diff --git a/examples/Animometer.cpp b/examples/Animometer.cpp
index dfd041c..5c197c4 100644
--- a/examples/Animometer.cpp
+++ b/examples/Animometer.cpp
@@ -18,8 +18,8 @@
 #include "utils/SystemUtils.h"
 #include "utils/WGPUHelpers.h"
 
-#include <cstdlib>
 #include <cstdio>
+#include <cstdlib>
 #include <vector>
 
 wgpu::Device device;
@@ -138,8 +138,7 @@
     bufferDesc.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Uniform;
     ubo = device.CreateBuffer(&bufferDesc);
 
-    bindGroup =
-        utils::MakeBindGroup(device, bgl, {{0, ubo, 0, sizeof(ShaderData)}});
+    bindGroup = utils::MakeBindGroup(device, bgl, {{0, ubo, 0, sizeof(ShaderData)}});
 }
 
 void frame() {
diff --git a/examples/BUILD.gn b/examples/BUILD.gn
index 39ef9c5..96ae72f 100644
--- a/examples/BUILD.gn
+++ b/examples/BUILD.gn
@@ -49,9 +49,7 @@
 # Template for samples to avoid listing dawn_sample_utils as a dep every time
 template("dawn_sample") {
   executable(target_name) {
-    deps = [
-      ":dawn_sample_utils",
-    ]
+    deps = [ ":dawn_sample_utils" ]
     forward_variables_from(invoker, "*", [ "deps" ])
 
     if (defined(invoker.deps)) {
@@ -61,43 +59,27 @@
 }
 
 dawn_sample("CppHelloTriangle") {
-  sources = [
-    "CppHelloTriangle.cpp",
-  ]
+  sources = [ "CppHelloTriangle.cpp" ]
 }
 
 dawn_sample("CHelloTriangle") {
-  sources = [
-    "CHelloTriangle.cpp",
-  ]
+  sources = [ "CHelloTriangle.cpp" ]
 }
 
 dawn_sample("ComputeBoids") {
-  sources = [
-    "ComputeBoids.cpp",
-  ]
-  deps = [
-    "${dawn_root}/third_party/gn/glm",
-  ]
+  sources = [ "ComputeBoids.cpp" ]
+  deps = [ "${dawn_root}/third_party/gn/glm" ]
 }
 
 dawn_sample("Animometer") {
-  sources = [
-    "Animometer.cpp",
-  ]
+  sources = [ "Animometer.cpp" ]
 }
 
 dawn_sample("CubeReflection") {
-  sources = [
-    "CubeReflection.cpp",
-  ]
-  deps = [
-    "${dawn_root}/third_party/gn/glm",
-  ]
+  sources = [ "CubeReflection.cpp" ]
+  deps = [ "${dawn_root}/third_party/gn/glm" ]
 }
 
 dawn_sample("ManualSwapChainTest") {
-  sources = [
-    "ManualSwapChainTest.cpp",
-  ]
+  sources = [ "ManualSwapChainTest.cpp" ]
 }
diff --git a/examples/CHelloTriangle.cpp b/examples/CHelloTriangle.cpp
index 048fba1..22d8202 100644
--- a/examples/CHelloTriangle.cpp
+++ b/examples/CHelloTriangle.cpp
@@ -120,7 +120,7 @@
     {
         colorAttachment.attachment = backbufferView;
         colorAttachment.resolveTarget = nullptr;
-        colorAttachment.clearColor = { 0.0f, 0.0f, 0.0f, 0.0f };
+        colorAttachment.clearColor = {0.0f, 0.0f, 0.0f, 0.0f};
         colorAttachment.loadOp = WGPULoadOp_Clear;
         colorAttachment.storeOp = WGPUStoreOp_Store;
         renderpassInfo.colorAttachmentCount = 1;
diff --git a/examples/ComputeBoids.cpp b/examples/ComputeBoids.cpp
index 59538df..f958ab4 100644
--- a/examples/ComputeBoids.cpp
+++ b/examples/ComputeBoids.cpp
@@ -67,7 +67,7 @@
     modelBuffer =
         utils::CreateBufferFromData(device, model, sizeof(model), wgpu::BufferUsage::Vertex);
 
-    SimParams params = { 0.04f, 0.1f, 0.025f, 0.025f, 0.02f, 0.05f, 0.005f, kNumParticles };
+    SimParams params = {0.04f, 0.1f, 0.025f, 0.025f, 0.02f, 0.05f, 0.005f, kNumParticles};
     updateParams =
         utils::CreateBufferFromData(device, &params, sizeof(params), wgpu::BufferUsage::Uniform);
 
@@ -75,8 +75,7 @@
     {
         std::mt19937 generator;
         std::uniform_real_distribution<float> dist(-1.0f, 1.0f);
-        for (auto& p : initialParticles)
-        {
+        for (auto& p : initialParticles) {
             p.pos = glm::vec2(dist(generator), dist(generator));
             p.vel = glm::vec2(dist(generator), dist(generator)) * 0.1f;
         }
@@ -253,11 +252,13 @@
     updatePipeline = device.CreateComputePipeline(&csDesc);
 
     for (uint32_t i = 0; i < 2; ++i) {
-        updateBGs[i] = utils::MakeBindGroup(device, bgl, {
-            {0, updateParams, 0, sizeof(SimParams)},
-            {1, particleBuffers[i], 0, kNumParticles * sizeof(Particle)},
-            {2, particleBuffers[(i + 1) % 2], 0, kNumParticles * sizeof(Particle)},
-        });
+        updateBGs[i] = utils::MakeBindGroup(
+            device, bgl,
+            {
+                {0, updateParams, 0, sizeof(SimParams)},
+                {1, particleBuffers[i], 0, kNumParticles * sizeof(Particle)},
+                {2, particleBuffers[(i + 1) % 2], 0, kNumParticles * sizeof(Particle)},
+            });
     }
 }
 
diff --git a/examples/CppHelloTriangle.cpp b/examples/CppHelloTriangle.cpp
index fbc598d..378afa8 100644
--- a/examples/CppHelloTriangle.cpp
+++ b/examples/CppHelloTriangle.cpp
@@ -36,15 +36,15 @@
 
 void initBuffers() {
     static const uint32_t indexData[3] = {
-        0, 1, 2,
+        0,
+        1,
+        2,
     };
     indexBuffer =
         utils::CreateBufferFromData(device, indexData, sizeof(indexData), wgpu::BufferUsage::Index);
 
     static const float vertexData[12] = {
-        0.0f, 0.5f, 0.0f, 1.0f,
-        -0.5f, -0.5f, 0.0f, 1.0f,
-        0.5f, -0.5f, 0.0f, 1.0f,
+        0.0f, 0.5f, 0.0f, 1.0f, -0.5f, -0.5f, 0.0f, 1.0f, 0.5f, -0.5f, 0.0f, 1.0f,
     };
     vertexBuffer = utils::CreateBufferFromData(device, vertexData, sizeof(vertexData),
                                                wgpu::BufferUsage::Vertex);
@@ -141,17 +141,19 @@
 
     wgpu::TextureView view = texture.CreateView();
 
-    bindGroup = utils::MakeBindGroup(device, bgl, {
-        {0, sampler},
-        {1, view}
-    });
+    bindGroup = utils::MakeBindGroup(device, bgl, {{0, sampler}, {1, view}});
 }
 
-struct {uint32_t a; float b;} s;
+struct {
+    uint32_t a;
+    float b;
+} s;
 void frame() {
     s.a = (s.a + 1) % 256;
     s.b += 0.02f;
-    if (s.b >= 1.0f) {s.b = 0.0f;}
+    if (s.b >= 1.0f) {
+        s.b = 0.0f;
+    }
 
     wgpu::TextureView backbufferView = swapchain.GetCurrentTextureView();
     utils::ComboRenderPassDescriptor renderPass({backbufferView}, depthStencilView);
diff --git a/examples/CubeReflection.cpp b/examples/CubeReflection.cpp
index becec87..4ff18e0 100644
--- a/examples/CubeReflection.cpp
+++ b/examples/CubeReflection.cpp
@@ -18,10 +18,10 @@
 #include "utils/SystemUtils.h"
 #include "utils/WGPUHelpers.h"
 
-#include <vector>
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
+#include <vector>
 
 wgpu::Device device;
 
@@ -43,67 +43,44 @@
 wgpu::RenderPipeline reflectionPipeline;
 
 void initBuffers() {
-    static const uint32_t indexData[6*6] = {
-        0, 1, 2,
-        0, 2, 3,
+    static const uint32_t indexData[6 * 6] = {0,  1,  2,  0,  2,  3,
 
-        4, 5, 6,
-        4, 6, 7,
+                                              4,  5,  6,  4,  6,  7,
 
-        8, 9, 10,
-        8, 10, 11,
+                                              8,  9,  10, 8,  10, 11,
 
-        12, 13, 14,
-        12, 14, 15,
+                                              12, 13, 14, 12, 14, 15,
 
-        16, 17, 18,
-        16, 18, 19,
+                                              16, 17, 18, 16, 18, 19,
 
-        20, 21, 22,
-        20, 22, 23
-    };
+                                              20, 21, 22, 20, 22, 23};
     indexBuffer =
         utils::CreateBufferFromData(device, indexData, sizeof(indexData), wgpu::BufferUsage::Index);
 
     static const float vertexData[6 * 4 * 6] = {
-        -1.0, -1.0,  1.0,    1.0, 0.0, 0.0,
-        1.0, -1.0,  1.0,    1.0, 0.0, 0.0,
-        1.0,  1.0,  1.0,    1.0, 0.0, 0.0,
-        -1.0,  1.0,  1.0,    1.0, 0.0, 0.0,
+        -1.0, -1.0, 1.0,  1.0, 0.0, 0.0, 1.0,  -1.0, 1.0,  1.0, 0.0, 0.0,
+        1.0,  1.0,  1.0,  1.0, 0.0, 0.0, -1.0, 1.0,  1.0,  1.0, 0.0, 0.0,
 
-        -1.0, -1.0, -1.0,    1.0, 1.0, 0.0,
-        -1.0,  1.0, -1.0,    1.0, 1.0, 0.0,
-        1.0,  1.0, -1.0,    1.0, 1.0, 0.0,
-        1.0, -1.0, -1.0,    1.0, 1.0, 0.0,
+        -1.0, -1.0, -1.0, 1.0, 1.0, 0.0, -1.0, 1.0,  -1.0, 1.0, 1.0, 0.0,
+        1.0,  1.0,  -1.0, 1.0, 1.0, 0.0, 1.0,  -1.0, -1.0, 1.0, 1.0, 0.0,
 
-        -1.0,  1.0, -1.0,    1.0, 0.0, 1.0,
-        -1.0,  1.0,  1.0,    1.0, 0.0, 1.0,
-        1.0,  1.0,  1.0,    1.0, 0.0, 1.0,
-        1.0,  1.0, -1.0,    1.0, 0.0, 1.0,
+        -1.0, 1.0,  -1.0, 1.0, 0.0, 1.0, -1.0, 1.0,  1.0,  1.0, 0.0, 1.0,
+        1.0,  1.0,  1.0,  1.0, 0.0, 1.0, 1.0,  1.0,  -1.0, 1.0, 0.0, 1.0,
 
-        -1.0, -1.0, -1.0,    0.0, 1.0, 0.0,
-        1.0, -1.0, -1.0,    0.0, 1.0, 0.0,
-        1.0, -1.0,  1.0,    0.0, 1.0, 0.0,
-        -1.0, -1.0,  1.0,    0.0, 1.0, 0.0,
+        -1.0, -1.0, -1.0, 0.0, 1.0, 0.0, 1.0,  -1.0, -1.0, 0.0, 1.0, 0.0,
+        1.0,  -1.0, 1.0,  0.0, 1.0, 0.0, -1.0, -1.0, 1.0,  0.0, 1.0, 0.0,
 
-        1.0, -1.0, -1.0,    0.0, 1.0, 1.0,
-        1.0,  1.0, -1.0,    0.0, 1.0, 1.0,
-        1.0,  1.0,  1.0,    0.0, 1.0, 1.0,
-        1.0, -1.0,  1.0,    0.0, 1.0, 1.0,
+        1.0,  -1.0, -1.0, 0.0, 1.0, 1.0, 1.0,  1.0,  -1.0, 0.0, 1.0, 1.0,
+        1.0,  1.0,  1.0,  0.0, 1.0, 1.0, 1.0,  -1.0, 1.0,  0.0, 1.0, 1.0,
 
-        -1.0, -1.0, -1.0,    1.0, 1.0, 1.0,
-        -1.0, -1.0,  1.0,    1.0, 1.0, 1.0,
-        -1.0,  1.0,  1.0,    1.0, 1.0, 1.0,
-        -1.0,  1.0, -1.0,    1.0, 1.0, 1.0
-    };
+        -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, 1.0,  1.0, 1.0, 1.0,
+        -1.0, 1.0,  1.0,  1.0, 1.0, 1.0, -1.0, 1.0,  -1.0, 1.0, 1.0, 1.0};
     vertexBuffer = utils::CreateBufferFromData(device, vertexData, sizeof(vertexData),
                                                wgpu::BufferUsage::Vertex);
 
     static const float planeData[6 * 4] = {
-        -2.0, -1.0, -2.0,    0.5, 0.5, 0.5,
-        2.0, -1.0, -2.0,    0.5, 0.5, 0.5,
-        2.0, -1.0,  2.0,    0.5, 0.5, 0.5,
-        -2.0, -1.0,  2.0,    0.5, 0.5, 0.5,
+        -2.0, -1.0, -2.0, 0.5, 0.5, 0.5, 2.0,  -1.0, -2.0, 0.5, 0.5, 0.5,
+        2.0,  -1.0, 2.0,  0.5, 0.5, 0.5, -2.0, -1.0, 2.0,  0.5, 0.5, 0.5,
     };
     planeBuffer = utils::CreateBufferFromData(device, planeData, sizeof(planeData),
                                               wgpu::BufferUsage::Vertex);
@@ -191,15 +168,13 @@
     transformBuffer[1] = utils::CreateBufferFromData(device, &transform, sizeof(glm::mat4),
                                                      wgpu::BufferUsage::Uniform);
 
-    bindGroup[0] = utils::MakeBindGroup(device, bgl, {
-        {0, cameraBuffer, 0, sizeof(CameraData)},
-        {1, transformBuffer[0], 0, sizeof(glm::mat4)}
-    });
+    bindGroup[0] = utils::MakeBindGroup(
+        device, bgl,
+        {{0, cameraBuffer, 0, sizeof(CameraData)}, {1, transformBuffer[0], 0, sizeof(glm::mat4)}});
 
-    bindGroup[1] = utils::MakeBindGroup(device, bgl, {
-        {0, cameraBuffer, 0, sizeof(CameraData)},
-        {1, transformBuffer[1], 0, sizeof(glm::mat4)}
-    });
+    bindGroup[1] = utils::MakeBindGroup(
+        device, bgl,
+        {{0, cameraBuffer, 0, sizeof(CameraData)}, {1, transformBuffer[1], 0, sizeof(glm::mat4)}});
 
     depthStencilView = CreateDefaultDepthStencilView(device);
 
@@ -250,17 +225,20 @@
     cameraData.proj = glm::perspective(glm::radians(45.0f), 1.f, 1.0f, 100.0f);
 }
 
-struct {uint32_t a; float b;} s;
+struct {
+    uint32_t a;
+    float b;
+} s;
 void frame() {
     s.a = (s.a + 1) % 256;
     s.b += 0.01f;
-    if (s.b >= 1.0f) {s.b = 0.0f;}
+    if (s.b >= 1.0f) {
+        s.b = 0.0f;
+    }
 
-    cameraData.view = glm::lookAt(
-        glm::vec3(8.f * std::sin(glm::radians(s.b * 360.f)), 2.f, 8.f * std::cos(glm::radians(s.b * 360.f))),
-        glm::vec3(0.0f, 0.0f, 0.0f),
-        glm::vec3(0.0f, 1.0f, 0.0f)
-    );
+    cameraData.view = glm::lookAt(glm::vec3(8.f * std::sin(glm::radians(s.b * 360.f)), 2.f,
+                                            8.f * std::cos(glm::radians(s.b * 360.f))),
+                                  glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
 
     queue.WriteBuffer(cameraBuffer, 0, &cameraData, sizeof(CameraData));
 
diff --git a/examples/ManualSwapChainTest.cpp b/examples/ManualSwapChainTest.cpp
index ee924d3..9e3990d 100644
--- a/examples/ManualSwapChainTest.cpp
+++ b/examples/ManualSwapChainTest.cpp
@@ -150,7 +150,8 @@
 
         utils::ComboRenderPassDescriptor desc({view});
         desc.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear;
-        desc.cColorAttachments[0].clearColor = {data->clearCycle, 1.0f - data->clearCycle, 0.0f, 1.0f};
+        desc.cColorAttachments[0].clearColor = {data->clearCycle, 1.0f - data->clearCycle, 0.0f,
+                                                1.0f};
 
         wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&desc);
         pass.EndPass();
diff --git a/examples/SampleUtils.cpp b/examples/SampleUtils.cpp
index 17b7c9e..ee7e006 100644
--- a/examples/SampleUtils.cpp
+++ b/examples/SampleUtils.cpp
@@ -60,7 +60,7 @@
 enum class CmdBufType {
     None,
     Terrible,
-    //TODO(cwallez@chromium.org) double terrible cmdbuf
+    // TODO(cwallez@chromium.org): double terrible cmdbuf
 };
 
 // Default to D3D12, Metal, Vulkan, OpenGL in that order as D3D12 and Metal are the preferred on
@@ -74,7 +74,7 @@
 #elif defined(DAWN_ENABLE_BACKEND_OPENGL)
 static wgpu::BackendType backendType = wgpu::BackendType::OpenGL;
 #else
-    #error
+#    error
 #endif
 
 static CmdBufType cmdBufType = CmdBufType::Terrible;
@@ -136,31 +136,29 @@
             cDevice = backendDevice;
             break;
 
-        case CmdBufType::Terrible:
-            {
-                c2sBuf = new utils::TerribleCommandBuffer();
-                s2cBuf = new utils::TerribleCommandBuffer();
+        case CmdBufType::Terrible: {
+            c2sBuf = new utils::TerribleCommandBuffer();
+            s2cBuf = new utils::TerribleCommandBuffer();
 
-                dawn_wire::WireServerDescriptor serverDesc = {};
-                serverDesc.device = backendDevice;
-                serverDesc.procs = &backendProcs;
-                serverDesc.serializer = s2cBuf;
+            dawn_wire::WireServerDescriptor serverDesc = {};
+            serverDesc.device = backendDevice;
+            serverDesc.procs = &backendProcs;
+            serverDesc.serializer = s2cBuf;
 
-                wireServer = new dawn_wire::WireServer(serverDesc);
-                c2sBuf->SetHandler(wireServer);
+            wireServer = new dawn_wire::WireServer(serverDesc);
+            c2sBuf->SetHandler(wireServer);
 
-                dawn_wire::WireClientDescriptor clientDesc = {};
-                clientDesc.serializer = c2sBuf;
+            dawn_wire::WireClientDescriptor clientDesc = {};
+            clientDesc.serializer = c2sBuf;
 
-                wireClient = new dawn_wire::WireClient(clientDesc);
-                WGPUDevice clientDevice = wireClient->GetDevice();
-                DawnProcTable clientProcs = dawn_wire::WireClient::GetProcs();
-                s2cBuf->SetHandler(wireClient);
+            wireClient = new dawn_wire::WireClient(clientDesc);
+            WGPUDevice clientDevice = wireClient->GetDevice();
+            DawnProcTable clientProcs = dawn_wire::WireClient::GetProcs();
+            s2cBuf->SetHandler(wireClient);
 
-                procs = clientProcs;
-                cDevice = clientDevice;
-            }
-            break;
+            procs = clientProcs;
+            cDevice = clientDevice;
+        } break;
     }
 
     dawnProcSetProcs(&procs);
@@ -221,7 +219,8 @@
                 backendType = wgpu::BackendType::Vulkan;
                 continue;
             }
-            fprintf(stderr, "--backend expects a backend name (opengl, metal, d3d12, null, vulkan)\n");
+            fprintf(stderr,
+                    "--backend expects a backend name (opengl, metal, d3d12, null, vulkan)\n");
             return false;
         }
         if (std::string("-c") == argv[i] || std::string("--command-buffer") == argv[i]) {
diff --git a/src/tests/end2end/BasicTests.cpp b/src/tests/end2end/BasicTests.cpp
index 98ecb2e..4a0409f 100644
--- a/src/tests/end2end/BasicTests.cpp
+++ b/src/tests/end2end/BasicTests.cpp
@@ -16,8 +16,7 @@
 
 #include "utils/WGPUHelpers.h"
 
-class BasicTests : public DawnTest {
-};
+class BasicTests : public DawnTest {};
 
 // Test adapter filter by vendor id.
 TEST_P(BasicTests, VendorIdFilter) {
diff --git a/src/tests/end2end/BindGroupTests.cpp b/src/tests/end2end/BindGroupTests.cpp
index 118a4ee..780f482 100644
--- a/src/tests/end2end/BindGroupTests.cpp
+++ b/src/tests/end2end/BindGroupTests.cpp
@@ -22,102 +22,102 @@
 constexpr static uint32_t kRTSize = 8;
 
 class BindGroupTests : public DawnTest {
-protected:
-  wgpu::CommandBuffer CreateSimpleComputeCommandBuffer(const wgpu::ComputePipeline& pipeline,
-                                                       const wgpu::BindGroup& bindGroup) {
-      wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-      wgpu::ComputePassEncoder pass = encoder.BeginComputePass();
-      pass.SetPipeline(pipeline);
-      pass.SetBindGroup(0, bindGroup);
-      pass.Dispatch(1);
-      pass.EndPass();
-      return encoder.Finish();
-  }
+  protected:
+    wgpu::CommandBuffer CreateSimpleComputeCommandBuffer(const wgpu::ComputePipeline& pipeline,
+                                                         const wgpu::BindGroup& bindGroup) {
+        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+        wgpu::ComputePassEncoder pass = encoder.BeginComputePass();
+        pass.SetPipeline(pipeline);
+        pass.SetBindGroup(0, bindGroup);
+        pass.Dispatch(1);
+        pass.EndPass();
+        return encoder.Finish();
+    }
 
-  wgpu::PipelineLayout MakeBasicPipelineLayout(
-      std::vector<wgpu::BindGroupLayout> bindingInitializer) const {
-      wgpu::PipelineLayoutDescriptor descriptor;
+    wgpu::PipelineLayout MakeBasicPipelineLayout(
+        std::vector<wgpu::BindGroupLayout> bindingInitializer) const {
+        wgpu::PipelineLayoutDescriptor descriptor;
 
-      descriptor.bindGroupLayoutCount = bindingInitializer.size();
-      descriptor.bindGroupLayouts = bindingInitializer.data();
+        descriptor.bindGroupLayoutCount = bindingInitializer.size();
+        descriptor.bindGroupLayouts = bindingInitializer.data();
 
-      return device.CreatePipelineLayout(&descriptor);
-  }
+        return device.CreatePipelineLayout(&descriptor);
+    }
 
-  wgpu::ShaderModule MakeSimpleVSModule() const {
-      return utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+    wgpu::ShaderModule MakeSimpleVSModule() const {
+        return utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
         #version 450
         void main() {
             const vec2 pos[3] = vec2[3](vec2(-1.f, 1.f), vec2(1.f, 1.f), vec2(-1.f, -1.f));
             gl_Position = vec4(pos[gl_VertexIndex], 0.f, 1.f);
         })");
-  }
+    }
 
-  wgpu::ShaderModule MakeFSModule(std::vector<wgpu::BindingType> bindingTypes) const {
-      ASSERT(bindingTypes.size() <= kMaxBindGroups);
+    wgpu::ShaderModule MakeFSModule(std::vector<wgpu::BindingType> bindingTypes) const {
+        ASSERT(bindingTypes.size() <= kMaxBindGroups);
 
-      std::ostringstream fs;
-      fs << R"(
+        std::ostringstream fs;
+        fs << R"(
         #version 450
         layout(location = 0) out vec4 fragColor;
         )";
 
-      for (size_t i = 0; i < bindingTypes.size(); ++i) {
-          switch (bindingTypes[i]) {
-              case wgpu::BindingType::UniformBuffer:
-                  fs << "layout (std140, set = " << i << ", binding = 0) uniform UniformBuffer" << i
-                     << R"( {
+        for (size_t i = 0; i < bindingTypes.size(); ++i) {
+            switch (bindingTypes[i]) {
+                case wgpu::BindingType::UniformBuffer:
+                    fs << "layout (std140, set = " << i << ", binding = 0) uniform UniformBuffer"
+                       << i << R"( {
                         vec4 color;
                     } buffer)"
-                     << i << ";\n";
-                  break;
-              case wgpu::BindingType::StorageBuffer:
-                  fs << "layout (std430, set = " << i << ", binding = 0) buffer StorageBuffer" << i
-                     << R"( {
+                       << i << ";\n";
+                    break;
+                case wgpu::BindingType::StorageBuffer:
+                    fs << "layout (std430, set = " << i << ", binding = 0) buffer StorageBuffer"
+                       << i << R"( {
                         vec4 color;
                     } buffer)"
-                     << i << ";\n";
-                  break;
-              default:
-                  UNREACHABLE();
-          }
-      }
+                       << i << ";\n";
+                    break;
+                default:
+                    UNREACHABLE();
+            }
+        }
 
-      fs << R"(
+        fs << R"(
         void main() {
             fragColor = vec4(0.0);
         )";
-      for (size_t i = 0; i < bindingTypes.size(); ++i) {
-          fs << "fragColor += buffer" << i << ".color;\n";
-      }
-      fs << "}\n";
+        for (size_t i = 0; i < bindingTypes.size(); ++i) {
+            fs << "fragColor += buffer" << i << ".color;\n";
+        }
+        fs << "}\n";
 
-      return utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment,
-                                       fs.str().c_str());
-  }
+        return utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment,
+                                         fs.str().c_str());
+    }
 
-  wgpu::RenderPipeline MakeTestPipeline(const utils::BasicRenderPass& renderPass,
-                                        std::vector<wgpu::BindingType> bindingTypes,
-                                        std::vector<wgpu::BindGroupLayout> bindGroupLayouts) {
-      wgpu::ShaderModule vsModule = MakeSimpleVSModule();
-      wgpu::ShaderModule fsModule = MakeFSModule(bindingTypes);
+    wgpu::RenderPipeline MakeTestPipeline(const utils::BasicRenderPass& renderPass,
+                                          std::vector<wgpu::BindingType> bindingTypes,
+                                          std::vector<wgpu::BindGroupLayout> bindGroupLayouts) {
+        wgpu::ShaderModule vsModule = MakeSimpleVSModule();
+        wgpu::ShaderModule fsModule = MakeFSModule(bindingTypes);
 
-      wgpu::PipelineLayout pipelineLayout = MakeBasicPipelineLayout(bindGroupLayouts);
+        wgpu::PipelineLayout pipelineLayout = MakeBasicPipelineLayout(bindGroupLayouts);
 
-      utils::ComboRenderPipelineDescriptor pipelineDescriptor(device);
-      pipelineDescriptor.layout = pipelineLayout;
-      pipelineDescriptor.vertexStage.module = vsModule;
-      pipelineDescriptor.cFragmentStage.module = fsModule;
-      pipelineDescriptor.cColorStates[0].format = renderPass.colorFormat;
-      pipelineDescriptor.cColorStates[0].colorBlend.operation = wgpu::BlendOperation::Add;
-      pipelineDescriptor.cColorStates[0].colorBlend.srcFactor = wgpu::BlendFactor::One;
-      pipelineDescriptor.cColorStates[0].colorBlend.dstFactor = wgpu::BlendFactor::One;
-      pipelineDescriptor.cColorStates[0].alphaBlend.operation = wgpu::BlendOperation::Add;
-      pipelineDescriptor.cColorStates[0].alphaBlend.srcFactor = wgpu::BlendFactor::One;
-      pipelineDescriptor.cColorStates[0].alphaBlend.dstFactor = wgpu::BlendFactor::One;
+        utils::ComboRenderPipelineDescriptor pipelineDescriptor(device);
+        pipelineDescriptor.layout = pipelineLayout;
+        pipelineDescriptor.vertexStage.module = vsModule;
+        pipelineDescriptor.cFragmentStage.module = fsModule;
+        pipelineDescriptor.cColorStates[0].format = renderPass.colorFormat;
+        pipelineDescriptor.cColorStates[0].colorBlend.operation = wgpu::BlendOperation::Add;
+        pipelineDescriptor.cColorStates[0].colorBlend.srcFactor = wgpu::BlendFactor::One;
+        pipelineDescriptor.cColorStates[0].colorBlend.dstFactor = wgpu::BlendFactor::One;
+        pipelineDescriptor.cColorStates[0].alphaBlend.operation = wgpu::BlendOperation::Add;
+        pipelineDescriptor.cColorStates[0].alphaBlend.srcFactor = wgpu::BlendFactor::One;
+        pipelineDescriptor.cColorStates[0].alphaBlend.dstFactor = wgpu::BlendFactor::One;
 
-      return device.CreateRenderPipeline(&pipelineDescriptor);
-  }
+        return device.CreateRenderPipeline(&pipelineDescriptor);
+    }
 };
 
 // Test a bindgroup reused in two command buffers in the same call to queue.Submit().
@@ -195,10 +195,10 @@
     };
     ASSERT(offsetof(Data, color) == 256);
     constexpr float dummy = 0.0f;
-    Data data {
-        { 1.f, 0.f, dummy, dummy, 0.f, 1.0f, dummy, dummy },
-        { 0 },
-        { 0.f, 1.f, 0.f, 1.f },
+    Data data{
+        {1.f, 0.f, dummy, dummy, 0.f, 1.0f, dummy, dummy},
+        {0},
+        {0.f, 1.f, 0.f, 1.f},
     };
     wgpu::Buffer buffer =
         utils::CreateBufferFromData(device, &data, sizeof(data), wgpu::BufferUsage::Uniform);
@@ -219,15 +219,15 @@
     RGBA8 filled(0, 255, 0, 255);
     RGBA8 notFilled(0, 0, 0, 0);
     uint32_t min = 1, max = kRTSize - 3;
-    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color,    min, min);
-    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color,    max, min);
-    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color,    min, max);
+    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, min, min);
+    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, max, min);
+    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, min, max);
     EXPECT_PIXEL_RGBA8_EQ(notFilled, renderPass.color, max, max);
 }
 
-// Test a bindgroup containing a UBO in the vertex shader and a sampler and texture in the fragment shader.
-// In D3D12 for example, these different types of bindings end up in different namespaces, but the register
-// offsets used must match between the shader module and descriptor range.
+// Test a bindgroup containing a UBO in the vertex shader and a sampler and texture in the fragment
+// shader. In D3D12 for example, these different types of bindings end up in different namespaces,
+// but the register offsets used must match between the shader module and descriptor range.
 TEST_P(BindGroupTests, UBOSamplerAndTexture) {
     utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
 
@@ -260,7 +260,7 @@
     wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDescriptor);
 
     constexpr float dummy = 0.0f;
-    constexpr float transform[] = { 1.f, 0.f, dummy, dummy, 0.f, 1.f, dummy, dummy };
+    constexpr float transform[] = {1.f, 0.f, dummy, dummy, 0.f, 1.f, dummy, dummy};
     wgpu::Buffer buffer = utils::CreateBufferFromData(device, &transform, sizeof(transform),
                                                       wgpu::BufferUsage::Uniform);
 
@@ -320,9 +320,9 @@
     RGBA8 filled(0, 255, 0, 255);
     RGBA8 notFilled(0, 0, 0, 0);
     uint32_t min = 1, max = kRTSize - 3;
-    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color,    min, min);
-    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color,    max, min);
-    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color,    min, max);
+    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, min, min);
+    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, max, min);
+    EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, min, max);
     EXPECT_PIXEL_RGBA8_EQ(notFilled, renderPass.color, max, max);
 }
 
@@ -1091,4 +1091,8 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8::kGreen, renderPass.color, 0, 0);
 }
 
-DAWN_INSTANTIATE_TEST(BindGroupTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(BindGroupTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/BufferTests.cpp b/src/tests/end2end/BufferTests.cpp
index f010be6..4b626ee 100644
--- a/src/tests/end2end/BufferTests.cpp
+++ b/src/tests/end2end/BufferTests.cpp
@@ -17,34 +17,34 @@
 #include <cstring>
 
 class BufferMapReadTests : public DawnTest {
-    protected:
-      static void MapReadCallback(WGPUBufferMapAsyncStatus status,
-                                  const void* data,
-                                  uint64_t,
-                                  void* userdata) {
-          ASSERT_EQ(WGPUBufferMapAsyncStatus_Success, status);
-          ASSERT_NE(nullptr, data);
+  protected:
+    static void MapReadCallback(WGPUBufferMapAsyncStatus status,
+                                const void* data,
+                                uint64_t,
+                                void* userdata) {
+        ASSERT_EQ(WGPUBufferMapAsyncStatus_Success, status);
+        ASSERT_NE(nullptr, data);
 
-          static_cast<BufferMapReadTests*>(userdata)->mappedData = data;
-      }
+        static_cast<BufferMapReadTests*>(userdata)->mappedData = data;
+    }
 
-      const void* MapReadAsyncAndWait(const wgpu::Buffer& buffer) {
-          buffer.MapReadAsync(MapReadCallback, this);
+    const void* MapReadAsyncAndWait(const wgpu::Buffer& buffer) {
+        buffer.MapReadAsync(MapReadCallback, this);
 
-          while (mappedData == nullptr) {
-              WaitABit();
-          }
+        while (mappedData == nullptr) {
+            WaitABit();
+        }
 
-          return mappedData;
-      }
+        return mappedData;
+    }
 
-      void UnmapBuffer(const wgpu::Buffer& buffer) {
-          buffer.Unmap();
-          mappedData = nullptr;
-      }
+    void UnmapBuffer(const wgpu::Buffer& buffer) {
+        buffer.Unmap();
+        mappedData = nullptr;
+    }
 
-    private:
-        const void* mappedData = nullptr;
+  private:
+    const void* mappedData = nullptr;
 };
 
 // Test that the simplest map read works.
@@ -145,41 +145,45 @@
     UnmapBuffer(buffer);
 }
 
-DAWN_INSTANTIATE_TEST(BufferMapReadTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(BufferMapReadTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 class BufferMapWriteTests : public DawnTest {
-    protected:
-      static void MapWriteCallback(WGPUBufferMapAsyncStatus status,
-                                   void* data,
-                                   uint64_t,
-                                   void* userdata) {
-          ASSERT_EQ(WGPUBufferMapAsyncStatus_Success, status);
-          ASSERT_NE(nullptr, data);
+  protected:
+    static void MapWriteCallback(WGPUBufferMapAsyncStatus status,
+                                 void* data,
+                                 uint64_t,
+                                 void* userdata) {
+        ASSERT_EQ(WGPUBufferMapAsyncStatus_Success, status);
+        ASSERT_NE(nullptr, data);
 
-          static_cast<BufferMapWriteTests*>(userdata)->mappedData = data;
-      }
+        static_cast<BufferMapWriteTests*>(userdata)->mappedData = data;
+    }
 
-      void* MapWriteAsyncAndWait(const wgpu::Buffer& buffer) {
-          buffer.MapWriteAsync(MapWriteCallback, this);
+    void* MapWriteAsyncAndWait(const wgpu::Buffer& buffer) {
+        buffer.MapWriteAsync(MapWriteCallback, this);
 
-          while (mappedData == nullptr) {
-              WaitABit();
-          }
+        while (mappedData == nullptr) {
+            WaitABit();
+        }
 
-          // Ensure the prior write's status is updated.
-          void* resultPointer = mappedData;
-          mappedData = nullptr;
+        // Ensure the prior write's status is updated.
+        void* resultPointer = mappedData;
+        mappedData = nullptr;
 
-          return resultPointer;
-      }
+        return resultPointer;
+    }
 
-      void UnmapBuffer(const wgpu::Buffer& buffer) {
-          buffer.Unmap();
-          mappedData = nullptr;
-      }
+    void UnmapBuffer(const wgpu::Buffer& buffer) {
+        buffer.Unmap();
+        mappedData = nullptr;
+    }
 
-    private:
-        void* mappedData = nullptr;
+  private:
+    void* mappedData = nullptr;
 };
 
 // Test that the simplest map write works.
@@ -307,64 +311,68 @@
     UnmapBuffer(buffer);
 }
 
-DAWN_INSTANTIATE_TEST(BufferMapWriteTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(BufferMapWriteTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 class CreateBufferMappedTests : public DawnTest {
-    protected:
-      static void MapReadCallback(WGPUBufferMapAsyncStatus status,
-                                  const void* data,
-                                  uint64_t,
-                                  void* userdata) {
-          ASSERT_EQ(WGPUBufferMapAsyncStatus_Success, status);
-          ASSERT_NE(nullptr, data);
+  protected:
+    static void MapReadCallback(WGPUBufferMapAsyncStatus status,
+                                const void* data,
+                                uint64_t,
+                                void* userdata) {
+        ASSERT_EQ(WGPUBufferMapAsyncStatus_Success, status);
+        ASSERT_NE(nullptr, data);
 
-          static_cast<CreateBufferMappedTests*>(userdata)->mappedData = data;
-      }
+        static_cast<CreateBufferMappedTests*>(userdata)->mappedData = data;
+    }
 
-      const void* MapReadAsyncAndWait(const wgpu::Buffer& buffer) {
-          buffer.MapReadAsync(MapReadCallback, this);
+    const void* MapReadAsyncAndWait(const wgpu::Buffer& buffer) {
+        buffer.MapReadAsync(MapReadCallback, this);
 
-          while (mappedData == nullptr) {
-              WaitABit();
-          }
+        while (mappedData == nullptr) {
+            WaitABit();
+        }
 
-          return mappedData;
-      }
+        return mappedData;
+    }
 
-      void UnmapBuffer(const wgpu::Buffer& buffer) {
-          buffer.Unmap();
-          mappedData = nullptr;
-      }
+    void UnmapBuffer(const wgpu::Buffer& buffer) {
+        buffer.Unmap();
+        mappedData = nullptr;
+    }
 
-      void CheckResultStartsZeroed(const wgpu::CreateBufferMappedResult& result, uint64_t size) {
-          ASSERT_EQ(result.dataLength, size);
-          for (uint64_t i = 0; i < result.dataLength; ++i) {
-              uint8_t value = *(reinterpret_cast<uint8_t*>(result.data) + i);
-              ASSERT_EQ(value, 0u);
-          }
-      }
+    void CheckResultStartsZeroed(const wgpu::CreateBufferMappedResult& result, uint64_t size) {
+        ASSERT_EQ(result.dataLength, size);
+        for (uint64_t i = 0; i < result.dataLength; ++i) {
+            uint8_t value = *(reinterpret_cast<uint8_t*>(result.data) + i);
+            ASSERT_EQ(value, 0u);
+        }
+    }
 
-      wgpu::CreateBufferMappedResult CreateBufferMapped(wgpu::BufferUsage usage, uint64_t size) {
-          wgpu::BufferDescriptor descriptor = {};
-          descriptor.size = size;
-          descriptor.usage = usage;
+    wgpu::CreateBufferMappedResult CreateBufferMapped(wgpu::BufferUsage usage, uint64_t size) {
+        wgpu::BufferDescriptor descriptor = {};
+        descriptor.size = size;
+        descriptor.usage = usage;
 
-          wgpu::CreateBufferMappedResult result = device.CreateBufferMapped(&descriptor);
-          CheckResultStartsZeroed(result, size);
-          return result;
-      }
+        wgpu::CreateBufferMappedResult result = device.CreateBufferMapped(&descriptor);
+        CheckResultStartsZeroed(result, size);
+        return result;
+    }
 
-      wgpu::CreateBufferMappedResult CreateBufferMappedWithData(wgpu::BufferUsage usage,
-                                                                const std::vector<uint32_t>& data) {
-          size_t byteLength = data.size() * sizeof(uint32_t);
-          wgpu::CreateBufferMappedResult result = CreateBufferMapped(usage, byteLength);
-          memcpy(result.data, data.data(), byteLength);
+    wgpu::CreateBufferMappedResult CreateBufferMappedWithData(wgpu::BufferUsage usage,
+                                                              const std::vector<uint32_t>& data) {
+        size_t byteLength = data.size() * sizeof(uint32_t);
+        wgpu::CreateBufferMappedResult result = CreateBufferMapped(usage, byteLength);
+        memcpy(result.data, data.data(), byteLength);
 
-          return result;
-      }
+        return result;
+    }
 
-    private:
-        const void* mappedData = nullptr;
+  private:
+    const void* mappedData = nullptr;
 };
 
 // Test that the simplest CreateBufferMapped works for MapWrite buffers.
diff --git a/src/tests/end2end/ClipSpaceTests.cpp b/src/tests/end2end/ClipSpaceTests.cpp
index be97ced..33c78e9 100644
--- a/src/tests/end2end/ClipSpaceTests.cpp
+++ b/src/tests/end2end/ClipSpaceTests.cpp
@@ -97,4 +97,8 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8::kGreen, colorTexture, 0, 0);
 }
 
-DAWN_INSTANTIATE_TEST(ClipSpaceTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(ClipSpaceTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/ColorStateTests.cpp b/src/tests/end2end/ColorStateTests.cpp
index f0fa1e5..b4f935d 100644
--- a/src/tests/end2end/ColorStateTests.cpp
+++ b/src/tests/end2end/ColorStateTests.cpp
@@ -758,8 +758,8 @@
         renderTargetViews[i] = renderTargets[i].CreateView();
     }
 
-    utils::ComboRenderPassDescriptor renderPass({renderTargetViews[0], renderTargetViews[1],
-                                                renderTargetViews[2], renderTargetViews[3]});
+    utils::ComboRenderPassDescriptor renderPass(
+        {renderTargetViews[0], renderTargetViews[1], renderTargetViews[2], renderTargetViews[3]});
 
     wgpu::ShaderModule fsModule =
         utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
@@ -1047,4 +1047,8 @@
     EXPECT_PIXEL_RGBA8_EQ(expected, renderPass.color, kRTSize / 2, kRTSize / 2);
 }
 
-DAWN_INSTANTIATE_TEST(ColorStateTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(ColorStateTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/ComputeCopyStorageBufferTests.cpp b/src/tests/end2end/ComputeCopyStorageBufferTests.cpp
index dcb762e..f127acd 100644
--- a/src/tests/end2end/ComputeCopyStorageBufferTests.cpp
+++ b/src/tests/end2end/ComputeCopyStorageBufferTests.cpp
@@ -173,7 +173,7 @@
 }
 
 DAWN_INSTANTIATE_TEST(ComputeCopyStorageBufferTests,
-                     D3D12Backend(),
-                     MetalBackend(),
-                     OpenGLBackend(),
-                     VulkanBackend());
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/ComputeSharedMemoryTests.cpp b/src/tests/end2end/ComputeSharedMemoryTests.cpp
index bb33856..a11c01a 100644
--- a/src/tests/end2end/ComputeSharedMemoryTests.cpp
+++ b/src/tests/end2end/ComputeSharedMemoryTests.cpp
@@ -98,7 +98,7 @@
 }
 
 DAWN_INSTANTIATE_TEST(ComputeSharedMemoryTests,
-                     D3D12Backend(),
-                     MetalBackend(),
-                     OpenGLBackend(),
-                     VulkanBackend());
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/CopyTests.cpp b/src/tests/end2end/CopyTests.cpp
index 5d592a1..75de2f6 100644
--- a/src/tests/end2end/CopyTests.cpp
+++ b/src/tests/end2end/CopyTests.cpp
@@ -21,164 +21,164 @@
 #include "utils/WGPUHelpers.h"
 
 class CopyTests : public DawnTest {
-    protected:
-      static constexpr wgpu::TextureFormat kTextureFormat = wgpu::TextureFormat::RGBA8Unorm;
+  protected:
+    static constexpr wgpu::TextureFormat kTextureFormat = wgpu::TextureFormat::RGBA8Unorm;
 
-      struct TextureSpec {
-          wgpu::Origin3D copyOrigin;
-          wgpu::Extent3D textureSize;
-          uint32_t level;
-      };
+    struct TextureSpec {
+        wgpu::Origin3D copyOrigin;
+        wgpu::Extent3D textureSize;
+        uint32_t level;
+    };
 
-        struct BufferSpec {
-            uint64_t size;
-            uint64_t offset;
-            uint32_t bytesPerRow;
-            uint32_t rowsPerImage;
-        };
+    struct BufferSpec {
+        uint64_t size;
+        uint64_t offset;
+        uint32_t bytesPerRow;
+        uint32_t rowsPerImage;
+    };
 
-        static std::vector<RGBA8> GetExpectedTextureData(
-            const utils::BufferTextureCopyLayout& layout) {
-            std::vector<RGBA8> textureData(layout.texelBlockCount);
-            for (uint32_t layer = 0; layer < layout.mipSize.depth; ++layer) {
-                const uint32_t texelIndexOffsetPerSlice = layout.texelBlocksPerImage * layer;
-                for (uint32_t y = 0; y < layout.mipSize.height; ++y) {
-                    for (uint32_t x = 0; x < layout.mipSize.width; ++x) {
-                        uint32_t i = x + y * layout.texelBlocksPerRow;
-                        textureData[texelIndexOffsetPerSlice + i] =
-                            RGBA8(static_cast<uint8_t>((x + layer * x) % 256),
-                                  static_cast<uint8_t>((y + layer * y) % 256),
-                                  static_cast<uint8_t>(x / 256), static_cast<uint8_t>(y / 256));
-                    }
-                }
-            }
-
-            return textureData;
-        }
-
-        static BufferSpec MinimumBufferSpec(uint32_t width,
-                                            uint32_t rowsPerImage,
-                                            uint32_t arrayLayer = 1,
-                                            bool testZeroRowsPerImage = true) {
-            const uint32_t bytesPerRow = utils::GetMinimumBytesPerRow(kTextureFormat, width);
-            const uint32_t totalBufferSize = utils::GetBytesInBufferTextureCopy(
-                kTextureFormat, width, bytesPerRow, rowsPerImage, arrayLayer);
-            uint32_t appliedRowsPerImage = testZeroRowsPerImage ? 0 : rowsPerImage;
-            return {totalBufferSize, 0, bytesPerRow, appliedRowsPerImage};
-        }
-
-        static void PackTextureData(const RGBA8* srcData, uint32_t width, uint32_t height, uint32_t srcTexelsPerRow, RGBA8* dstData, uint32_t dstTexelsPerRow) {
-            for (unsigned int y = 0; y < height; ++y) {
-                for (unsigned int x = 0; x < width; ++x) {
-                    unsigned int src = x + y * srcTexelsPerRow;
-                    unsigned int dst = x + y * dstTexelsPerRow;
-                    dstData[dst] = srcData[src];
+    static std::vector<RGBA8> GetExpectedTextureData(const utils::BufferTextureCopyLayout& layout) {
+        std::vector<RGBA8> textureData(layout.texelBlockCount);
+        for (uint32_t layer = 0; layer < layout.mipSize.depth; ++layer) {
+            const uint32_t texelIndexOffsetPerSlice = layout.texelBlocksPerImage * layer;
+            for (uint32_t y = 0; y < layout.mipSize.height; ++y) {
+                for (uint32_t x = 0; x < layout.mipSize.width; ++x) {
+                    uint32_t i = x + y * layout.texelBlocksPerRow;
+                    textureData[texelIndexOffsetPerSlice + i] =
+                        RGBA8(static_cast<uint8_t>((x + layer * x) % 256),
+                              static_cast<uint8_t>((y + layer * y) % 256),
+                              static_cast<uint8_t>(x / 256), static_cast<uint8_t>(y / 256));
                 }
             }
         }
+
+        return textureData;
+    }
+
+    static BufferSpec MinimumBufferSpec(uint32_t width,
+                                        uint32_t rowsPerImage,
+                                        uint32_t arrayLayer = 1,
+                                        bool testZeroRowsPerImage = true) {
+        const uint32_t bytesPerRow = utils::GetMinimumBytesPerRow(kTextureFormat, width);
+        const uint32_t totalBufferSize = utils::GetBytesInBufferTextureCopy(
+            kTextureFormat, width, bytesPerRow, rowsPerImage, arrayLayer);
+        uint32_t appliedRowsPerImage = testZeroRowsPerImage ? 0 : rowsPerImage;
+        return {totalBufferSize, 0, bytesPerRow, appliedRowsPerImage};
+    }
+
+    static void PackTextureData(const RGBA8* srcData,
+                                uint32_t width,
+                                uint32_t height,
+                                uint32_t srcTexelsPerRow,
+                                RGBA8* dstData,
+                                uint32_t dstTexelsPerRow) {
+        for (unsigned int y = 0; y < height; ++y) {
+            for (unsigned int x = 0; x < width; ++x) {
+                unsigned int src = x + y * srcTexelsPerRow;
+                unsigned int dst = x + y * dstTexelsPerRow;
+                dstData[dst] = srcData[src];
+            }
+        }
+    }
 };
 
 class CopyTests_T2B : public CopyTests {
-    protected:
-      void DoTest(const TextureSpec& textureSpec,
-                  const BufferSpec& bufferSpec,
-                  const wgpu::Extent3D& copySize) {
-          // Create a texture that is `width` x `height` with (`level` + 1) mip levels.
-          wgpu::TextureDescriptor descriptor;
-          descriptor.dimension = wgpu::TextureDimension::e2D;
-          descriptor.size = textureSpec.textureSize;
-          descriptor.sampleCount = 1;
-          descriptor.format = kTextureFormat;
-          descriptor.mipLevelCount = textureSpec.level + 1;
-          descriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
-          wgpu::Texture texture = device.CreateTexture(&descriptor);
+  protected:
+    void DoTest(const TextureSpec& textureSpec,
+                const BufferSpec& bufferSpec,
+                const wgpu::Extent3D& copySize) {
+        // Create a texture that is `width` x `height` with (`level` + 1) mip levels.
+        wgpu::TextureDescriptor descriptor;
+        descriptor.dimension = wgpu::TextureDimension::e2D;
+        descriptor.size = textureSpec.textureSize;
+        descriptor.sampleCount = 1;
+        descriptor.format = kTextureFormat;
+        descriptor.mipLevelCount = textureSpec.level + 1;
+        descriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
+        wgpu::Texture texture = device.CreateTexture(&descriptor);
 
-          const utils::BufferTextureCopyLayout copyLayout =
-              utils::GetBufferTextureCopyLayoutForTexture2DAtLevel(
-                  kTextureFormat, textureSpec.textureSize, textureSpec.level,
-                  bufferSpec.rowsPerImage);
+        const utils::BufferTextureCopyLayout copyLayout =
+            utils::GetBufferTextureCopyLayoutForTexture2DAtLevel(
+                kTextureFormat, textureSpec.textureSize, textureSpec.level,
+                bufferSpec.rowsPerImage);
 
-          wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
-          // Initialize the source texture
-          std::vector<RGBA8> textureArrayData = GetExpectedTextureData(copyLayout);
-          {
-              wgpu::Buffer uploadBuffer =
-                  utils::CreateBufferFromData(device, textureArrayData.data(),
-                                              copyLayout.byteLength, wgpu::BufferUsage::CopySrc);
-              wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(
-                  uploadBuffer, 0, copyLayout.bytesPerRow, bufferSpec.rowsPerImage);
-              wgpu::TextureCopyView textureCopyView =
-                  utils::CreateTextureCopyView(texture, textureSpec.level, {0, 0, 0});
-              encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copyLayout.mipSize);
-          }
+        // Initialize the source texture
+        std::vector<RGBA8> textureArrayData = GetExpectedTextureData(copyLayout);
+        {
+            wgpu::Buffer uploadBuffer = utils::CreateBufferFromData(
+                device, textureArrayData.data(), copyLayout.byteLength, wgpu::BufferUsage::CopySrc);
+            wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(
+                uploadBuffer, 0, copyLayout.bytesPerRow, bufferSpec.rowsPerImage);
+            wgpu::TextureCopyView textureCopyView =
+                utils::CreateTextureCopyView(texture, textureSpec.level, {0, 0, 0});
+            encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copyLayout.mipSize);
+        }
 
-          // Create a buffer of `size` and populate it with empty data (0,0,0,0) Note:
-          // Prepopulating the buffer with empty data ensures that there is not random data in the
-          // expectation and helps ensure that the padding due to the bytes per row is not modified
-          // by the copy.
-          // TODO(jiawei.shao@intel.com): remove the initialization of the buffer after we support
-          // buffer lazy-initialization.
-          const uint32_t bytesPerTexel = utils::GetTexelBlockSizeInBytes(kTextureFormat);
-          const std::vector<RGBA8> emptyData(bufferSpec.size / bytesPerTexel, RGBA8());
-          wgpu::Buffer buffer =
-              utils::CreateBufferFromData(device, emptyData.data(), bufferSpec.size,
-                                          wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst);
+        // Create a buffer of `size` and populate it with empty data (0,0,0,0) Note:
+        // Prepopulating the buffer with empty data ensures that there is not random data in the
+        // expectation and helps ensure that the padding due to the bytes per row is not modified
+        // by the copy.
+        // TODO(jiawei.shao@intel.com): remove the initialization of the buffer after we support
+        // buffer lazy-initialization.
+        const uint32_t bytesPerTexel = utils::GetTexelBlockSizeInBytes(kTextureFormat);
+        const std::vector<RGBA8> emptyData(bufferSpec.size / bytesPerTexel, RGBA8());
+        wgpu::Buffer buffer =
+            utils::CreateBufferFromData(device, emptyData.data(), bufferSpec.size,
+                                        wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst);
 
-          {
-              wgpu::TextureCopyView textureCopyView =
-                  utils::CreateTextureCopyView(texture, textureSpec.level, textureSpec.copyOrigin);
-              wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(
-                  buffer, bufferSpec.offset, bufferSpec.bytesPerRow, bufferSpec.rowsPerImage);
-              encoder.CopyTextureToBuffer(&textureCopyView, &bufferCopyView, &copySize);
-          }
+        {
+            wgpu::TextureCopyView textureCopyView =
+                utils::CreateTextureCopyView(texture, textureSpec.level, textureSpec.copyOrigin);
+            wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(
+                buffer, bufferSpec.offset, bufferSpec.bytesPerRow, bufferSpec.rowsPerImage);
+            encoder.CopyTextureToBuffer(&textureCopyView, &bufferCopyView, &copySize);
+        }
 
-          wgpu::CommandBuffer commands = encoder.Finish();
-          queue.Submit(1, &commands);
+        wgpu::CommandBuffer commands = encoder.Finish();
+        queue.Submit(1, &commands);
 
-          uint64_t bufferOffset = bufferSpec.offset;
-          const uint32_t texelCountInCopyRegion =
-              bufferSpec.bytesPerRow / bytesPerTexel * (copySize.height - 1) + copySize.width;
-          const uint32_t maxArrayLayer = textureSpec.copyOrigin.z + copySize.depth;
-          std::vector<RGBA8> expected(texelCountInCopyRegion);
-          for (uint32_t slice = textureSpec.copyOrigin.z; slice < maxArrayLayer; ++slice) {
-              // Pack the data used to create the upload buffer in the specified copy region to have
-              // the same format as the expected buffer data.
-              std::fill(expected.begin(), expected.end(), RGBA8());
-              const uint32_t texelIndexOffset = copyLayout.texelBlocksPerImage * slice;
-              const uint32_t expectedTexelArrayDataStartIndex =
-                  texelIndexOffset + (textureSpec.copyOrigin.x +
-                                      textureSpec.copyOrigin.y * copyLayout.texelBlocksPerRow);
+        uint64_t bufferOffset = bufferSpec.offset;
+        const uint32_t texelCountInCopyRegion =
+            bufferSpec.bytesPerRow / bytesPerTexel * (copySize.height - 1) + copySize.width;
+        const uint32_t maxArrayLayer = textureSpec.copyOrigin.z + copySize.depth;
+        std::vector<RGBA8> expected(texelCountInCopyRegion);
+        for (uint32_t slice = textureSpec.copyOrigin.z; slice < maxArrayLayer; ++slice) {
+            // Pack the data used to create the upload buffer in the specified copy region to have
+            // the same format as the expected buffer data.
+            std::fill(expected.begin(), expected.end(), RGBA8());
+            const uint32_t texelIndexOffset = copyLayout.texelBlocksPerImage * slice;
+            const uint32_t expectedTexelArrayDataStartIndex =
+                texelIndexOffset + (textureSpec.copyOrigin.x +
+                                    textureSpec.copyOrigin.y * copyLayout.texelBlocksPerRow);
 
-              PackTextureData(&textureArrayData[expectedTexelArrayDataStartIndex], copySize.width,
-                              copySize.height, copyLayout.texelBlocksPerRow, expected.data(),
-                              bufferSpec.bytesPerRow / bytesPerTexel);
+            PackTextureData(&textureArrayData[expectedTexelArrayDataStartIndex], copySize.width,
+                            copySize.height, copyLayout.texelBlocksPerRow, expected.data(),
+                            bufferSpec.bytesPerRow / bytesPerTexel);
 
-              EXPECT_BUFFER_U32_RANGE_EQ(reinterpret_cast<const uint32_t*>(expected.data()), buffer,
-                                         bufferOffset, static_cast<uint32_t>(expected.size()))
-                  << "Texture to Buffer copy failed copying region [(" << textureSpec.copyOrigin.x
-                  << ", " << textureSpec.copyOrigin.y << "), ("
-                  << textureSpec.copyOrigin.x + copySize.width << ", "
-                  << textureSpec.copyOrigin.y + copySize.height << ")) from "
-                  << textureSpec.textureSize.width << " x " << textureSpec.textureSize.height
-                  << " texture at mip level " << textureSpec.level << " layer " << slice << " to "
-                  << bufferSpec.size << "-byte buffer with offset " << bufferOffset
-                  << " and bytes per row " << bufferSpec.bytesPerRow << std::endl;
+            EXPECT_BUFFER_U32_RANGE_EQ(reinterpret_cast<const uint32_t*>(expected.data()), buffer,
+                                       bufferOffset, static_cast<uint32_t>(expected.size()))
+                << "Texture to Buffer copy failed copying region [(" << textureSpec.copyOrigin.x
+                << ", " << textureSpec.copyOrigin.y << "), ("
+                << textureSpec.copyOrigin.x + copySize.width << ", "
+                << textureSpec.copyOrigin.y + copySize.height << ")) from "
+                << textureSpec.textureSize.width << " x " << textureSpec.textureSize.height
+                << " texture at mip level " << textureSpec.level << " layer " << slice << " to "
+                << bufferSpec.size << "-byte buffer with offset " << bufferOffset
+                << " and bytes per row " << bufferSpec.bytesPerRow << std::endl;
 
-              bufferOffset += copyLayout.bytesPerImage;
-          }
-      }
+            bufferOffset += copyLayout.bytesPerImage;
+        }
+    }
 };
 
 class CopyTests_B2T : public CopyTests {
-protected:
+  protected:
     static void FillBufferData(RGBA8* data, size_t count) {
         for (size_t i = 0; i < count; ++i) {
-            data[i] = RGBA8(
-                static_cast<uint8_t>(i % 256),
-                static_cast<uint8_t>((i / 256) % 256),
-                static_cast<uint8_t>((i / 256 / 256) % 256),
-                255);
+            data[i] = RGBA8(static_cast<uint8_t>(i % 256), static_cast<uint8_t>((i / 256) % 256),
+                            static_cast<uint8_t>((i / 256 / 256) % 256), 255);
         }
     }
 
@@ -510,7 +510,7 @@
     constexpr uint32_t kWidth = 256;
     constexpr uint32_t kHeight = 128;
     for (unsigned int w : {64, 128, 256}) {
-        for (unsigned int h : { 16, 32, 48 }) {
+        for (unsigned int h : {16, 32, 48}) {
             TextureSpec textureSpec;
             textureSpec.copyOrigin = {0, 0, 0};
             textureSpec.level = 0;
@@ -531,7 +531,7 @@
     defaultTextureSpec.textureSize = {kWidth, kHeight, 1};
 
     for (unsigned int w : {13, 63, 65}) {
-        for (unsigned int h : { 17, 19, 63 }) {
+        for (unsigned int h : {17, 19, 63}) {
             TextureSpec textureSpec = defaultTextureSpec;
             DoTest(textureSpec, MinimumBufferSpec(w, h), {w, h, 1});
         }
@@ -746,7 +746,11 @@
     DoTest(textureSpec, bufferSpec, {kWidth, kHeight, kCopyLayers});
 }
 
-DAWN_INSTANTIATE_TEST(CopyTests_T2B, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(CopyTests_T2B,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 // Test that copying an entire texture with 256-byte aligned dimensions works
 TEST_P(CopyTests_B2T, FullTextureAligned) {
@@ -877,7 +881,7 @@
     constexpr uint32_t kWidth = 256;
     constexpr uint32_t kHeight = 128;
     for (unsigned int w : {64, 128, 256}) {
-        for (unsigned int h : { 16, 32, 48 }) {
+        for (unsigned int h : {16, 32, 48}) {
             TextureSpec textureSpec;
             textureSpec.copyOrigin = {0, 0, 0};
             textureSpec.level = 0;
@@ -1090,7 +1094,11 @@
     DoTest(textureSpec, bufferSpec, {kWidth, kHeight, kCopyLayers});
 }
 
-DAWN_INSTANTIATE_TEST(CopyTests_B2T, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(CopyTests_B2T,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 TEST_P(CopyTests_T2T, Texture) {
     constexpr uint32_t kWidth = 256;
@@ -1310,7 +1318,11 @@
     }
 }
 
-DAWN_INSTANTIATE_TEST(CopyTests_T2T, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(CopyTests_T2T,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 static constexpr uint64_t kSmallBufferSize = 4;
 static constexpr uint64_t kLargeBufferSize = 1 << 16;
diff --git a/src/tests/end2end/CullingTests.cpp b/src/tests/end2end/CullingTests.cpp
index 79a2303..726df13 100644
--- a/src/tests/end2end/CullingTests.cpp
+++ b/src/tests/end2end/CullingTests.cpp
@@ -127,4 +127,8 @@
     DoTest(wgpu::FrontFace::CW, wgpu::CullMode::Back, true, false);
 }
 
-DAWN_INSTANTIATE_TEST(CullingTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(CullingTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/D3D12ResourceWrappingTests.cpp b/src/tests/end2end/D3D12ResourceWrappingTests.cpp
index 2907a87..364f48f 100644
--- a/src/tests/end2end/D3D12ResourceWrappingTests.cpp
+++ b/src/tests/end2end/D3D12ResourceWrappingTests.cpp
@@ -130,8 +130,7 @@
 
 // A small fixture used to initialize default data for the D3D12Resource validation tests.
 // These tests are skipped if the harness is using the wire.
-class D3D12SharedHandleValidation : public D3D12ResourceTestBase {
-};
+class D3D12SharedHandleValidation : public D3D12ResourceTestBase {};
 
 // Test a successful wrapping of an D3D12Resource in a texture
 TEST_P(D3D12SharedHandleValidation, Success) {
diff --git a/src/tests/end2end/DebugMarkerTests.cpp b/src/tests/end2end/DebugMarkerTests.cpp
index f9fab77..d368a17 100644
--- a/src/tests/end2end/DebugMarkerTests.cpp
+++ b/src/tests/end2end/DebugMarkerTests.cpp
@@ -42,4 +42,8 @@
     queue.Submit(1, &commands);
 }
 
-DAWN_INSTANTIATE_TEST(DebugMarkerTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(DebugMarkerTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/DepthSamplingTests.cpp b/src/tests/end2end/DepthSamplingTests.cpp
index 7c24a69..06dcce6e 100644
--- a/src/tests/end2end/DepthSamplingTests.cpp
+++ b/src/tests/end2end/DepthSamplingTests.cpp
@@ -20,14 +20,10 @@
 namespace {
 
     constexpr wgpu::CompareFunction kCompareFunctions[] = {
-        wgpu::CompareFunction::Never,
-        wgpu::CompareFunction::Less,
-        wgpu::CompareFunction::LessEqual,
-        wgpu::CompareFunction::Greater,
-        wgpu::CompareFunction::GreaterEqual,
-        wgpu::CompareFunction::Equal,
-        wgpu::CompareFunction::NotEqual,
-        wgpu::CompareFunction::Always,
+        wgpu::CompareFunction::Never,        wgpu::CompareFunction::Less,
+        wgpu::CompareFunction::LessEqual,    wgpu::CompareFunction::Greater,
+        wgpu::CompareFunction::GreaterEqual, wgpu::CompareFunction::Equal,
+        wgpu::CompareFunction::NotEqual,     wgpu::CompareFunction::Always,
     };
 
     // Test a "normal" ref value between 0 and 1; as well as negative and > 1 refs.
@@ -225,12 +221,11 @@
         wgpu::SamplerDescriptor samplerDesc;
         wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
 
-        wgpu::BindGroup bindGroup =
-            utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
-                                 {
-                                     {0, sampler},
-                                     {1, mInputTexture.CreateView()},
-                                 });
+        wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
+                                                         {
+                                                             {0, sampler},
+                                                             {1, mInputTexture.CreateView()},
+                                                         });
 
         for (float textureValue : textureValues) {
             // Set the input depth texture to the provided texture value
@@ -258,12 +253,9 @@
         wgpu::SamplerDescriptor samplerDesc;
         wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
 
-        wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
-                                                         {
-                                                             {0, sampler},
-                                                             {1, mInputTexture.CreateView()},
-                                                             {2, mOutputBuffer}
-                                                         });
+        wgpu::BindGroup bindGroup = utils::MakeBindGroup(
+            device, pipeline.GetBindGroupLayout(0),
+            {{0, sampler}, {1, mInputTexture.CreateView()}, {2, mOutputBuffer}});
 
         for (float textureValue : textureValues) {
             // Set the input depth texture to the provided texture value
@@ -321,13 +313,12 @@
         samplerDesc.compare = compare;
         wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
 
-        wgpu::BindGroup bindGroup =
-            utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
-                                 {
-                                     {0, sampler},
-                                     {1, mInputTexture.CreateView()},
-                                     {2, mUniformBuffer},
-                                 });
+        wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
+                                                         {
+                                                             {0, sampler},
+                                                             {1, mInputTexture.CreateView()},
+                                                             {2, mUniformBuffer},
+                                                         });
 
         for (float textureValue : textureValues) {
             // Set the input depth texture to the provided texture value
@@ -364,12 +355,10 @@
         wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
 
         wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
-                                                         {
-                                                             {0, sampler},
-                                                             {1, mInputTexture.CreateView()},
-                                                             {2, mUniformBuffer},
-                                                             {3, mOutputBuffer}
-                                                         });
+                                                         {{0, sampler},
+                                                          {1, mInputTexture.CreateView()},
+                                                          {2, mUniformBuffer},
+                                                          {3, mOutputBuffer}});
 
         for (float textureValue : textureValues) {
             // Set the input depth texture to the provided texture value
diff --git a/src/tests/end2end/DepthStencilStateTests.cpp b/src/tests/end2end/DepthStencilStateTests.cpp
index 4881437..4788094 100644
--- a/src/tests/end2end/DepthStencilStateTests.cpp
+++ b/src/tests/end2end/DepthStencilStateTests.cpp
@@ -21,38 +21,38 @@
 constexpr static unsigned int kRTSize = 64;
 
 class DepthStencilStateTest : public DawnTest {
-    protected:
-        void SetUp() override {
-            DawnTest::SetUp();
+  protected:
+    void SetUp() override {
+        DawnTest::SetUp();
 
-            wgpu::TextureDescriptor renderTargetDescriptor;
-            renderTargetDescriptor.dimension = wgpu::TextureDimension::e2D;
-            renderTargetDescriptor.size.width = kRTSize;
-            renderTargetDescriptor.size.height = kRTSize;
-            renderTargetDescriptor.size.depth = 1;
-            renderTargetDescriptor.sampleCount = 1;
-            renderTargetDescriptor.format = wgpu::TextureFormat::RGBA8Unorm;
-            renderTargetDescriptor.mipLevelCount = 1;
-            renderTargetDescriptor.usage =
-                wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::CopySrc;
-            renderTarget = device.CreateTexture(&renderTargetDescriptor);
+        wgpu::TextureDescriptor renderTargetDescriptor;
+        renderTargetDescriptor.dimension = wgpu::TextureDimension::e2D;
+        renderTargetDescriptor.size.width = kRTSize;
+        renderTargetDescriptor.size.height = kRTSize;
+        renderTargetDescriptor.size.depth = 1;
+        renderTargetDescriptor.sampleCount = 1;
+        renderTargetDescriptor.format = wgpu::TextureFormat::RGBA8Unorm;
+        renderTargetDescriptor.mipLevelCount = 1;
+        renderTargetDescriptor.usage =
+            wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::CopySrc;
+        renderTarget = device.CreateTexture(&renderTargetDescriptor);
 
-            renderTargetView = renderTarget.CreateView();
+        renderTargetView = renderTarget.CreateView();
 
-            wgpu::TextureDescriptor depthDescriptor;
-            depthDescriptor.dimension = wgpu::TextureDimension::e2D;
-            depthDescriptor.size.width = kRTSize;
-            depthDescriptor.size.height = kRTSize;
-            depthDescriptor.size.depth = 1;
-            depthDescriptor.sampleCount = 1;
-            depthDescriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
-            depthDescriptor.mipLevelCount = 1;
-            depthDescriptor.usage = wgpu::TextureUsage::OutputAttachment;
-            depthTexture = device.CreateTexture(&depthDescriptor);
+        wgpu::TextureDescriptor depthDescriptor;
+        depthDescriptor.dimension = wgpu::TextureDimension::e2D;
+        depthDescriptor.size.width = kRTSize;
+        depthDescriptor.size.height = kRTSize;
+        depthDescriptor.size.depth = 1;
+        depthDescriptor.sampleCount = 1;
+        depthDescriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
+        depthDescriptor.mipLevelCount = 1;
+        depthDescriptor.usage = wgpu::TextureUsage::OutputAttachment;
+        depthTexture = device.CreateTexture(&depthDescriptor);
 
-            depthTextureView = depthTexture.CreateView();
+        depthTextureView = depthTexture.CreateView();
 
-            vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
                 #version 450
                 layout(set = 0, binding = 0) uniform myBlock {
                     vec3 color;
@@ -67,7 +67,7 @@
                 }
             )");
 
-            fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
                 #version 450
                 layout(set = 0, binding = 0) uniform myBlock {
                     vec3 color;
@@ -78,235 +78,251 @@
                     fragColor = vec4(myUbo.color, 1.f);
                 }
             )");
-        }
+    }
 
-        struct TestSpec {
-            const wgpu::DepthStencilStateDescriptor& depthStencilState;
-            RGBA8 color;
-            float depth;
-            uint32_t stencil;
-        };
+    struct TestSpec {
+        const wgpu::DepthStencilStateDescriptor& depthStencilState;
+        RGBA8 color;
+        float depth;
+        uint32_t stencil;
+    };
 
-        // Check whether a depth comparison function works as expected
-        // The less, equal, greater booleans denote wether the respective triangle should be visible based on the comparison function
-        void CheckDepthCompareFunction(wgpu::CompareFunction compareFunction,
-                                       bool less,
-                                       bool equal,
-                                       bool greater) {
-            wgpu::StencilStateFaceDescriptor stencilFace;
-            stencilFace.compare = wgpu::CompareFunction::Always;
-            stencilFace.failOp = wgpu::StencilOperation::Keep;
-            stencilFace.depthFailOp = wgpu::StencilOperation::Keep;
-            stencilFace.passOp = wgpu::StencilOperation::Keep;
+    // Check whether a depth comparison function works as expected
+    // The less, equal, greater booleans denote wether the respective triangle should be visible
+    // based on the comparison function
+    void CheckDepthCompareFunction(wgpu::CompareFunction compareFunction,
+                                   bool less,
+                                   bool equal,
+                                   bool greater) {
+        wgpu::StencilStateFaceDescriptor stencilFace;
+        stencilFace.compare = wgpu::CompareFunction::Always;
+        stencilFace.failOp = wgpu::StencilOperation::Keep;
+        stencilFace.depthFailOp = wgpu::StencilOperation::Keep;
+        stencilFace.passOp = wgpu::StencilOperation::Keep;
 
-            wgpu::DepthStencilStateDescriptor baseState;
-            baseState.depthWriteEnabled = true;
-            baseState.depthCompare = wgpu::CompareFunction::Always;
-            baseState.stencilBack = stencilFace;
-            baseState.stencilFront = stencilFace;
-            baseState.stencilReadMask = 0xff;
-            baseState.stencilWriteMask = 0xff;
+        wgpu::DepthStencilStateDescriptor baseState;
+        baseState.depthWriteEnabled = true;
+        baseState.depthCompare = wgpu::CompareFunction::Always;
+        baseState.stencilBack = stencilFace;
+        baseState.stencilFront = stencilFace;
+        baseState.stencilReadMask = 0xff;
+        baseState.stencilWriteMask = 0xff;
 
-            wgpu::DepthStencilStateDescriptor state;
-            state.depthWriteEnabled = true;
-            state.depthCompare = compareFunction;
-            state.stencilBack = stencilFace;
-            state.stencilFront = stencilFace;
-            state.stencilReadMask = 0xff;
-            state.stencilWriteMask = 0xff;
+        wgpu::DepthStencilStateDescriptor state;
+        state.depthWriteEnabled = true;
+        state.depthCompare = compareFunction;
+        state.stencilBack = stencilFace;
+        state.stencilFront = stencilFace;
+        state.stencilReadMask = 0xff;
+        state.stencilWriteMask = 0xff;
 
-            RGBA8 baseColor = RGBA8(255, 255, 255, 255);
-            RGBA8 lessColor = RGBA8(255, 0, 0, 255);
-            RGBA8 equalColor = RGBA8(0, 255, 0, 255);
-            RGBA8 greaterColor = RGBA8(0, 0, 255, 255);
+        RGBA8 baseColor = RGBA8(255, 255, 255, 255);
+        RGBA8 lessColor = RGBA8(255, 0, 0, 255);
+        RGBA8 equalColor = RGBA8(0, 255, 0, 255);
+        RGBA8 greaterColor = RGBA8(0, 0, 255, 255);
 
-            // Base triangle at depth 0.5, depth always, depth write enabled
-            TestSpec base = { baseState, baseColor, 0.5f, 0u };
+        // Base triangle at depth 0.5, depth always, depth write enabled
+        TestSpec base = {baseState, baseColor, 0.5f, 0u};
 
-            // Draw the base triangle, then a triangle in stencilFront of the base triangle with the
-            // given depth comparison function
-            DoTest({ base, { state, lessColor, 0.f, 0u } }, less ? lessColor : baseColor);
+        // Draw the base triangle, then a triangle in stencilFront of the base triangle with the
+        // given depth comparison function
+        DoTest({base, {state, lessColor, 0.f, 0u}}, less ? lessColor : baseColor);
 
-            // Draw the base triangle, then a triangle in at the same depth as the base triangle with the given depth comparison function
-            DoTest({ base, { state, equalColor, 0.5f, 0u } }, equal ? equalColor : baseColor);
+        // Draw the base triangle, then a triangle in at the same depth as the base triangle with
+        // the given depth comparison function
+        DoTest({base, {state, equalColor, 0.5f, 0u}}, equal ? equalColor : baseColor);
 
-            // Draw the base triangle, then a triangle behind the base triangle with the given depth comparison function
-            DoTest({ base, { state, greaterColor, 1.0f, 0u } }, greater ? greaterColor :  baseColor);
-        }
+        // Draw the base triangle, then a triangle behind the base triangle with the given depth
+        // comparison function
+        DoTest({base, {state, greaterColor, 1.0f, 0u}}, greater ? greaterColor : baseColor);
+    }
 
-        // Check whether a stencil comparison function works as expected
-        // The less, equal, greater booleans denote wether the respective triangle should be visible based on the comparison function
-        void CheckStencilCompareFunction(wgpu::CompareFunction compareFunction,
-                                         bool less,
-                                         bool equal,
-                                         bool greater) {
-            wgpu::StencilStateFaceDescriptor baseStencilFaceDescriptor;
-            baseStencilFaceDescriptor.compare = wgpu::CompareFunction::Always;
-            baseStencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
-            baseStencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
-            baseStencilFaceDescriptor.passOp = wgpu::StencilOperation::Replace;
-            wgpu::DepthStencilStateDescriptor baseState;
-            baseState.depthWriteEnabled = false;
-            baseState.depthCompare = wgpu::CompareFunction::Always;
-            baseState.stencilBack = baseStencilFaceDescriptor;
-            baseState.stencilFront = baseStencilFaceDescriptor;
-            baseState.stencilReadMask = 0xff;
-            baseState.stencilWriteMask = 0xff;
+    // Check whether a stencil comparison function works as expected
+    // The less, equal, greater booleans denote wether the respective triangle should be visible
+    // based on the comparison function
+    void CheckStencilCompareFunction(wgpu::CompareFunction compareFunction,
+                                     bool less,
+                                     bool equal,
+                                     bool greater) {
+        wgpu::StencilStateFaceDescriptor baseStencilFaceDescriptor;
+        baseStencilFaceDescriptor.compare = wgpu::CompareFunction::Always;
+        baseStencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
+        baseStencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
+        baseStencilFaceDescriptor.passOp = wgpu::StencilOperation::Replace;
+        wgpu::DepthStencilStateDescriptor baseState;
+        baseState.depthWriteEnabled = false;
+        baseState.depthCompare = wgpu::CompareFunction::Always;
+        baseState.stencilBack = baseStencilFaceDescriptor;
+        baseState.stencilFront = baseStencilFaceDescriptor;
+        baseState.stencilReadMask = 0xff;
+        baseState.stencilWriteMask = 0xff;
 
-            wgpu::StencilStateFaceDescriptor stencilFaceDescriptor;
-            stencilFaceDescriptor.compare = compareFunction;
-            stencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
-            stencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
-            stencilFaceDescriptor.passOp = wgpu::StencilOperation::Keep;
-            wgpu::DepthStencilStateDescriptor state;
-            state.depthWriteEnabled = false;
-            state.depthCompare = wgpu::CompareFunction::Always;
-            state.stencilBack = stencilFaceDescriptor;
-            state.stencilFront = stencilFaceDescriptor;
-            state.stencilReadMask = 0xff;
-            state.stencilWriteMask = 0xff;
+        wgpu::StencilStateFaceDescriptor stencilFaceDescriptor;
+        stencilFaceDescriptor.compare = compareFunction;
+        stencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
+        stencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
+        stencilFaceDescriptor.passOp = wgpu::StencilOperation::Keep;
+        wgpu::DepthStencilStateDescriptor state;
+        state.depthWriteEnabled = false;
+        state.depthCompare = wgpu::CompareFunction::Always;
+        state.stencilBack = stencilFaceDescriptor;
+        state.stencilFront = stencilFaceDescriptor;
+        state.stencilReadMask = 0xff;
+        state.stencilWriteMask = 0xff;
 
-            RGBA8 baseColor = RGBA8(255, 255, 255, 255);
-            RGBA8 lessColor = RGBA8(255, 0, 0, 255);
-            RGBA8 equalColor = RGBA8(0, 255, 0, 255);
-            RGBA8 greaterColor = RGBA8(0, 0, 255, 255);
+        RGBA8 baseColor = RGBA8(255, 255, 255, 255);
+        RGBA8 lessColor = RGBA8(255, 0, 0, 255);
+        RGBA8 equalColor = RGBA8(0, 255, 0, 255);
+        RGBA8 greaterColor = RGBA8(0, 0, 255, 255);
 
-            // Base triangle with stencil reference 1
-            TestSpec base = { baseState, baseColor, 0.0f, 1u };
+        // Base triangle with stencil reference 1
+        TestSpec base = {baseState, baseColor, 0.0f, 1u};
 
-            // Draw the base triangle, then a triangle with stencil reference 0 with the given stencil comparison function
-            DoTest({ base, { state, lessColor, 0.f, 0u } }, less ? lessColor : baseColor);
+        // Draw the base triangle, then a triangle with stencil reference 0 with the given stencil
+        // comparison function
+        DoTest({base, {state, lessColor, 0.f, 0u}}, less ? lessColor : baseColor);
 
-            // Draw the base triangle, then a triangle with stencil reference 1 with the given stencil comparison function
-            DoTest({ base, { state, equalColor, 0.f, 1u } }, equal ? equalColor : baseColor);
+        // Draw the base triangle, then a triangle with stencil reference 1 with the given stencil
+        // comparison function
+        DoTest({base, {state, equalColor, 0.f, 1u}}, equal ? equalColor : baseColor);
 
-            // Draw the base triangle, then a triangle with stencil reference 2 with the given stencil comparison function
-            DoTest({ base, { state, greaterColor, 0.f, 2u } }, greater ? greaterColor : baseColor);
-        }
+        // Draw the base triangle, then a triangle with stencil reference 2 with the given stencil
+        // comparison function
+        DoTest({base, {state, greaterColor, 0.f, 2u}}, greater ? greaterColor : baseColor);
+    }
 
-        // Given the provided `initialStencil` and `reference`, check that applying the `stencilOperation` produces the `expectedStencil`
-        void CheckStencilOperation(wgpu::StencilOperation stencilOperation,
-                                   uint32_t initialStencil,
-                                   uint32_t reference,
-                                   uint32_t expectedStencil) {
-            wgpu::StencilStateFaceDescriptor baseStencilFaceDescriptor;
-            baseStencilFaceDescriptor.compare = wgpu::CompareFunction::Always;
-            baseStencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
-            baseStencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
-            baseStencilFaceDescriptor.passOp = wgpu::StencilOperation::Replace;
-            wgpu::DepthStencilStateDescriptor baseState;
-            baseState.depthWriteEnabled = false;
-            baseState.depthCompare = wgpu::CompareFunction::Always;
-            baseState.stencilBack = baseStencilFaceDescriptor;
-            baseState.stencilFront = baseStencilFaceDescriptor;
-            baseState.stencilReadMask = 0xff;
-            baseState.stencilWriteMask = 0xff;
+    // Given the provided `initialStencil` and `reference`, check that applying the
+    // `stencilOperation` produces the `expectedStencil`
+    void CheckStencilOperation(wgpu::StencilOperation stencilOperation,
+                               uint32_t initialStencil,
+                               uint32_t reference,
+                               uint32_t expectedStencil) {
+        wgpu::StencilStateFaceDescriptor baseStencilFaceDescriptor;
+        baseStencilFaceDescriptor.compare = wgpu::CompareFunction::Always;
+        baseStencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
+        baseStencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
+        baseStencilFaceDescriptor.passOp = wgpu::StencilOperation::Replace;
+        wgpu::DepthStencilStateDescriptor baseState;
+        baseState.depthWriteEnabled = false;
+        baseState.depthCompare = wgpu::CompareFunction::Always;
+        baseState.stencilBack = baseStencilFaceDescriptor;
+        baseState.stencilFront = baseStencilFaceDescriptor;
+        baseState.stencilReadMask = 0xff;
+        baseState.stencilWriteMask = 0xff;
 
-            wgpu::StencilStateFaceDescriptor stencilFaceDescriptor;
-            stencilFaceDescriptor.compare = wgpu::CompareFunction::Always;
-            stencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
-            stencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
-            stencilFaceDescriptor.passOp = stencilOperation;
-            wgpu::DepthStencilStateDescriptor state;
-            state.depthWriteEnabled = false;
-            state.depthCompare = wgpu::CompareFunction::Always;
-            state.stencilBack = stencilFaceDescriptor;
-            state.stencilFront = stencilFaceDescriptor;
-            state.stencilReadMask = 0xff;
-            state.stencilWriteMask = 0xff;
+        wgpu::StencilStateFaceDescriptor stencilFaceDescriptor;
+        stencilFaceDescriptor.compare = wgpu::CompareFunction::Always;
+        stencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
+        stencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
+        stencilFaceDescriptor.passOp = stencilOperation;
+        wgpu::DepthStencilStateDescriptor state;
+        state.depthWriteEnabled = false;
+        state.depthCompare = wgpu::CompareFunction::Always;
+        state.stencilBack = stencilFaceDescriptor;
+        state.stencilFront = stencilFaceDescriptor;
+        state.stencilReadMask = 0xff;
+        state.stencilWriteMask = 0xff;
 
-            CheckStencil({
+        CheckStencil(
+            {
                 // Wipe the stencil buffer with the initialStencil value
-                { baseState, RGBA8(255, 255, 255, 255), 0.f, initialStencil },
+                {baseState, RGBA8(255, 255, 255, 255), 0.f, initialStencil},
 
                 // Draw a triangle with the provided stencil operation and reference
-                { state, RGBA8(255, 0, 0, 255), 0.f, reference },
-            }, expectedStencil);
-        }
+                {state, RGBA8(255, 0, 0, 255), 0.f, reference},
+            },
+            expectedStencil);
+    }
 
-        // Draw a list of test specs, and check if the stencil value is equal to the expected value
-        void CheckStencil(std::vector<TestSpec> testParams, uint32_t expectedStencil) {
-            wgpu::StencilStateFaceDescriptor stencilFaceDescriptor;
-            stencilFaceDescriptor.compare = wgpu::CompareFunction::Equal;
-            stencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
-            stencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
-            stencilFaceDescriptor.passOp = wgpu::StencilOperation::Keep;
-            wgpu::DepthStencilStateDescriptor state;
-            state.depthWriteEnabled = false;
-            state.depthCompare = wgpu::CompareFunction::Always;
-            state.stencilBack = stencilFaceDescriptor;
-            state.stencilFront = stencilFaceDescriptor;
-            state.stencilReadMask = 0xff;
-            state.stencilWriteMask = 0xff;
+    // Draw a list of test specs, and check if the stencil value is equal to the expected value
+    void CheckStencil(std::vector<TestSpec> testParams, uint32_t expectedStencil) {
+        wgpu::StencilStateFaceDescriptor stencilFaceDescriptor;
+        stencilFaceDescriptor.compare = wgpu::CompareFunction::Equal;
+        stencilFaceDescriptor.failOp = wgpu::StencilOperation::Keep;
+        stencilFaceDescriptor.depthFailOp = wgpu::StencilOperation::Keep;
+        stencilFaceDescriptor.passOp = wgpu::StencilOperation::Keep;
+        wgpu::DepthStencilStateDescriptor state;
+        state.depthWriteEnabled = false;
+        state.depthCompare = wgpu::CompareFunction::Always;
+        state.stencilBack = stencilFaceDescriptor;
+        state.stencilFront = stencilFaceDescriptor;
+        state.stencilReadMask = 0xff;
+        state.stencilWriteMask = 0xff;
 
-            testParams.push_back({ state, RGBA8(0, 255, 0, 255), 0, expectedStencil });
-            DoTest(testParams, RGBA8(0, 255, 0, 255));
-        }
+        testParams.push_back({state, RGBA8(0, 255, 0, 255), 0, expectedStencil});
+        DoTest(testParams, RGBA8(0, 255, 0, 255));
+    }
 
-        // Each test param represents a pair of triangles with a color, depth, stencil value, and depthStencil state, one frontfacing, one backfacing
-        // Draw the triangles in order and check the expected colors for the frontfaces and backfaces
-        void DoTest(const std::vector<TestSpec> &testParams, const RGBA8& expectedFront, const RGBA8& expectedBack) {
-            wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    // Each test param represents a pair of triangles with a color, depth, stencil value, and
+    // depthStencil state, one frontfacing, one backfacing Draw the triangles in order and check the
+    // expected colors for the frontfaces and backfaces
+    void DoTest(const std::vector<TestSpec>& testParams,
+                const RGBA8& expectedFront,
+                const RGBA8& expectedBack) {
+        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
-            struct TriangleData {
-                float color[3];
-                float depth;
+        struct TriangleData {
+            float color[3];
+            float depth;
+        };
+
+        utils::ComboRenderPassDescriptor renderPass({renderTargetView}, depthTextureView);
+        wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
+
+        for (size_t i = 0; i < testParams.size(); ++i) {
+            const TestSpec& test = testParams[i];
+
+            TriangleData data = {
+                {static_cast<float>(test.color.r) / 255.f, static_cast<float>(test.color.g) / 255.f,
+                 static_cast<float>(test.color.b) / 255.f},
+                test.depth,
             };
+            // Upload a buffer for each triangle's depth and color data
+            wgpu::Buffer buffer = utils::CreateBufferFromData(device, &data, sizeof(TriangleData),
+                                                              wgpu::BufferUsage::Uniform);
 
-            utils::ComboRenderPassDescriptor renderPass({renderTargetView}, depthTextureView);
-            wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
+            // Create a pipeline for the triangles with the test spec's depth stencil state
 
-            for (size_t i = 0; i < testParams.size(); ++i) {
-                const TestSpec& test = testParams[i];
+            utils::ComboRenderPipelineDescriptor descriptor(device);
+            descriptor.vertexStage.module = vsModule;
+            descriptor.cFragmentStage.module = fsModule;
+            descriptor.cDepthStencilState = test.depthStencilState;
+            descriptor.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
+            descriptor.depthStencilState = &descriptor.cDepthStencilState;
 
-                TriangleData data = {
-                    {  static_cast<float>(test.color.r) / 255.f, static_cast<float>(test.color.g) / 255.f, static_cast<float>(test.color.b) / 255.f },
-                    test.depth,
-                };
-                // Upload a buffer for each triangle's depth and color data
-                wgpu::Buffer buffer = utils::CreateBufferFromData(
-                    device, &data, sizeof(TriangleData), wgpu::BufferUsage::Uniform);
+            wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
 
-                // Create a pipeline for the triangles with the test spec's depth stencil state
+            // Create a bind group for the data
+            wgpu::BindGroup bindGroup = utils::MakeBindGroup(
+                device, pipeline.GetBindGroupLayout(0), {{0, buffer, 0, sizeof(TriangleData)}});
 
-                utils::ComboRenderPipelineDescriptor descriptor(device);
-                descriptor.vertexStage.module = vsModule;
-                descriptor.cFragmentStage.module = fsModule;
-                descriptor.cDepthStencilState = test.depthStencilState;
-                descriptor.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
-                descriptor.depthStencilState = &descriptor.cDepthStencilState;
-
-                wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
-
-                // Create a bind group for the data
-                wgpu::BindGroup bindGroup = utils::MakeBindGroup(
-                    device, pipeline.GetBindGroupLayout(0), {{0, buffer, 0, sizeof(TriangleData)}});
-
-                pass.SetPipeline(pipeline);
-                pass.SetStencilReference(test.stencil);  // Set the stencil reference
-                pass.SetBindGroup(
-                    0, bindGroup);  // Set the bind group which contains color and depth data
-                pass.Draw(6);
-            }
-            pass.EndPass();
-
-            wgpu::CommandBuffer commands = encoder.Finish();
-            queue.Submit(1, &commands);
-
-            EXPECT_PIXEL_RGBA8_EQ(expectedFront, renderTarget, kRTSize / 4, kRTSize / 2) << "Front face check failed";
-            EXPECT_PIXEL_RGBA8_EQ(expectedBack, renderTarget, 3 * kRTSize / 4, kRTSize / 2) << "Back face check failed";
+            pass.SetPipeline(pipeline);
+            pass.SetStencilReference(test.stencil);  // Set the stencil reference
+            pass.SetBindGroup(0,
+                              bindGroup);  // Set the bind group which contains color and depth data
+            pass.Draw(6);
         }
+        pass.EndPass();
 
-        void DoTest(const std::vector<TestSpec> &testParams, const RGBA8& expected) {
-            DoTest(testParams, expected, expected);
-        }
+        wgpu::CommandBuffer commands = encoder.Finish();
+        queue.Submit(1, &commands);
 
-        wgpu::Texture renderTarget;
-        wgpu::Texture depthTexture;
-        wgpu::TextureView renderTargetView;
-        wgpu::TextureView depthTextureView;
-        wgpu::ShaderModule vsModule;
-        wgpu::ShaderModule fsModule;
+        EXPECT_PIXEL_RGBA8_EQ(expectedFront, renderTarget, kRTSize / 4, kRTSize / 2)
+            << "Front face check failed";
+        EXPECT_PIXEL_RGBA8_EQ(expectedBack, renderTarget, 3 * kRTSize / 4, kRTSize / 2)
+            << "Back face check failed";
+    }
+
+    void DoTest(const std::vector<TestSpec>& testParams, const RGBA8& expected) {
+        DoTest(testParams, expected, expected);
+    }
+
+    wgpu::Texture renderTarget;
+    wgpu::Texture depthTexture;
+    wgpu::TextureView renderTargetView;
+    wgpu::TextureView depthTextureView;
+    wgpu::ShaderModule vsModule;
+    wgpu::ShaderModule fsModule;
 };
 
 // Test compilation and usage of the fixture
@@ -325,9 +341,11 @@
     state.stencilReadMask = 0xff;
     state.stencilWriteMask = 0xff;
 
-    DoTest({
-        { state, RGBA8(0, 255, 0, 255), 0.5f, 0u },
-    }, RGBA8(0, 255, 0, 255));
+    DoTest(
+        {
+            {state, RGBA8(0, 255, 0, 255), 0.5f, 0u},
+        },
+        RGBA8(0, 255, 0, 255));
 }
 
 // Test defaults: depth and stencil tests disabled
@@ -347,9 +365,9 @@
     state.stencilWriteMask = 0xff;
 
     TestSpec specs[3] = {
-        { state, RGBA8(255, 0, 0, 255), 0.0f, 0u },
-        { state, RGBA8(0, 255, 0, 255), 0.5f, 0u },
-        { state, RGBA8(0, 0, 255, 255), 1.0f, 0u },
+        {state, RGBA8(255, 0, 0, 255), 0.0f, 0u},
+        {state, RGBA8(0, 255, 0, 255), 0.5f, 0u},
+        {state, RGBA8(0, 0, 255, 255), 1.0f, 0u},
     };
 
     // Test that for all combinations, the last triangle drawn is the one visible
@@ -357,8 +375,8 @@
     for (uint32_t last = 0; last < 3; ++last) {
         uint32_t i = (last + 1) % 3;
         uint32_t j = (last + 2) % 3;
-        DoTest({ specs[i], specs[j], specs[last] }, specs[last].color);
-        DoTest({ specs[j], specs[i], specs[last] }, specs[last].color);
+        DoTest({specs[i], specs[j], specs[last]}, specs[last].color);
+        DoTest({specs[j], specs[i], specs[last]}, specs[last].color);
     }
 }
 
@@ -427,11 +445,17 @@
     checkState.stencilReadMask = 0xff;
     checkState.stencilWriteMask = 0xff;
 
-    DoTest({
-        { baseState, RGBA8(255, 255, 255, 255), 1.f, 0u }, // Draw a base triangle with depth enabled
-        { noDepthWrite, RGBA8(0, 0, 0, 255), 0.f, 0u }, // Draw a second triangle without depth enabled
-        { checkState, RGBA8(0, 255, 0, 255), 1.f, 0u }, // Draw a third triangle which should occlude the second even though it is behind it
-    }, RGBA8(0, 255, 0, 255));
+    DoTest(
+        {
+            {baseState, RGBA8(255, 255, 255, 255), 1.f,
+             0u},  // Draw a base triangle with depth enabled
+            {noDepthWrite, RGBA8(0, 0, 0, 255), 0.f,
+             0u},  // Draw a second triangle without depth enabled
+            {checkState, RGBA8(0, 255, 0, 255), 1.f,
+             0u},  // Draw a third triangle which should occlude the second even though it is behind
+                   // it
+        },
+        RGBA8(0, 255, 0, 255));
 }
 
 // The following tests check that each stencil comparison function works
@@ -536,9 +560,11 @@
     RGBA8 red = RGBA8(255, 0, 0, 255);
     RGBA8 green = RGBA8(0, 255, 0, 255);
 
-    TestSpec base = { baseState, baseColor, 0.5f, 3u };     // Base triangle to set the stencil to 3
-    DoTest({ base, { state, red, 0.f, 1u } }, baseColor);   // Triangle with stencil reference 1 and read mask 2 does not draw because (3 & 2 != 1)
-    DoTest({ base, { state, green, 0.f, 2u } }, green);     // Triangle with stencil reference 2 and read mask 2 draws because (3 & 2 == 2)
+    TestSpec base = {baseState, baseColor, 0.5f, 3u};  // Base triangle to set the stencil to 3
+    DoTest({base, {state, red, 0.f, 1u}}, baseColor);  // Triangle with stencil reference 1 and read
+                                                       // mask 2 does not draw because (3 & 2 != 1)
+    DoTest({base, {state, green, 0.f, 2u}},
+           green);  // Triangle with stencil reference 2 and read mask 2 draws because (3 & 2 == 2)
 }
 
 // Check that setting a stencil write mask works
@@ -572,9 +598,12 @@
     RGBA8 baseColor = RGBA8(255, 255, 255, 255);
     RGBA8 green = RGBA8(0, 255, 0, 255);
 
-    TestSpec base = { baseState, baseColor, 0.5f, 3u };         // Base triangle with stencil reference 3 and mask 1 to set the stencil 1
-    DoTest({ base, { state, green, 0.f, 2u } }, baseColor);     // Triangle with stencil reference 2 does not draw because 2 != (3 & 1)
-    DoTest({ base, { state, green, 0.f, 1u } }, green);         // Triangle with stencil reference 1 draws because 1 == (3 & 1)
+    TestSpec base = {baseState, baseColor, 0.5f,
+                     3u};  // Base triangle with stencil reference 3 and mask 1 to set the stencil 1
+    DoTest({base, {state, green, 0.f, 2u}},
+           baseColor);  // Triangle with stencil reference 2 does not draw because 2 != (3 & 1)
+    DoTest({base, {state, green, 0.f, 1u}},
+           green);  // Triangle with stencil reference 1 draws because 1 == (3 & 1)
 }
 
 // Test that the stencil operation is executed on stencil fail
@@ -605,10 +634,13 @@
     state.stencilReadMask = 0xff;
     state.stencilWriteMask = 0xff;
 
-    CheckStencil({
-        { baseState, RGBA8(255, 255, 255, 255), 1.f, 1 },   // Triangle to set stencil value to 1
-        { state, RGBA8(0, 0, 0, 255), 0.f, 2 }              // Triangle with stencil reference 2 fails the Less comparison function
-    }, 2);                                                  // Replace the stencil on failure, so it should be 2
+    CheckStencil(
+        {
+            {baseState, RGBA8(255, 255, 255, 255), 1.f, 1},  // Triangle to set stencil value to 1
+            {state, RGBA8(0, 0, 0, 255), 0.f,
+             2}  // Triangle with stencil reference 2 fails the Less comparison function
+        },
+        2);  // Replace the stencil on failure, so it should be 2
 }
 
 // Test that the stencil operation is executed on stencil pass, depth fail
@@ -639,10 +671,12 @@
     state.stencilReadMask = 0xff;
     state.stencilWriteMask = 0xff;
 
-    CheckStencil({
-        { baseState, RGBA8(255, 255, 255, 255), 0.f, 1 },   // Triangle to set stencil value to 1. Depth is 0
-        { state, RGBA8(0, 0, 0, 255), 1.f, 2 } },           // Triangle with stencil reference 2 passes the Greater comparison function. At depth 1, it fails the Less depth test
-    2);                                                     // Replace the stencil on stencil pass, depth failure, so it should be 2
+    CheckStencil({{baseState, RGBA8(255, 255, 255, 255), 0.f,
+                   1},  // Triangle to set stencil value to 1. Depth is 0
+                  {state, RGBA8(0, 0, 0, 255), 1.f,
+                   2}},  // Triangle with stencil reference 2 passes the Greater comparison
+                         // function. At depth 1, it fails the Less depth test
+                 2);     // Replace the stencil on stencil pass, depth failure, so it should be 2
 }
 
 // Test that the stencil operation is executed on stencil pass, depth pass
@@ -673,10 +707,12 @@
     state.stencilReadMask = 0xff;
     state.stencilWriteMask = 0xff;
 
-    CheckStencil({
-        { baseState, RGBA8(255, 255, 255, 255), 1.f, 1 },   // Triangle to set stencil value to 1. Depth is 0
-        { state, RGBA8(0, 0, 0, 255), 0.f, 2 } },           // Triangle with stencil reference 2 passes the Greater comparison function. At depth 0, it pass the Less depth test
-2);                                                         // Replace the stencil on stencil pass, depth pass, so it should be 2
+    CheckStencil({{baseState, RGBA8(255, 255, 255, 255), 1.f,
+                   1},  // Triangle to set stencil value to 1. Depth is 0
+                  {state, RGBA8(0, 0, 0, 255), 0.f,
+                   2}},  // Triangle with stencil reference 2 passes the Greater comparison
+                         // function. At depth 0, it pass the Less depth test
+                 2);     // Replace the stencil on stencil pass, depth pass, so it should be 2
 }
 
 // Test that creating a render pipeline works with for all depth and combined formats
diff --git a/src/tests/end2end/DestroyTests.cpp b/src/tests/end2end/DestroyTests.cpp
index 82c43a6..4122001 100644
--- a/src/tests/end2end/DestroyTests.cpp
+++ b/src/tests/end2end/DestroyTests.cpp
@@ -157,4 +157,8 @@
     ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
 }
 
-DAWN_INSTANTIATE_TEST(DestroyTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(DestroyTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/DrawIndexedTests.cpp b/src/tests/end2end/DrawIndexedTests.cpp
index 48abdad..f980af3 100644
--- a/src/tests/end2end/DrawIndexedTests.cpp
+++ b/src/tests/end2end/DrawIndexedTests.cpp
@@ -20,90 +20,89 @@
 constexpr uint32_t kRTSize = 4;
 
 class DrawIndexedTest : public DawnTest {
-    protected:
-        void SetUp() override {
-            DawnTest::SetUp();
+  protected:
+    void SetUp() override {
+        DawnTest::SetUp();
 
-            renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
+        renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
 
-            wgpu::ShaderModule vsModule =
-                utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        wgpu::ShaderModule vsModule =
+            utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
                 #version 450
                 layout(location = 0) in vec4 pos;
                 void main() {
                     gl_Position = pos;
                 })");
 
-            wgpu::ShaderModule fsModule =
-                utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        wgpu::ShaderModule fsModule =
+            utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
                 #version 450
                 layout(location = 0) out vec4 fragColor;
                 void main() {
                     fragColor = vec4(0.0, 1.0, 0.0, 1.0);
                 })");
 
-            utils::ComboRenderPipelineDescriptor descriptor(device);
-            descriptor.vertexStage.module = vsModule;
-            descriptor.cFragmentStage.module = fsModule;
-            descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
-            descriptor.cVertexState.vertexBufferCount = 1;
-            descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
-            descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
-            descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
-            descriptor.cColorStates[0].format = renderPass.colorFormat;
+        utils::ComboRenderPipelineDescriptor descriptor(device);
+        descriptor.vertexStage.module = vsModule;
+        descriptor.cFragmentStage.module = fsModule;
+        descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
+        descriptor.cVertexState.vertexBufferCount = 1;
+        descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
+        descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
+        descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
+        descriptor.cColorStates[0].format = renderPass.colorFormat;
 
-            pipeline = device.CreateRenderPipeline(&descriptor);
+        pipeline = device.CreateRenderPipeline(&descriptor);
 
-            vertexBuffer = utils::CreateBufferFromData<float>(
-                device, wgpu::BufferUsage::Vertex,
-                {// First quad: the first 3 vertices represent the bottom left triangle
-                 -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 1.0f,
-                 1.0f, 0.0f, 1.0f,
+        vertexBuffer = utils::CreateBufferFromData<float>(
+            device, wgpu::BufferUsage::Vertex,
+            {// First quad: the first 3 vertices represent the bottom left triangle
+             -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f,
+             0.0f, 1.0f,
 
-                 // Second quad: the first 3 vertices represent the top right triangle
-                 -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f,
-                 -1.0f, 0.0f, 1.0f});
-            indexBuffer = utils::CreateBufferFromData<uint32_t>(
-                device, wgpu::BufferUsage::Index,
-                {0, 1, 2, 0, 3, 1,
-                 // The indices below are added to test negatve baseVertex
-                 0 + 4, 1 + 4, 2 + 4, 0 + 4, 3 + 4, 1 + 4});
+             // Second quad: the first 3 vertices represent the top right triangle
+             -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f,
+             0.0f, 1.0f});
+        indexBuffer = utils::CreateBufferFromData<uint32_t>(
+            device, wgpu::BufferUsage::Index,
+            {0, 1, 2, 0, 3, 1,
+             // The indices below are added to test negatve baseVertex
+             0 + 4, 1 + 4, 2 + 4, 0 + 4, 3 + 4, 1 + 4});
+    }
+
+    utils::BasicRenderPass renderPass;
+    wgpu::RenderPipeline pipeline;
+    wgpu::Buffer vertexBuffer;
+    wgpu::Buffer indexBuffer;
+
+    void Test(uint32_t indexCount,
+              uint32_t instanceCount,
+              uint32_t firstIndex,
+              int32_t baseVertex,
+              uint32_t firstInstance,
+              uint64_t bufferOffset,
+              RGBA8 bottomLeftExpected,
+              RGBA8 topRightExpected) {
+        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+        {
+            wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
+            pass.SetPipeline(pipeline);
+            pass.SetVertexBuffer(0, vertexBuffer);
+            pass.SetIndexBuffer(indexBuffer, bufferOffset);
+            pass.DrawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+            pass.EndPass();
         }
 
-        utils::BasicRenderPass renderPass;
-        wgpu::RenderPipeline pipeline;
-        wgpu::Buffer vertexBuffer;
-        wgpu::Buffer indexBuffer;
+        wgpu::CommandBuffer commands = encoder.Finish();
+        queue.Submit(1, &commands);
 
-        void Test(uint32_t indexCount,
-                  uint32_t instanceCount,
-                  uint32_t firstIndex,
-                  int32_t baseVertex,
-                  uint32_t firstInstance,
-                  uint64_t bufferOffset,
-                  RGBA8 bottomLeftExpected,
-                  RGBA8 topRightExpected) {
-            wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-            {
-                wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
-                pass.SetPipeline(pipeline);
-                pass.SetVertexBuffer(0, vertexBuffer);
-                pass.SetIndexBuffer(indexBuffer, bufferOffset);
-                pass.DrawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
-                pass.EndPass();
-            }
-
-            wgpu::CommandBuffer commands = encoder.Finish();
-            queue.Submit(1, &commands);
-
-            EXPECT_PIXEL_RGBA8_EQ(bottomLeftExpected, renderPass.color, 1, 3);
-            EXPECT_PIXEL_RGBA8_EQ(topRightExpected, renderPass.color, 3, 1);
-        }
+        EXPECT_PIXEL_RGBA8_EQ(bottomLeftExpected, renderPass.color, 1, 3);
+        EXPECT_PIXEL_RGBA8_EQ(topRightExpected, renderPass.color, 3, 1);
+    }
 };
 
 // The most basic DrawIndexed triangle draw.
 TEST_P(DrawIndexedTest, Uint32) {
-
     RGBA8 filled(0, 255, 0, 255);
     RGBA8 notFilled(0, 0, 0, 0);
 
@@ -134,4 +133,8 @@
     Test(3, 1, 3, -4, 0, 6 * sizeof(uint32_t), notFilled, filled);
 }
 
-DAWN_INSTANTIATE_TEST(DrawIndexedTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(DrawIndexedTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/DrawIndirectTests.cpp b/src/tests/end2end/DrawIndirectTests.cpp
index 3f14375..56b55ec 100644
--- a/src/tests/end2end/DrawIndirectTests.cpp
+++ b/src/tests/end2end/DrawIndirectTests.cpp
@@ -124,4 +124,8 @@
     Test({3, 1, 0, 0, 3, 1, 3, 0}, 4 * sizeof(uint32_t), notFilled, filled);
 }
 
-DAWN_INSTANTIATE_TEST(DrawIndirectTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(DrawIndirectTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/GpuMemorySynchronizationTests.cpp b/src/tests/end2end/GpuMemorySynchronizationTests.cpp
index 3b4dcd1..4cf64d0 100644
--- a/src/tests/end2end/GpuMemorySynchronizationTests.cpp
+++ b/src/tests/end2end/GpuMemorySynchronizationTests.cpp
@@ -231,7 +231,11 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8(2, 0, 0, 255), renderPass.color, 0, 0);
 }
 
-DAWN_INSTANTIATE_TEST(GpuMemorySyncTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(GpuMemorySyncTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 class StorageToUniformSyncTests : public DawnTest {
   protected:
diff --git a/src/tests/end2end/IOSurfaceWrappingTests.cpp b/src/tests/end2end/IOSurfaceWrappingTests.cpp
index af40c1b..9e44cb7 100644
--- a/src/tests/end2end/IOSurfaceWrappingTests.cpp
+++ b/src/tests/end2end/IOSurfaceWrappingTests.cpp
@@ -369,7 +369,8 @@
 // Test sampling from a R8 IOSurface
 TEST_P(IOSurfaceUsageTests, SampleFromR8IOSurface) {
     DAWN_SKIP_TEST_IF(UsesWire());
-    ScopedIOSurfaceRef ioSurface = CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_OneComponent8, 1);
+    ScopedIOSurfaceRef ioSurface =
+        CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_OneComponent8, 1);
 
     uint8_t data = 0x01;
     DoSampleTest(ioSurface.get(), wgpu::TextureFormat::R8Unorm, &data, sizeof(data),
@@ -379,7 +380,8 @@
 // Test clearing a R8 IOSurface
 TEST_P(IOSurfaceUsageTests, ClearR8IOSurface) {
     DAWN_SKIP_TEST_IF(UsesWire());
-    ScopedIOSurfaceRef ioSurface = CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_OneComponent8, 1);
+    ScopedIOSurfaceRef ioSurface =
+        CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_OneComponent8, 1);
 
     uint8_t data = 0x01;
     DoClearTest(ioSurface.get(), wgpu::TextureFormat::R8Unorm, &data, sizeof(data));
@@ -388,7 +390,8 @@
 // Test sampling from a RG8 IOSurface
 TEST_P(IOSurfaceUsageTests, SampleFromRG8IOSurface) {
     DAWN_SKIP_TEST_IF(UsesWire());
-    ScopedIOSurfaceRef ioSurface = CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_TwoComponent8, 2);
+    ScopedIOSurfaceRef ioSurface =
+        CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_TwoComponent8, 2);
 
     uint16_t data = 0x0102;  // Stored as (G, R)
     DoSampleTest(ioSurface.get(), wgpu::TextureFormat::RG8Unorm, &data, sizeof(data),
@@ -398,7 +401,8 @@
 // Test clearing a RG8 IOSurface
 TEST_P(IOSurfaceUsageTests, ClearRG8IOSurface) {
     DAWN_SKIP_TEST_IF(UsesWire());
-    ScopedIOSurfaceRef ioSurface = CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_TwoComponent8, 2);
+    ScopedIOSurfaceRef ioSurface =
+        CreateSinglePlaneIOSurface(1, 1, kCVPixelFormatType_TwoComponent8, 2);
 
     uint16_t data = 0x0201;
     DoClearTest(ioSurface.get(), wgpu::TextureFormat::RG8Unorm, &data, sizeof(data));
diff --git a/src/tests/end2end/IndexFormatTests.cpp b/src/tests/end2end/IndexFormatTests.cpp
index ea83e91..554c674 100644
--- a/src/tests/end2end/IndexFormatTests.cpp
+++ b/src/tests/end2end/IndexFormatTests.cpp
@@ -21,45 +21,45 @@
 constexpr uint32_t kRTSize = 400;
 
 class IndexFormatTest : public DawnTest {
-    protected:
-        void SetUp() override {
-            DawnTest::SetUp();
+  protected:
+    void SetUp() override {
+        DawnTest::SetUp();
 
-            renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
-        }
+        renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
+    }
 
-        utils::BasicRenderPass renderPass;
+    utils::BasicRenderPass renderPass;
 
-        wgpu::RenderPipeline MakeTestPipeline(wgpu::IndexFormat format) {
-            wgpu::ShaderModule vsModule =
-                utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+    wgpu::RenderPipeline MakeTestPipeline(wgpu::IndexFormat format) {
+        wgpu::ShaderModule vsModule =
+            utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
                 #version 450
                 layout(location = 0) in vec4 pos;
                 void main() {
                     gl_Position = pos;
                 })");
 
-            wgpu::ShaderModule fsModule =
-                utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        wgpu::ShaderModule fsModule =
+            utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
                 #version 450
                 layout(location = 0) out vec4 fragColor;
                 void main() {
                     fragColor = vec4(0.0, 1.0, 0.0, 1.0);
                 })");
 
-            utils::ComboRenderPipelineDescriptor descriptor(device);
-            descriptor.vertexStage.module = vsModule;
-            descriptor.cFragmentStage.module = fsModule;
-            descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
-            descriptor.cVertexState.indexFormat = format;
-            descriptor.cVertexState.vertexBufferCount = 1;
-            descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
-            descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
-            descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
-            descriptor.cColorStates[0].format = renderPass.colorFormat;
+        utils::ComboRenderPipelineDescriptor descriptor(device);
+        descriptor.vertexStage.module = vsModule;
+        descriptor.cFragmentStage.module = fsModule;
+        descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
+        descriptor.cVertexState.indexFormat = format;
+        descriptor.cVertexState.vertexBufferCount = 1;
+        descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
+        descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
+        descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
+        descriptor.cColorStates[0].format = renderPass.colorFormat;
 
-            return device.CreateRenderPipeline(&descriptor);
-        }
+        return device.CreateRenderPipeline(&descriptor);
+    }
 };
 
 // Test that the Uint32 index format is correctly interpreted
@@ -275,4 +275,8 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 100, 300);
 }
 
-DAWN_INSTANTIATE_TEST(IndexFormatTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(IndexFormatTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/MultisampledRenderingTests.cpp b/src/tests/end2end/MultisampledRenderingTests.cpp
index ef03bf2..0605594 100644
--- a/src/tests/end2end/MultisampledRenderingTests.cpp
+++ b/src/tests/end2end/MultisampledRenderingTests.cpp
@@ -61,7 +61,6 @@
 
         const char* fs = testDepth ? kFsOneOutputWithDepth : kFsOneOutputWithoutDepth;
 
-
         return CreateRenderPipelineForTest(fs, 1, testDepth);
     }
 
@@ -285,8 +284,8 @@
         utils::ComboRenderPassDescriptor renderPass =
             CreateComboRenderPassDescriptorForTest({mMultisampledColorView}, {mResolveView},
                                                    wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, true);
-        std::array<float, 5> kUniformData = {kGreen.r, kGreen.g, kGreen.b, kGreen.a, // Color
-                                             0.2f};                                  // depth
+        std::array<float, 5> kUniformData = {kGreen.r, kGreen.g, kGreen.b, kGreen.a,  // Color
+                                             0.2f};                                   // depth
         constexpr uint32_t kSize = sizeof(kUniformData);
         EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize);
     }
@@ -299,8 +298,8 @@
             {mMultisampledColorView}, {mResolveView}, wgpu::LoadOp::Load, wgpu::LoadOp::Load,
             kTestDepth);
 
-        std::array<float, 8> kUniformData = {kRed.r, kRed.g, kRed.b, kRed.a, // color
-                                             0.5f};                          // depth
+        std::array<float, 8> kUniformData = {kRed.r, kRed.g, kRed.b, kRed.a,  // color
+                                             0.5f};                           // depth
         constexpr uint32_t kSize = sizeof(kUniformData);
         EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize);
     }
@@ -369,8 +368,8 @@
             {mMultisampledColorView, multisampledColorView2}, {mResolveView, resolveView2},
             wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, kTestDepth);
 
-        std::array<float, 8> kUniformData = {kRed.r, kRed.g, kRed.b, kRed.a,          // color1
-                                             kGreen.r, kGreen.g, kGreen.b, kGreen.a}; // color2
+        std::array<float, 8> kUniformData = {kRed.r,   kRed.g,   kRed.b,   kRed.a,     // color1
+                                             kGreen.r, kGreen.g, kGreen.b, kGreen.a};  // color2
         constexpr uint32_t kSize = sizeof(kUniformData);
         EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize);
     }
@@ -503,8 +502,8 @@
             {mMultisampledColorView, multisampledColorView2}, {resolveView1, resolveView2},
             wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, kTestDepth);
 
-        std::array<float, 8> kUniformData = {kRed.r, kRed.g, kRed.b, kRed.a,          // color1
-                                             kGreen.r, kGreen.g, kGreen.b, kGreen.a}; // color2
+        std::array<float, 8> kUniformData = {kRed.r,   kRed.g,   kRed.b,   kRed.a,     // color1
+                                             kGreen.r, kGreen.g, kGreen.b, kGreen.a};  // color2
         constexpr uint32_t kSize = sizeof(kUniformData);
         EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize);
     }
diff --git a/src/tests/end2end/NonzeroTextureCreationTests.cpp b/src/tests/end2end/NonzeroTextureCreationTests.cpp
index 9ee9e80..97759af 100644
--- a/src/tests/end2end/NonzeroTextureCreationTests.cpp
+++ b/src/tests/end2end/NonzeroTextureCreationTests.cpp
@@ -292,6 +292,6 @@
                       MetalBackend({"nonzero_clear_resources_on_creation_for_testing"},
                                    {"lazy_clear_resource_on_first_use"}),
                       OpenGLBackend({"nonzero_clear_resources_on_creation_for_testing"},
-                                   {"lazy_clear_resource_on_first_use"}),
+                                    {"lazy_clear_resource_on_first_use"}),
                       VulkanBackend({"nonzero_clear_resources_on_creation_for_testing"},
-                                   {"lazy_clear_resource_on_first_use"}));
+                                    {"lazy_clear_resource_on_first_use"}));
diff --git a/src/tests/end2end/ObjectCachingTests.cpp b/src/tests/end2end/ObjectCachingTests.cpp
index d27a3f5..20705a9 100644
--- a/src/tests/end2end/ObjectCachingTests.cpp
+++ b/src/tests/end2end/ObjectCachingTests.cpp
@@ -400,4 +400,8 @@
     EXPECT_EQ(sampler.Get() == sameSampler.Get(), !UsesWire());
 }
 
-DAWN_INSTANTIATE_TEST(ObjectCachingTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(ObjectCachingTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/OpArrayLengthTests.cpp b/src/tests/end2end/OpArrayLengthTests.cpp
index 3e6a043..2d8e465 100644
--- a/src/tests/end2end/OpArrayLengthTests.cpp
+++ b/src/tests/end2end/OpArrayLengthTests.cpp
@@ -262,4 +262,8 @@
     EXPECT_PIXEL_RGBA8_EQ(expectedColor, renderPass.color, 0, 0);
 }
 
-DAWN_INSTANTIATE_TEST(OpArrayLengthTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(OpArrayLengthTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/PipelineLayoutTests.cpp b/src/tests/end2end/PipelineLayoutTests.cpp
index 6e71234..a4a02e9 100644
--- a/src/tests/end2end/PipelineLayoutTests.cpp
+++ b/src/tests/end2end/PipelineLayoutTests.cpp
@@ -62,4 +62,4 @@
                       D3D12Backend(),
                       MetalBackend(),
                       OpenGLBackend(),
-                      VulkanBackend());
\ No newline at end of file
+                      VulkanBackend());
diff --git a/src/tests/end2end/PrimitiveTopologyTests.cpp b/src/tests/end2end/PrimitiveTopologyTests.cpp
index 822bfee..0c0c285 100644
--- a/src/tests/end2end/PrimitiveTopologyTests.cpp
+++ b/src/tests/end2end/PrimitiveTopologyTests.cpp
@@ -18,7 +18,8 @@
 #include "utils/ComboRenderPipelineDescriptor.h"
 #include "utils/WGPUHelpers.h"
 
-// Primitive topology tests work by drawing the following vertices with all the different primitive topology states:
+// Primitive topology tests work by drawing the following vertices with all the different primitive
+// topology states:
 // -------------------------------------
 // |                                   |
 // |        1        2        5        |
@@ -81,8 +82,8 @@
 // -------------------------------------
 //
 // Each of these different states is a superset of some of the previous states,
-// so for every state, we check any new added test locations that are not contained in previous states
-// We also check that the test locations of subsequent states are untouched
+// so for every state, we check any new added test locations that are not contained in previous
+// states We also check that the test locations of subsequent states are untouched
 
 constexpr static unsigned int kRTSize = 32;
 
@@ -91,11 +92,13 @@
 };
 
 constexpr TestLocation GetMidpoint(const TestLocation& a, const TestLocation& b) noexcept {
-    return { (a.x + b.x) / 2, (a.y + b.y) / 2 };
+    return {(a.x + b.x) / 2, (a.y + b.y) / 2};
 }
 
-constexpr TestLocation GetCentroid(const TestLocation& a, const TestLocation& b, const TestLocation& c) noexcept {
-    return { (a.x + b.x + c.x) / 3, (a.y + b.y + c.y) / 3 };
+constexpr TestLocation GetCentroid(const TestLocation& a,
+                                   const TestLocation& b,
+                                   const TestLocation& c) noexcept {
+    return {(a.x + b.x + c.x) / 3, (a.y + b.y + c.y) / 3};
 }
 
 // clang-format off
@@ -144,13 +147,13 @@
 // clang-format on
 
 class PrimitiveTopologyTest : public DawnTest {
-    protected:
-        void SetUp() override {
-            DawnTest::SetUp();
+  protected:
+    void SetUp() override {
+        DawnTest::SetUp();
 
-            renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
+        renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
 
-            vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
                 #version 450
                 layout(location = 0) in vec4 pos;
                 void main() {
@@ -158,69 +161,73 @@
                     gl_PointSize = 1.0;
                 })");
 
-            fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
                 #version 450
                 layout(location = 0) out vec4 fragColor;
                 void main() {
                     fragColor = vec4(0.0, 1.0, 0.0, 1.0);
                 })");
 
-            vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                       wgpu::BufferUsage::Vertex);
+        vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
+                                                   wgpu::BufferUsage::Vertex);
+    }
+
+    struct LocationSpec {
+        const TestLocation* locations;
+        size_t count;
+        bool include;
+    };
+
+    template <std::size_t N>
+    constexpr LocationSpec TestPoints(TestLocation const (&points)[N], bool include) noexcept {
+        return {points, N, include};
+    }
+
+    // Draw the vertices with the given primitive topology and check the pixel values of the test
+    // locations
+    void DoTest(wgpu::PrimitiveTopology primitiveTopology,
+                const std::vector<LocationSpec>& locationSpecs) {
+        utils::ComboRenderPipelineDescriptor descriptor(device);
+        descriptor.vertexStage.module = vsModule;
+        descriptor.cFragmentStage.module = fsModule;
+        descriptor.primitiveTopology = primitiveTopology;
+        descriptor.cVertexState.vertexBufferCount = 1;
+        descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
+        descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
+        descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
+        descriptor.cColorStates[0].format = renderPass.colorFormat;
+
+        wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
+
+        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+        {
+            wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
+            pass.SetPipeline(pipeline);
+            pass.SetVertexBuffer(0, vertexBuffer);
+            pass.Draw(6);
+            pass.EndPass();
         }
 
-        struct LocationSpec {
-            const TestLocation* locations;
-            size_t count;
-            bool include;
-        };
+        wgpu::CommandBuffer commands = encoder.Finish();
+        queue.Submit(1, &commands);
 
-        template <std::size_t N>
-        constexpr LocationSpec TestPoints(TestLocation const (&points)[N], bool include) noexcept {
-            return { points, N, include };
-        }
-
-        // Draw the vertices with the given primitive topology and check the pixel values of the test locations
-        void DoTest(wgpu::PrimitiveTopology primitiveTopology,
-                    const std::vector<LocationSpec>& locationSpecs) {
-            utils::ComboRenderPipelineDescriptor descriptor(device);
-            descriptor.vertexStage.module = vsModule;
-            descriptor.cFragmentStage.module = fsModule;
-            descriptor.primitiveTopology = primitiveTopology;
-            descriptor.cVertexState.vertexBufferCount = 1;
-            descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
-            descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
-            descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
-            descriptor.cColorStates[0].format = renderPass.colorFormat;
-
-            wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
-
-            wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-            {
-                wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
-                pass.SetPipeline(pipeline);
-                pass.SetVertexBuffer(0, vertexBuffer);
-                pass.Draw(6);
-                pass.EndPass();
-            }
-
-            wgpu::CommandBuffer commands = encoder.Finish();
-            queue.Submit(1, &commands);
-
-            for (auto& locationSpec : locationSpecs) {
-                for (size_t i = 0; i < locationSpec.count; ++i) {
-                    // If this pixel is included, check that it is green. Otherwise, check that it is black
-                    RGBA8 color = locationSpec.include ? RGBA8::kGreen : RGBA8::kZero;
-                    EXPECT_PIXEL_RGBA8_EQ(color, renderPass.color, locationSpec.locations[i].x, locationSpec.locations[i].y)
-                        << "Expected (" << locationSpec.locations[i].x << ", " << locationSpec.locations[i].y << ") to be " << color;
-                }
+        for (auto& locationSpec : locationSpecs) {
+            for (size_t i = 0; i < locationSpec.count; ++i) {
+                // If this pixel is included, check that it is green. Otherwise, check that it is
+                // black
+                RGBA8 color = locationSpec.include ? RGBA8::kGreen : RGBA8::kZero;
+                EXPECT_PIXEL_RGBA8_EQ(color, renderPass.color, locationSpec.locations[i].x,
+                                      locationSpec.locations[i].y)
+                    << "Expected (" << locationSpec.locations[i].x << ", "
+                    << locationSpec.locations[i].y << ") to be " << color;
             }
         }
+    }
 
-        utils::BasicRenderPass renderPass;
-        wgpu::ShaderModule vsModule;
-        wgpu::ShaderModule fsModule;
-        wgpu::Buffer vertexBuffer;
+    utils::BasicRenderPass renderPass;
+    wgpu::ShaderModule vsModule;
+    wgpu::ShaderModule fsModule;
+    wgpu::Buffer vertexBuffer;
 };
 
 // Test Point primitive topology
@@ -286,4 +293,8 @@
            });
 }
 
-DAWN_INSTANTIATE_TEST(PrimitiveTopologyTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(PrimitiveTopologyTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/RenderBundleTests.cpp b/src/tests/end2end/RenderBundleTests.cpp
index 0df87c3..c58eb8c 100644
--- a/src/tests/end2end/RenderBundleTests.cpp
+++ b/src/tests/end2end/RenderBundleTests.cpp
@@ -196,4 +196,8 @@
     EXPECT_PIXEL_RGBA8_EQ(kColors[1], renderPass.color, 3, 1);
 }
 
-DAWN_INSTANTIATE_TEST(RenderBundleTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(RenderBundleTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/RenderPassLoadOpTests.cpp b/src/tests/end2end/RenderPassLoadOpTests.cpp
index db7b6a9..011c6e0 100644
--- a/src/tests/end2end/RenderPassLoadOpTests.cpp
+++ b/src/tests/end2end/RenderPassLoadOpTests.cpp
@@ -22,62 +22,61 @@
 constexpr static unsigned int kRTSize = 16;
 
 class DrawQuad {
-    public:
-        DrawQuad() {}
-        DrawQuad(wgpu::Device device, const char* vsSource, const char* fsSource) : device(device) {
-            vsModule =
-                utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, vsSource);
-            fsModule =
-                utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, fsSource);
+  public:
+    DrawQuad() {
+    }
+    DrawQuad(wgpu::Device device, const char* vsSource, const char* fsSource) : device(device) {
+        vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, vsSource);
+        fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, fsSource);
 
-            pipelineLayout = utils::MakeBasicPipelineLayout(device, nullptr);
-        }
+        pipelineLayout = utils::MakeBasicPipelineLayout(device, nullptr);
+    }
 
-        void Draw(wgpu::RenderPassEncoder* pass) {
-            utils::ComboRenderPipelineDescriptor descriptor(device);
-            descriptor.layout = pipelineLayout;
-            descriptor.vertexStage.module = vsModule;
-            descriptor.cFragmentStage.module = fsModule;
+    void Draw(wgpu::RenderPassEncoder* pass) {
+        utils::ComboRenderPipelineDescriptor descriptor(device);
+        descriptor.layout = pipelineLayout;
+        descriptor.vertexStage.module = vsModule;
+        descriptor.cFragmentStage.module = fsModule;
 
-            auto renderPipeline = device.CreateRenderPipeline(&descriptor);
+        auto renderPipeline = device.CreateRenderPipeline(&descriptor);
 
-            pass->SetPipeline(renderPipeline);
-            pass->Draw(6, 1, 0, 0);
-        }
+        pass->SetPipeline(renderPipeline);
+        pass->Draw(6, 1, 0, 0);
+    }
 
-    private:
-      wgpu::Device device;
-      wgpu::ShaderModule vsModule = {};
-      wgpu::ShaderModule fsModule = {};
-      wgpu::PipelineLayout pipelineLayout = {};
+  private:
+    wgpu::Device device;
+    wgpu::ShaderModule vsModule = {};
+    wgpu::ShaderModule fsModule = {};
+    wgpu::PipelineLayout pipelineLayout = {};
 };
 
 class RenderPassLoadOpTests : public DawnTest {
-    protected:
-        void SetUp() override {
-            DawnTest::SetUp();
+  protected:
+    void SetUp() override {
+        DawnTest::SetUp();
 
-            wgpu::TextureDescriptor descriptor;
-            descriptor.dimension = wgpu::TextureDimension::e2D;
-            descriptor.size.width = kRTSize;
-            descriptor.size.height = kRTSize;
-            descriptor.size.depth = 1;
-            descriptor.sampleCount = 1;
-            descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
-            descriptor.mipLevelCount = 1;
-            descriptor.usage = wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::CopySrc;
-            renderTarget = device.CreateTexture(&descriptor);
+        wgpu::TextureDescriptor descriptor;
+        descriptor.dimension = wgpu::TextureDimension::e2D;
+        descriptor.size.width = kRTSize;
+        descriptor.size.height = kRTSize;
+        descriptor.size.depth = 1;
+        descriptor.sampleCount = 1;
+        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
+        descriptor.mipLevelCount = 1;
+        descriptor.usage = wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::CopySrc;
+        renderTarget = device.CreateTexture(&descriptor);
 
-            renderTargetView = renderTarget.CreateView();
+        renderTargetView = renderTarget.CreateView();
 
-            std::fill(expectZero.begin(), expectZero.end(), RGBA8::kZero);
+        std::fill(expectZero.begin(), expectZero.end(), RGBA8::kZero);
 
-            std::fill(expectGreen.begin(), expectGreen.end(), RGBA8::kGreen);
+        std::fill(expectGreen.begin(), expectGreen.end(), RGBA8::kGreen);
 
-            std::fill(expectBlue.begin(), expectBlue.end(), RGBA8::kBlue);
+        std::fill(expectBlue.begin(), expectBlue.end(), RGBA8::kBlue);
 
-            // draws a blue quad on the right half of the screen
-            const char* vsSource = R"(
+        // draws a blue quad on the right half of the screen
+        const char* vsSource = R"(
                 #version 450
                 void main() {
                     const vec2 pos[6] = vec2[6](
@@ -86,24 +85,24 @@
                     gl_Position = vec4(pos[gl_VertexIndex], 0.f, 1.f);
                 }
                 )";
-            const char* fsSource = R"(
+        const char* fsSource = R"(
                 #version 450
                 layout(location = 0) out vec4 color;
                 void main() {
                     color = vec4(0.f, 0.f, 1.f, 1.f);
                 }
                 )";
-            blueQuad = DrawQuad(device, vsSource, fsSource);
-        }
+        blueQuad = DrawQuad(device, vsSource, fsSource);
+    }
 
-        wgpu::Texture renderTarget;
-        wgpu::TextureView renderTargetView;
+    wgpu::Texture renderTarget;
+    wgpu::TextureView renderTargetView;
 
-        std::array<RGBA8, kRTSize * kRTSize> expectZero;
-        std::array<RGBA8, kRTSize * kRTSize> expectGreen;
-        std::array<RGBA8, kRTSize * kRTSize> expectBlue;
+    std::array<RGBA8, kRTSize * kRTSize> expectZero;
+    std::array<RGBA8, kRTSize * kRTSize> expectGreen;
+    std::array<RGBA8, kRTSize * kRTSize> expectBlue;
 
-        DrawQuad blueQuad = {};
+    DrawQuad blueQuad = {};
 };
 
 // Tests clearing, loading, and drawing into color attachments
@@ -144,7 +143,12 @@
     // Left half should still be green
     EXPECT_TEXTURE_RGBA8_EQ(expectGreen.data(), renderTarget, 0, 0, kRTSize / 2, kRTSize, 0, 0);
     // Right half should now be blue
-    EXPECT_TEXTURE_RGBA8_EQ(expectBlue.data(), renderTarget, kRTSize / 2, 0, kRTSize / 2, kRTSize, 0, 0);
+    EXPECT_TEXTURE_RGBA8_EQ(expectBlue.data(), renderTarget, kRTSize / 2, 0, kRTSize / 2, kRTSize,
+                            0, 0);
 }
 
-DAWN_INSTANTIATE_TEST(RenderPassLoadOpTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(RenderPassLoadOpTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/RenderPassTests.cpp b/src/tests/end2end/RenderPassTests.cpp
index ead9bee..74069ff 100644
--- a/src/tests/end2end/RenderPassTests.cpp
+++ b/src/tests/end2end/RenderPassTests.cpp
@@ -21,7 +21,7 @@
 constexpr wgpu::TextureFormat kFormat = wgpu::TextureFormat::RGBA8Unorm;
 
 class RenderPassTest : public DawnTest {
-protected:
+  protected:
     void SetUp() override {
         DawnTest::SetUp();
 
@@ -71,9 +71,9 @@
 // Test using two different render passes in one commandBuffer works correctly.
 TEST_P(RenderPassTest, TwoRenderPassesInOneCommandBuffer) {
     if (IsOpenGL() || IsMetal()) {
-      // crbug.com/950768
-      // This test is consistently failing on OpenGL and flaky on Metal.
-      return;
+        // crbug.com/950768
+        // This test is consistently failing on OpenGL and flaky on Metal.
+        return;
     }
 
     wgpu::Texture renderTarget1 = CreateDefault2DTexture();
diff --git a/src/tests/end2end/SamplerTests.cpp b/src/tests/end2end/SamplerTests.cpp
index d40f099..ad5ed92 100644
--- a/src/tests/end2end/SamplerTests.cpp
+++ b/src/tests/end2end/SamplerTests.cpp
@@ -46,10 +46,10 @@
             255,
         },
     };
-}
+}  // namespace
 
 class SamplerTest : public DawnTest {
-protected:
+  protected:
     void SetUp() override {
         DawnTest::SetUp();
         mRenderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
@@ -177,4 +177,8 @@
     }
 }
 
-DAWN_INSTANTIATE_TEST(SamplerTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(SamplerTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/ScissorTests.cpp b/src/tests/end2end/ScissorTests.cpp
index f674303..98722d0 100644
--- a/src/tests/end2end/ScissorTests.cpp
+++ b/src/tests/end2end/ScissorTests.cpp
@@ -17,7 +17,7 @@
 #include "utils/ComboRenderPipelineDescriptor.h"
 #include "utils/WGPUHelpers.h"
 
-class ScissorTest: public DawnTest {
+class ScissorTest : public DawnTest {
   protected:
     wgpu::RenderPipeline CreateQuadPipeline(wgpu::TextureFormat format) {
         wgpu::ShaderModule vsModule =
@@ -152,4 +152,8 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8::kGreen, renderPass.color, 99, 99);
 }
 
-DAWN_INSTANTIATE_TEST(ScissorTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(ScissorTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/TextureFormatTests.cpp b/src/tests/end2end/TextureFormatTests.cpp
index 06f70a5..cad7b31 100644
--- a/src/tests/end2end/TextureFormatTests.cpp
+++ b/src/tests/end2end/TextureFormatTests.cpp
@@ -404,7 +404,7 @@
         ASSERT(sizeof(float) * formatInfo.componentCount == formatInfo.texelByteSize);
         ASSERT(formatInfo.type == wgpu::TextureComponentType::Float);
 
-        std::vector<float> textureData = {+0.0f,  -0.0f, 1.0f,     1.0e-29f,
+        std::vector<float> textureData = {+0.0f,   -0.0f, 1.0f,     1.0e-29f,
                                           1.0e29f, NAN,   INFINITY, -INFINITY};
 
         DoFloatFormatSamplingTest(formatInfo, textureData, textureData);
@@ -733,4 +733,8 @@
 // TODO(cwallez@chromium.org): Add tests for depth-stencil formats when we know if they are copyable
 // in WebGPU.
 
-DAWN_INSTANTIATE_TEST(TextureFormatTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(TextureFormatTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/TextureViewTests.cpp b/src/tests/end2end/TextureViewTests.cpp
index acab158..4697169 100644
--- a/src/tests/end2end/TextureViewTests.cpp
+++ b/src/tests/end2end/TextureViewTests.cpp
@@ -70,7 +70,7 @@
 }  // anonymous namespace
 
 class TextureViewSamplingTest : public DawnTest {
-protected:
+  protected:
     // Generates an arbitrary pixel value per-layer-per-level, used for the "actual" uploaded
     // textures and the "expected" results.
     static int GenerateTestPixelValue(uint32_t layer, uint32_t level) {
@@ -104,8 +104,8 @@
         const uint32_t textureHeightLevel0 = 1 << mipLevelCount;
         constexpr wgpu::TextureUsage kUsage =
             wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::Sampled;
-        mTexture = Create2DTexture(
-            device, textureWidthLevel0, textureHeightLevel0, arrayLayerCount, mipLevelCount, kUsage);
+        mTexture = Create2DTexture(device, textureWidthLevel0, textureHeightLevel0, arrayLayerCount,
+                                   mipLevelCount, kUsage);
 
         mDefaultTextureViewDescriptor.dimension = wgpu::TextureViewDimension::e2DArray;
         mDefaultTextureViewDescriptor.format = kDefaultFormat;
@@ -145,10 +145,7 @@
         queue.Submit(1, &copy);
     }
 
-    void Verify(const wgpu::TextureView& textureView,
-                const char* fragmentShader,
-                int expected) {
-
+    void Verify(const wgpu::TextureView& textureView, const char* fragmentShader, int expected) {
         wgpu::ShaderModule fsModule =
             utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, fragmentShader);
 
@@ -176,8 +173,8 @@
 
         RGBA8 expectedPixel(0, 0, 0, expected);
         EXPECT_PIXEL_RGBA8_EQ(expectedPixel, mRenderPass.color, 0, 0);
-        EXPECT_PIXEL_RGBA8_EQ(
-            expectedPixel, mRenderPass.color, mRenderPass.width - 1, mRenderPass.height - 1);
+        EXPECT_PIXEL_RGBA8_EQ(expectedPixel, mRenderPass.color, mRenderPass.width - 1,
+                              mRenderPass.height - 1);
         // TODO(jiawei.shao@intel.com): add tests for 3D textures once Dawn supports 3D textures
     }
 
@@ -262,13 +259,13 @@
     std::string CreateFragmentShaderForCubeMapFace(uint32_t layer, bool isCubeMapArray) {
         // Reference: https://en.wikipedia.org/wiki/Cube_mapping
         const std::array<std::string, 6> kCoordsToCubeMapFace = {{
-             " 1.f,   tc,  -sc",  // Positive X
-             "-1.f,   tc,   sc",  // Negative X
-             "  sc,  1.f,  -tc",  // Positive Y
-             "  sc, -1.f,   tc",  // Negative Y
-             "  sc,   tc,  1.f",  // Positive Z
-             " -sc,   tc, -1.f",  // Negative Z
-            }};
+            " 1.f,   tc,  -sc",  // Positive X
+            "-1.f,   tc,   sc",  // Negative X
+            "  sc,  1.f,  -tc",  // Positive Y
+            "  sc, -1.f,   tc",  // Negative Y
+            "  sc,   tc,  1.f",  // Positive Z
+            " -sc,   tc, -1.f",  // Negative Z
+        }};
 
         const std::string textureType = isCubeMapArray ? "textureCubeArray" : "textureCube";
         const std::string samplerType = isCubeMapArray ? "samplerCubeArray" : "samplerCube";
@@ -279,13 +276,15 @@
         stream << R"(
             #version 450
             layout(set = 0, binding = 0) uniform sampler sampler0;
-            layout(set = 0, binding = 1) uniform )" << textureType << R"( texture0;
+            layout(set = 0, binding = 1) uniform )"
+               << textureType << R"( texture0;
             layout(location = 0) in vec2 texCoord;
             layout(location = 0) out vec4 fragColor;
             void main() {
                 float sc = 2.f * texCoord.x - 1.f;
                 float tc = 2.f * texCoord.y - 1.f;
-                fragColor = texture()" << samplerType << "(texture0, sampler0), ";
+                fragColor = texture()"
+               << samplerType << "(texture0, sampler0), ";
 
         if (isCubeMapArray) {
             stream << "vec4(" << coordToCubeMapFace << ", " << cubeMapArrayIndex;
@@ -321,7 +320,7 @@
 
         // Check the data in the every face of the cube map (array) texture view.
         for (uint32_t layer = 0; layer < textureViewLayerCount; ++layer) {
-            const std::string &fragmentShader =
+            const std::string& fragmentShader =
                 CreateFragmentShaderForCubeMapFace(layer, isCubeMapArray);
 
             int expected = GenerateTestPixelValue(textureViewBaseLayer + layer, 0);
@@ -362,8 +361,8 @@
             }
         )";
 
-    const int expected = GenerateTestPixelValue(0, 0) + GenerateTestPixelValue(1, 0) +
-                         GenerateTestPixelValue(2, 0);
+    const int expected =
+        GenerateTestPixelValue(0, 0) + GenerateTestPixelValue(1, 0) + GenerateTestPixelValue(2, 0);
     Verify(textureView, fragmentShader, expected);
 }
 
@@ -427,7 +426,8 @@
     TextureCubeMapTest(20, 3, 12, true);
 }
 
-// Test sampling from a cube map texture array view that covers the last layer of a 2D array texture.
+// Test sampling from a cube map texture array view that covers the last layer of a 2D array
+// texture.
 TEST_P(TextureViewSamplingTest, TextureCubeMapArrayViewCoveringLastLayer) {
     // Test failing on the GPU FYI Mac Pro (AMD), see
     // https://bugs.chromium.org/p/dawn/issues/detail?id=58
@@ -519,9 +519,8 @@
             bytesPerRow / kBytesPerTexel * (textureWidthLevel0 - 1) + textureHeightLevel0;
         constexpr RGBA8 kExpectedPixel(0, 255, 0, 255);
         std::vector<RGBA8> expected(expectedDataSize, kExpectedPixel);
-        EXPECT_TEXTURE_RGBA8_EQ(
-            expected.data(), texture, 0, 0, textureViewWidth, textureViewHeight,
-            textureViewBaseLevel, textureViewBaseLayer);
+        EXPECT_TEXTURE_RGBA8_EQ(expected.data(), texture, 0, 0, textureViewWidth, textureViewHeight,
+                                textureViewBaseLevel, textureViewBaseLayer);
     }
 };
 
@@ -565,7 +564,6 @@
         TextureLayerAsColorAttachmentTest(wgpu::TextureViewDimension::e2D, kLayers, kMipLevels,
                                           kBaseLayer, kBaseLevel);
     }
-
 }
 
 // Test rendering into a 1-layer 2D array texture view created on a mipmap level of a 2D texture.
@@ -610,9 +608,17 @@
     }
 }
 
-DAWN_INSTANTIATE_TEST(TextureViewSamplingTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(TextureViewSamplingTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
-DAWN_INSTANTIATE_TEST(TextureViewRenderingTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(TextureViewRenderingTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 class TextureViewTest : public DawnTest {};
 
diff --git a/src/tests/end2end/TextureZeroInitTests.cpp b/src/tests/end2end/TextureZeroInitTests.cpp
index 3333007..dbd2e76 100644
--- a/src/tests/end2end/TextureZeroInitTests.cpp
+++ b/src/tests/end2end/TextureZeroInitTests.cpp
@@ -1144,11 +1144,10 @@
     EXPECT_EQ(true, dawn_native::IsTextureSubresourceInitialized(texture.Get(), 0, 1, 0, 1));
 }
 
-DAWN_INSTANTIATE_TEST(
-    TextureZeroInitTest,
-    D3D12Backend({"nonzero_clear_resources_on_creation_for_testing"}),
-    D3D12Backend({"nonzero_clear_resources_on_creation_for_testing"},
-                 {"use_d3d12_render_pass"}),
-    OpenGLBackend({"nonzero_clear_resources_on_creation_for_testing"}),
-    MetalBackend({"nonzero_clear_resources_on_creation_for_testing"}),
-    VulkanBackend({"nonzero_clear_resources_on_creation_for_testing"}));
+DAWN_INSTANTIATE_TEST(TextureZeroInitTest,
+                      D3D12Backend({"nonzero_clear_resources_on_creation_for_testing"}),
+                      D3D12Backend({"nonzero_clear_resources_on_creation_for_testing"},
+                                   {"use_d3d12_render_pass"}),
+                      OpenGLBackend({"nonzero_clear_resources_on_creation_for_testing"}),
+                      MetalBackend({"nonzero_clear_resources_on_creation_for_testing"}),
+                      VulkanBackend({"nonzero_clear_resources_on_creation_for_testing"}));
diff --git a/src/tests/end2end/VertexFormatTests.cpp b/src/tests/end2end/VertexFormatTests.cpp
index 6030adc..a4e773a 100644
--- a/src/tests/end2end/VertexFormatTests.cpp
+++ b/src/tests/end2end/VertexFormatTests.cpp
@@ -915,4 +915,8 @@
     DoVertexFormatTest(wgpu::VertexFormat::Int4, vertexData, vertexData);
 }
 
-DAWN_INSTANTIATE_TEST(VertexFormatTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(VertexFormatTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/VertexStateTests.cpp b/src/tests/end2end/VertexStateTests.cpp
index e65fefa..1c92f34 100644
--- a/src/tests/end2end/VertexStateTests.cpp
+++ b/src/tests/end2end/VertexStateTests.cpp
@@ -543,7 +543,7 @@
         uint16_t halfs[2];
     };
     static_assert(sizeof(Data) == 16, "");
-    Data data {1.f, {2u, 3u}, {Float32ToFloat16(4.f), Float32ToFloat16(5.f)}};
+    Data data{1.f, {2u, 3u}, {Float32ToFloat16(4.f), Float32ToFloat16(5.f)}};
 
     wgpu::Buffer vertexBuffer =
         utils::CreateBufferFromData(device, &data, sizeof(data), wgpu::BufferUsage::Vertex);
@@ -599,7 +599,11 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8::kGreen, renderPass.color, 1, 1);
 }
 
-DAWN_INSTANTIATE_TEST(VertexStateTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(VertexStateTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
 
 // TODO for the input state:
 //  - Add more vertex formats
diff --git a/src/tests/end2end/ViewportOrientationTests.cpp b/src/tests/end2end/ViewportOrientationTests.cpp
index b592c21..7c2a04a 100644
--- a/src/tests/end2end/ViewportOrientationTests.cpp
+++ b/src/tests/end2end/ViewportOrientationTests.cpp
@@ -64,4 +64,8 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8::kZero, renderPass.color, 1, 1);
 }
 
-DAWN_INSTANTIATE_TEST(ViewportOrientationTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(ViewportOrientationTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/ViewportTests.cpp b/src/tests/end2end/ViewportTests.cpp
index 56dac87..2145ab4 100644
--- a/src/tests/end2end/ViewportTests.cpp
+++ b/src/tests/end2end/ViewportTests.cpp
@@ -404,4 +404,8 @@
     DoTest(info);
 }
 
-DAWN_INSTANTIATE_TEST(ViewportTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
+DAWN_INSTANTIATE_TEST(ViewportTest,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/unittests/BitSetIteratorTests.cpp b/src/tests/unittests/BitSetIteratorTests.cpp
index 34cfb6c..7bed713 100644
--- a/src/tests/unittests/BitSetIteratorTests.cpp
+++ b/src/tests/unittests/BitSetIteratorTests.cpp
@@ -20,8 +20,8 @@
 // This is ANGLE's BitSetIterator_unittests.cpp file.
 
 class BitSetIteratorTest : public testing::Test {
-    protected:
-        std::bitset<40> mStateBits;
+  protected:
+    std::bitset<40> mStateBits;
 };
 
 // Simple iterator test.
diff --git a/src/tests/unittests/BuddyAllocatorTests.cpp b/src/tests/unittests/BuddyAllocatorTests.cpp
index cdb8908..5d46630 100644
--- a/src/tests/unittests/BuddyAllocatorTests.cpp
+++ b/src/tests/unittests/BuddyAllocatorTests.cpp
@@ -324,4 +324,4 @@
     ASSERT_EQ(allocator.Allocate(16, alignment), 16ull);
 
     ASSERT_EQ(allocator.ComputeTotalNumOfFreeBlocksForTesting(), 0u);
-}
\ No newline at end of file
+}
diff --git a/src/tests/unittests/BuddyMemoryAllocatorTests.cpp b/src/tests/unittests/BuddyMemoryAllocatorTests.cpp
index a2d60ea..55da401 100644
--- a/src/tests/unittests/BuddyMemoryAllocatorTests.cpp
+++ b/src/tests/unittests/BuddyMemoryAllocatorTests.cpp
@@ -355,4 +355,4 @@
     constexpr uint64_t largeBlock = (1ull << 63) + 1;
     ResourceMemoryAllocation invalidAllocation = allocator.Allocate(largeBlock);
     ASSERT_EQ(invalidAllocation.GetInfo().mMethod, AllocationMethod::kInvalid);
-}
\ No newline at end of file
+}
diff --git a/src/tests/unittests/CommandAllocatorTests.cpp b/src/tests/unittests/CommandAllocatorTests.cpp
index 206261f..bc1d736 100644
--- a/src/tests/unittests/CommandAllocatorTests.cpp
+++ b/src/tests/unittests/CommandAllocatorTests.cpp
@@ -121,7 +121,8 @@
     uint32_t myValues[5] = {6, 42, 0xFFFFFFFF, 0, 54};
 
     {
-        CommandPushConstants* pushConstants = allocator.Allocate<CommandPushConstants>(CommandType::PushConstants);
+        CommandPushConstants* pushConstants =
+            allocator.Allocate<CommandPushConstants>(CommandType::PushConstants);
         pushConstants->size = mySize;
         pushConstants->offset = myOffset;
 
@@ -209,7 +210,7 @@
     for (int i = 0; i < kCommandCount; i++) {
         CommandBig* big = allocator.Allocate<CommandBig>(CommandType::Big);
         for (int j = 0; j < kBigBufferSize; j++) {
-            big->buffer[j] = count ++;
+            big->buffer[j] = count++;
         }
     }
 
@@ -223,9 +224,9 @@
         CommandBig* big = iterator.NextCommand<CommandBig>();
         for (int i = 0; i < kBigBufferSize; i++) {
             ASSERT_EQ(big->buffer[i], count);
-            count ++;
+            count++;
         }
-        numCommands ++;
+        numCommands++;
     }
     ASSERT_EQ(numCommands, kCommandCount);
 
@@ -242,7 +243,7 @@
     uint16_t count = 0;
     for (int i = 0; i < kCommandCount; i++) {
         CommandSmall* small = allocator.Allocate<CommandSmall>(CommandType::Small);
-        small->data = count ++;
+        small->data = count++;
     }
 
     CommandIterator iterator(std::move(allocator));
@@ -254,8 +255,8 @@
 
         CommandSmall* small = iterator.NextCommand<CommandSmall>();
         ASSERT_EQ(small->data, count);
-        count ++;
-        numCommands ++;
+        count++;
+        numCommands++;
     }
     ASSERT_EQ(numCommands, kCommandCount);
 
diff --git a/src/tests/unittests/EnumClassBitmasksTests.cpp b/src/tests/unittests/EnumClassBitmasksTests.cpp
index b706e49..c87f09f 100644
--- a/src/tests/unittests/EnumClassBitmasksTests.cpp
+++ b/src/tests/unittests/EnumClassBitmasksTests.cpp
@@ -25,7 +25,7 @@
         A = 8,
     };
 
-    template<>
+    template <>
     struct IsDawnBitmask<Color> {
         static constexpr bool enable = true;
     };
diff --git a/src/tests/unittests/ErrorTests.cpp b/src/tests/unittests/ErrorTests.cpp
index 514c740..042784d 100644
--- a/src/tests/unittests/ErrorTests.cpp
+++ b/src/tests/unittests/ErrorTests.cpp
@@ -21,278 +21,260 @@
 
 namespace {
 
-int dummySuccess = 0xbeef;
-const char* dummyErrorMessage = "I am an error message :3";
+    int dummySuccess = 0xbeef;
+    const char* dummyErrorMessage = "I am an error message :3";
 
-// Check returning a success MaybeError with {};
-TEST(ErrorTests, Error_Success) {
-    auto ReturnSuccess = []() -> MaybeError {
-        return {};
-    };
+    // Check returning a success MaybeError with {};
+    TEST(ErrorTests, Error_Success) {
+        auto ReturnSuccess = []() -> MaybeError { return {}; };
 
-    MaybeError result = ReturnSuccess();
-    ASSERT_TRUE(result.IsSuccess());
-}
+        MaybeError result = ReturnSuccess();
+        ASSERT_TRUE(result.IsSuccess());
+    }
 
-// Check returning an error MaybeError with "return DAWN_VALIDATION_ERROR"
-TEST(ErrorTests, Error_Error) {
-    auto ReturnError = []() -> MaybeError {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check returning an error MaybeError with "return DAWN_VALIDATION_ERROR"
+    TEST(ErrorTests, Error_Error) {
+        auto ReturnError = []() -> MaybeError { return DAWN_VALIDATION_ERROR(dummyErrorMessage); };
 
-    MaybeError result = ReturnError();
-    ASSERT_TRUE(result.IsError());
+        MaybeError result = ReturnError();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
-// Check returning a success ResultOrError with an implicit conversion
-TEST(ErrorTests, ResultOrError_Success) {
-    auto ReturnSuccess = []() -> ResultOrError<int*> {
-        return &dummySuccess;
-    };
+    // Check returning a success ResultOrError with an implicit conversion
+    TEST(ErrorTests, ResultOrError_Success) {
+        auto ReturnSuccess = []() -> ResultOrError<int*> { return &dummySuccess; };
 
-    ResultOrError<int*> result = ReturnSuccess();
-    ASSERT_TRUE(result.IsSuccess());
-    ASSERT_EQ(result.AcquireSuccess(), &dummySuccess);
-}
+        ResultOrError<int*> result = ReturnSuccess();
+        ASSERT_TRUE(result.IsSuccess());
+        ASSERT_EQ(result.AcquireSuccess(), &dummySuccess);
+    }
 
-// Check returning an error ResultOrError with "return DAWN_VALIDATION_ERROR"
-TEST(ErrorTests, ResultOrError_Error) {
-    auto ReturnError = []() -> ResultOrError<int*> {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check returning an error ResultOrError with "return DAWN_VALIDATION_ERROR"
+    TEST(ErrorTests, ResultOrError_Error) {
+        auto ReturnError = []() -> ResultOrError<int*> {
+            return DAWN_VALIDATION_ERROR(dummyErrorMessage);
+        };
 
-    ResultOrError<int*> result = ReturnError();
-    ASSERT_TRUE(result.IsError());
+        ResultOrError<int*> result = ReturnError();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
-// Check DAWN_TRY handles successes correctly.
-TEST(ErrorTests, TRY_Success) {
-    auto ReturnSuccess = []() -> MaybeError {
-        return {};
-    };
+    // Check DAWN_TRY handles successes correctly.
+    TEST(ErrorTests, TRY_Success) {
+        auto ReturnSuccess = []() -> MaybeError { return {}; };
 
-    // We need to check that DAWN_TRY doesn't return on successes
-    bool tryReturned = true;
+        // We need to check that DAWN_TRY doesn't return on successes
+        bool tryReturned = true;
 
-    auto Try = [ReturnSuccess, &tryReturned]() -> MaybeError {
-        DAWN_TRY(ReturnSuccess());
-        tryReturned = false;
-        return {};
-    };
+        auto Try = [ReturnSuccess, &tryReturned]() -> MaybeError {
+            DAWN_TRY(ReturnSuccess());
+            tryReturned = false;
+            return {};
+        };
 
-    MaybeError result = Try();
-    ASSERT_TRUE(result.IsSuccess());
-    ASSERT_FALSE(tryReturned);
-}
+        MaybeError result = Try();
+        ASSERT_TRUE(result.IsSuccess());
+        ASSERT_FALSE(tryReturned);
+    }
 
-// Check DAWN_TRY handles errors correctly.
-TEST(ErrorTests, TRY_Error) {
-    auto ReturnError = []() -> MaybeError {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check DAWN_TRY handles errors correctly.
+    TEST(ErrorTests, TRY_Error) {
+        auto ReturnError = []() -> MaybeError { return DAWN_VALIDATION_ERROR(dummyErrorMessage); };
 
-    auto Try = [ReturnError]() -> MaybeError {
-        DAWN_TRY(ReturnError());
-        // DAWN_TRY should return before this point
-        EXPECT_FALSE(true);
-        return {};
-    };
+        auto Try = [ReturnError]() -> MaybeError {
+            DAWN_TRY(ReturnError());
+            // DAWN_TRY should return before this point
+            EXPECT_FALSE(true);
+            return {};
+        };
 
-    MaybeError result = Try();
-    ASSERT_TRUE(result.IsError());
+        MaybeError result = Try();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
-// Check DAWN_TRY adds to the backtrace.
-TEST(ErrorTests, TRY_AddsToBacktrace) {
-    auto ReturnError = []() -> MaybeError {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check DAWN_TRY adds to the backtrace.
+    TEST(ErrorTests, TRY_AddsToBacktrace) {
+        auto ReturnError = []() -> MaybeError { return DAWN_VALIDATION_ERROR(dummyErrorMessage); };
 
-    auto SingleTry = [ReturnError]() -> MaybeError {
-        DAWN_TRY(ReturnError());
-        return {};
-    };
+        auto SingleTry = [ReturnError]() -> MaybeError {
+            DAWN_TRY(ReturnError());
+            return {};
+        };
 
-    auto DoubleTry = [SingleTry]() -> MaybeError {
-        DAWN_TRY(SingleTry());
-        return {};
-    };
+        auto DoubleTry = [SingleTry]() -> MaybeError {
+            DAWN_TRY(SingleTry());
+            return {};
+        };
 
-    MaybeError singleResult = SingleTry();
-    ASSERT_TRUE(singleResult.IsError());
+        MaybeError singleResult = SingleTry();
+        ASSERT_TRUE(singleResult.IsError());
 
-    MaybeError doubleResult = DoubleTry();
-    ASSERT_TRUE(doubleResult.IsError());
+        MaybeError doubleResult = DoubleTry();
+        ASSERT_TRUE(doubleResult.IsError());
 
-    std::unique_ptr<ErrorData> singleData = singleResult.AcquireError();
-    std::unique_ptr<ErrorData> doubleData = doubleResult.AcquireError();
+        std::unique_ptr<ErrorData> singleData = singleResult.AcquireError();
+        std::unique_ptr<ErrorData> doubleData = doubleResult.AcquireError();
 
-    ASSERT_EQ(singleData->GetBacktrace().size() + 1, doubleData->GetBacktrace().size());
-}
+        ASSERT_EQ(singleData->GetBacktrace().size() + 1, doubleData->GetBacktrace().size());
+    }
 
-// Check DAWN_TRY_ASSIGN handles successes correctly.
-TEST(ErrorTests, TRY_RESULT_Success) {
-    auto ReturnSuccess = []() -> ResultOrError<int*> {
-        return &dummySuccess;
-    };
+    // Check DAWN_TRY_ASSIGN handles successes correctly.
+    TEST(ErrorTests, TRY_RESULT_Success) {
+        auto ReturnSuccess = []() -> ResultOrError<int*> { return &dummySuccess; };
 
-    // We need to check that DAWN_TRY doesn't return on successes
-    bool tryReturned = true;
+        // We need to check that DAWN_TRY doesn't return on successes
+        bool tryReturned = true;
 
-    auto Try = [ReturnSuccess, &tryReturned]() -> ResultOrError<int*> {
-        int* result = nullptr;
-        DAWN_TRY_ASSIGN(result, ReturnSuccess());
-        tryReturned = false;
+        auto Try = [ReturnSuccess, &tryReturned]() -> ResultOrError<int*> {
+            int* result = nullptr;
+            DAWN_TRY_ASSIGN(result, ReturnSuccess());
+            tryReturned = false;
 
-        EXPECT_EQ(result, &dummySuccess);
-        return result;
-    };
+            EXPECT_EQ(result, &dummySuccess);
+            return result;
+        };
 
-    ResultOrError<int*> result = Try();
-    ASSERT_TRUE(result.IsSuccess());
-    ASSERT_FALSE(tryReturned);
-    ASSERT_EQ(result.AcquireSuccess(), &dummySuccess);
-}
+        ResultOrError<int*> result = Try();
+        ASSERT_TRUE(result.IsSuccess());
+        ASSERT_FALSE(tryReturned);
+        ASSERT_EQ(result.AcquireSuccess(), &dummySuccess);
+    }
 
-// Check DAWN_TRY_ASSIGN handles errors correctly.
-TEST(ErrorTests, TRY_RESULT_Error) {
-    auto ReturnError = []() -> ResultOrError<int*> {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check DAWN_TRY_ASSIGN handles errors correctly.
+    TEST(ErrorTests, TRY_RESULT_Error) {
+        auto ReturnError = []() -> ResultOrError<int*> {
+            return DAWN_VALIDATION_ERROR(dummyErrorMessage);
+        };
 
-    auto Try = [ReturnError]() -> ResultOrError<int*> {
-        int* result = nullptr;
-        DAWN_TRY_ASSIGN(result, ReturnError());
-        DAWN_UNUSED(result);
+        auto Try = [ReturnError]() -> ResultOrError<int*> {
+            int* result = nullptr;
+            DAWN_TRY_ASSIGN(result, ReturnError());
+            DAWN_UNUSED(result);
 
-        // DAWN_TRY should return before this point
-        EXPECT_FALSE(true);
-        return &dummySuccess;
-    };
+            // DAWN_TRY should return before this point
+            EXPECT_FALSE(true);
+            return &dummySuccess;
+        };
 
-    ResultOrError<int*> result = Try();
-    ASSERT_TRUE(result.IsError());
+        ResultOrError<int*> result = Try();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
-// Check DAWN_TRY_ASSIGN adds to the backtrace.
-TEST(ErrorTests, TRY_RESULT_AddsToBacktrace) {
-    auto ReturnError = []() -> ResultOrError<int*> {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check DAWN_TRY_ASSIGN adds to the backtrace.
+    TEST(ErrorTests, TRY_RESULT_AddsToBacktrace) {
+        auto ReturnError = []() -> ResultOrError<int*> {
+            return DAWN_VALIDATION_ERROR(dummyErrorMessage);
+        };
 
-    auto SingleTry = [ReturnError]() -> ResultOrError<int*> {
-        DAWN_TRY(ReturnError());
-        return &dummySuccess;
-    };
+        auto SingleTry = [ReturnError]() -> ResultOrError<int*> {
+            DAWN_TRY(ReturnError());
+            return &dummySuccess;
+        };
 
-    auto DoubleTry = [SingleTry]() -> ResultOrError<int*> {
-        DAWN_TRY(SingleTry());
-        return &dummySuccess;
-    };
+        auto DoubleTry = [SingleTry]() -> ResultOrError<int*> {
+            DAWN_TRY(SingleTry());
+            return &dummySuccess;
+        };
 
-    ResultOrError<int*> singleResult = SingleTry();
-    ASSERT_TRUE(singleResult.IsError());
+        ResultOrError<int*> singleResult = SingleTry();
+        ASSERT_TRUE(singleResult.IsError());
 
-    ResultOrError<int*> doubleResult = DoubleTry();
-    ASSERT_TRUE(doubleResult.IsError());
+        ResultOrError<int*> doubleResult = DoubleTry();
+        ASSERT_TRUE(doubleResult.IsError());
 
-    std::unique_ptr<ErrorData> singleData = singleResult.AcquireError();
-    std::unique_ptr<ErrorData> doubleData = doubleResult.AcquireError();
+        std::unique_ptr<ErrorData> singleData = singleResult.AcquireError();
+        std::unique_ptr<ErrorData> doubleData = doubleResult.AcquireError();
 
-    ASSERT_EQ(singleData->GetBacktrace().size() + 1, doubleData->GetBacktrace().size());
-}
+        ASSERT_EQ(singleData->GetBacktrace().size() + 1, doubleData->GetBacktrace().size());
+    }
 
-// Check a ResultOrError can be DAWN_TRY_ASSIGNED in a function that returns an Error
-TEST(ErrorTests, TRY_RESULT_ConversionToError) {
-    auto ReturnError = []() -> ResultOrError<int*> {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check a ResultOrError can be DAWN_TRY_ASSIGNED in a function that returns an Error
+    TEST(ErrorTests, TRY_RESULT_ConversionToError) {
+        auto ReturnError = []() -> ResultOrError<int*> {
+            return DAWN_VALIDATION_ERROR(dummyErrorMessage);
+        };
 
-    auto Try = [ReturnError]() -> MaybeError {
-        int* result = nullptr;
-        DAWN_TRY_ASSIGN(result, ReturnError());
-        DAWN_UNUSED(result);
+        auto Try = [ReturnError]() -> MaybeError {
+            int* result = nullptr;
+            DAWN_TRY_ASSIGN(result, ReturnError());
+            DAWN_UNUSED(result);
 
-        return {};
-    };
+            return {};
+        };
 
-    MaybeError result = Try();
-    ASSERT_TRUE(result.IsError());
+        MaybeError result = Try();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
-// Check a ResultOrError can be DAWN_TRY_ASSIGNED in a function that returns an Error
-// Version without Result<E*, T*>
-TEST(ErrorTests, TRY_RESULT_ConversionToErrorNonPointer) {
-    auto ReturnError = []() -> ResultOrError<int> {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check a ResultOrError can be DAWN_TRY_ASSIGNED in a function that returns an Error
+    // Version without Result<E*, T*>
+    TEST(ErrorTests, TRY_RESULT_ConversionToErrorNonPointer) {
+        auto ReturnError = []() -> ResultOrError<int> {
+            return DAWN_VALIDATION_ERROR(dummyErrorMessage);
+        };
 
-    auto Try = [ReturnError]() -> MaybeError {
-        int result = 0;
-        DAWN_TRY_ASSIGN(result, ReturnError());
-        DAWN_UNUSED(result);
+        auto Try = [ReturnError]() -> MaybeError {
+            int result = 0;
+            DAWN_TRY_ASSIGN(result, ReturnError());
+            DAWN_UNUSED(result);
 
-        return {};
-    };
+            return {};
+        };
 
-    MaybeError result = Try();
-    ASSERT_TRUE(result.IsError());
+        MaybeError result = Try();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
-// Check a MaybeError can be DAWN_TRIED in a function that returns an ResultOrError
-// Check DAWN_TRY handles errors correctly.
-TEST(ErrorTests, TRY_ConversionToErrorOrResult) {
-    auto ReturnError = []() -> MaybeError {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check a MaybeError can be DAWN_TRIED in a function that returns an ResultOrError
+    // Check DAWN_TRY handles errors correctly.
+    TEST(ErrorTests, TRY_ConversionToErrorOrResult) {
+        auto ReturnError = []() -> MaybeError { return DAWN_VALIDATION_ERROR(dummyErrorMessage); };
 
-    auto Try = [ReturnError]() -> ResultOrError<int*>{
-        DAWN_TRY(ReturnError());
-        return &dummySuccess;
-    };
+        auto Try = [ReturnError]() -> ResultOrError<int*> {
+            DAWN_TRY(ReturnError());
+            return &dummySuccess;
+        };
 
-    ResultOrError<int*> result = Try();
-    ASSERT_TRUE(result.IsError());
+        ResultOrError<int*> result = Try();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
-// Check a MaybeError can be DAWN_TRIED in a function that returns an ResultOrError
-// Check DAWN_TRY handles errors correctly. Version without Result<E*, T*>
-TEST(ErrorTests, TRY_ConversionToErrorOrResultNonPointer) {
-    auto ReturnError = []() -> MaybeError {
-        return DAWN_VALIDATION_ERROR(dummyErrorMessage);
-    };
+    // Check a MaybeError can be DAWN_TRIED in a function that returns an ResultOrError
+    // Check DAWN_TRY handles errors correctly. Version without Result<E*, T*>
+    TEST(ErrorTests, TRY_ConversionToErrorOrResultNonPointer) {
+        auto ReturnError = []() -> MaybeError { return DAWN_VALIDATION_ERROR(dummyErrorMessage); };
 
-    auto Try = [ReturnError]() -> ResultOrError<int>{
-        DAWN_TRY(ReturnError());
-        return 42;
-    };
+        auto Try = [ReturnError]() -> ResultOrError<int> {
+            DAWN_TRY(ReturnError());
+            return 42;
+        };
 
-    ResultOrError<int> result = Try();
-    ASSERT_TRUE(result.IsError());
+        ResultOrError<int> result = Try();
+        ASSERT_TRUE(result.IsError());
 
-    std::unique_ptr<ErrorData> errorData = result.AcquireError();
-    ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
-}
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+    }
 
 }  // anonymous namespace
diff --git a/src/tests/unittests/LinkedListTests.cpp b/src/tests/unittests/LinkedListTests.cpp
index 94f2ecd..7dcb37f 100644
--- a/src/tests/unittests/LinkedListTests.cpp
+++ b/src/tests/unittests/LinkedListTests.cpp
@@ -362,4 +362,4 @@
     EXPECT_TRUE(n.IsInList());
     n.RemoveFromList();
     EXPECT_FALSE(n.IsInList());
-}
\ No newline at end of file
+}
diff --git a/src/tests/unittests/ObjectBaseTests.cpp b/src/tests/unittests/ObjectBaseTests.cpp
index 6c3f2d7..ab141d3 100644
--- a/src/tests/unittests/ObjectBaseTests.cpp
+++ b/src/tests/unittests/ObjectBaseTests.cpp
@@ -194,4 +194,3 @@
     obj = nullptr;
     ASSERT_EQ(refcount, 1);
 }
-
diff --git a/src/tests/unittests/PerStageTests.cpp b/src/tests/unittests/PerStageTests.cpp
index a8c4cf4..dcecd83 100644
--- a/src/tests/unittests/PerStageTests.cpp
+++ b/src/tests/unittests/PerStageTests.cpp
@@ -48,7 +48,7 @@
     counts[SingleShaderStage::Compute] = 0;
 
     for (auto stage : IterateStages(kAllStages)) {
-        counts[stage] ++;
+        counts[stage]++;
     }
 
     ASSERT_EQ(counts[wgpu::ShaderStage::Vertex], 1);
@@ -64,7 +64,7 @@
     counts[SingleShaderStage::Compute] = 0;
 
     for (auto stage : IterateStages(wgpu::ShaderStage::Fragment)) {
-        counts[stage] ++;
+        counts[stage]++;
     }
 
     ASSERT_EQ(counts[wgpu::ShaderStage::Vertex], 0);
@@ -80,7 +80,7 @@
     counts[SingleShaderStage::Compute] = 0;
 
     for (auto stage : IterateStages(wgpu::ShaderStage::Fragment & wgpu::ShaderStage::Vertex)) {
-        counts[stage] ++;
+        counts[stage]++;
     }
 
     ASSERT_EQ(counts[wgpu::ShaderStage::Vertex], 0);
diff --git a/src/tests/unittests/RefCountedTests.cpp b/src/tests/unittests/RefCountedTests.cpp
index 5981dc9..7e5c959 100644
--- a/src/tests/unittests/RefCountedTests.cpp
+++ b/src/tests/unittests/RefCountedTests.cpp
@@ -410,4 +410,4 @@
 
     destination = nullptr;
     EXPECT_TRUE(deleted);
-}
\ No newline at end of file
+}
diff --git a/src/tests/unittests/ResultTests.cpp b/src/tests/unittests/ResultTests.cpp
index 7b21d2e..bd48217 100644
--- a/src/tests/unittests/ResultTests.cpp
+++ b/src/tests/unittests/ResultTests.cpp
@@ -19,363 +19,367 @@
 
 namespace {
 
-template<typename T, typename E>
-void TestError(Result<T, E>* result, E expectedError) {
-    EXPECT_TRUE(result->IsError());
-    EXPECT_FALSE(result->IsSuccess());
+    template <typename T, typename E>
+    void TestError(Result<T, E>* result, E expectedError) {
+        EXPECT_TRUE(result->IsError());
+        EXPECT_FALSE(result->IsSuccess());
 
-    std::unique_ptr<E> storedError = result->AcquireError();
-    EXPECT_EQ(*storedError, expectedError);
-}
-
-template<typename T, typename E>
-void TestSuccess(Result<T, E>* result, T expectedSuccess) {
-    EXPECT_FALSE(result->IsError());
-    EXPECT_TRUE(result->IsSuccess());
-
-    const T storedSuccess = result->AcquireSuccess();
-    EXPECT_EQ(storedSuccess, expectedSuccess);
-
-    // Once the success is acquired, result has an empty
-    // payload and is neither in the success nor error state.
-    EXPECT_FALSE(result->IsError());
-    EXPECT_FALSE(result->IsSuccess());
-}
-
-static int dummyError = 0xbeef;
-static float dummySuccess = 42.0f;
-static const float dummyConstSuccess = 42.0f;
-
-class AClass : public RefCounted {
-  public:
-    int a = 0;
-};
-
-// Tests using the following overload of TestSuccess make
-// local Ref instances to dummySuccessObj. Tests should
-// ensure any local Ref objects made along the way continue
-// to point to dummySuccessObj.
-template <typename T, typename E>
-void TestSuccess(Result<Ref<T>, E>* result, T* expectedSuccess) {
-    EXPECT_FALSE(result->IsError());
-    EXPECT_TRUE(result->IsSuccess());
-
-    // AClass starts with a reference count of 1 and stored
-    // on the stack in the caller. The result parameter should
-    // hold the only other reference to the object.
-    EXPECT_EQ(expectedSuccess->GetRefCountForTesting(), 2u);
-
-    const Ref<T> storedSuccess = result->AcquireSuccess();
-    EXPECT_EQ(storedSuccess.Get(), expectedSuccess);
-
-    // Once the success is acquired, result has an empty
-    // payload and is neither in the success nor error state.
-    EXPECT_FALSE(result->IsError());
-    EXPECT_FALSE(result->IsSuccess());
-
-    // Once we call AcquireSuccess, result no longer stores
-    // the object. storedSuccess should contain the only other
-    // reference to the object.
-    EXPECT_EQ(storedSuccess->GetRefCountForTesting(), 2u);
-}
-
-// Result<void, E*>
-
-// Test constructing an error Result<void, E>
-TEST(ResultOnlyPointerError, ConstructingError) {
-    Result<void, int> result(std::make_unique<int>(dummyError));
-    TestError(&result, dummyError);
-}
-
-// Test moving an error Result<void, E>
-TEST(ResultOnlyPointerError, MovingError) {
-    Result<void, int> result(std::make_unique<int>(dummyError));
-    Result<void, int> movedResult(std::move(result));
-    TestError(&movedResult, dummyError);
-}
-
-// Test returning an error Result<void, E>
-TEST(ResultOnlyPointerError, ReturningError) {
-    auto CreateError = []() -> Result<void, int> { return {std::make_unique<int>(dummyError)}; };
-
-    Result<void, int> result = CreateError();
-    TestError(&result, dummyError);
-}
-
-// Test constructing a success Result<void, E>
-TEST(ResultOnlyPointerError, ConstructingSuccess) {
-    Result<void, int> result;
-    EXPECT_TRUE(result.IsSuccess());
-    EXPECT_FALSE(result.IsError());
-}
-
-// Test moving a success Result<void, E>
-TEST(ResultOnlyPointerError, MovingSuccess) {
-    Result<void, int> result;
-    Result<void, int> movedResult(std::move(result));
-    EXPECT_TRUE(movedResult.IsSuccess());
-    EXPECT_FALSE(movedResult.IsError());
-}
-
-// Test returning a success Result<void, E>
-TEST(ResultOnlyPointerError, ReturningSuccess) {
-    auto CreateError = []() -> Result<void, int> { return {}; };
-
-    Result<void, int> result = CreateError();
-    EXPECT_TRUE(result.IsSuccess());
-    EXPECT_FALSE(result.IsError());
-}
-
-// Result<T*, E*>
-
-// Test constructing an error Result<T*, E>
-TEST(ResultBothPointer, ConstructingError) {
-    Result<float*, int> result(std::make_unique<int>(dummyError));
-    TestError(&result, dummyError);
-}
-
-// Test moving an error Result<T*, E>
-TEST(ResultBothPointer, MovingError) {
-    Result<float*, int> result(std::make_unique<int>(dummyError));
-    Result<float*, int> movedResult(std::move(result));
-    TestError(&movedResult, dummyError);
-}
-
-// Test returning an error Result<T*, E>
-TEST(ResultBothPointer, ReturningError) {
-    auto CreateError = []() -> Result<float*, int> { return {std::make_unique<int>(dummyError)}; };
-
-    Result<float*, int> result = CreateError();
-    TestError(&result, dummyError);
-}
-
-// Test constructing a success Result<T*, E>
-TEST(ResultBothPointer, ConstructingSuccess) {
-    Result<float*, int> result(&dummySuccess);
-    TestSuccess(&result, &dummySuccess);
-}
-
-// Test moving a success Result<T*, E>
-TEST(ResultBothPointer, MovingSuccess) {
-    Result<float*, int> result(&dummySuccess);
-    Result<float*, int> movedResult(std::move(result));
-    TestSuccess(&movedResult, &dummySuccess);
-}
-
-// Test returning a success Result<T*, E>
-TEST(ResultBothPointer, ReturningSuccess) {
-    auto CreateSuccess = []() -> Result<float*, int*> {
-        return {&dummySuccess};
-    };
-
-    Result<float*, int*> result = CreateSuccess();
-    TestSuccess(&result, &dummySuccess);
-}
-
-// Tests converting from a Result<TChild*, E>
-TEST(ResultBothPointer, ConversionFromChildClass) {
-    struct T {
-        int a;
-    };
-    struct TChild : T {};
-
-    TChild child;
-    T* childAsT = &child;
-    {
-        Result<T*, int> result(&child);
-        TestSuccess(&result, childAsT);
+        std::unique_ptr<E> storedError = result->AcquireError();
+        EXPECT_EQ(*storedError, expectedError);
     }
-    {
-        Result<TChild*, int> resultChild(&child);
-        Result<T*, int> result(std::move(resultChild));
-        TestSuccess(&result, childAsT);
+
+    template <typename T, typename E>
+    void TestSuccess(Result<T, E>* result, T expectedSuccess) {
+        EXPECT_FALSE(result->IsError());
+        EXPECT_TRUE(result->IsSuccess());
+
+        const T storedSuccess = result->AcquireSuccess();
+        EXPECT_EQ(storedSuccess, expectedSuccess);
+
+        // Once the success is acquired, result has an empty
+        // payload and is neither in the success nor error state.
+        EXPECT_FALSE(result->IsError());
+        EXPECT_FALSE(result->IsSuccess());
     }
-    {
-        Result<TChild*, int> resultChild(&child);
-        Result<T*, int> result = std::move(resultChild);
-        TestSuccess(&result, childAsT);
+
+    static int dummyError = 0xbeef;
+    static float dummySuccess = 42.0f;
+    static const float dummyConstSuccess = 42.0f;
+
+    class AClass : public RefCounted {
+      public:
+        int a = 0;
+    };
+
+    // Tests using the following overload of TestSuccess make
+    // local Ref instances to dummySuccessObj. Tests should
+    // ensure any local Ref objects made along the way continue
+    // to point to dummySuccessObj.
+    template <typename T, typename E>
+    void TestSuccess(Result<Ref<T>, E>* result, T* expectedSuccess) {
+        EXPECT_FALSE(result->IsError());
+        EXPECT_TRUE(result->IsSuccess());
+
+        // AClass starts with a reference count of 1 and stored
+        // on the stack in the caller. The result parameter should
+        // hold the only other reference to the object.
+        EXPECT_EQ(expectedSuccess->GetRefCountForTesting(), 2u);
+
+        const Ref<T> storedSuccess = result->AcquireSuccess();
+        EXPECT_EQ(storedSuccess.Get(), expectedSuccess);
+
+        // Once the success is acquired, result has an empty
+        // payload and is neither in the success nor error state.
+        EXPECT_FALSE(result->IsError());
+        EXPECT_FALSE(result->IsSuccess());
+
+        // Once we call AcquireSuccess, result no longer stores
+        // the object. storedSuccess should contain the only other
+        // reference to the object.
+        EXPECT_EQ(storedSuccess->GetRefCountForTesting(), 2u);
     }
-}
 
-// Result<const T*, E>
+    // Result<void, E*>
 
-// Test constructing an error Result<const T*, E>
-TEST(ResultBothPointerWithConstResult, ConstructingError) {
-    Result<const float*, int> result(std::make_unique<int>(dummyError));
-    TestError(&result, dummyError);
-}
+    // Test constructing an error Result<void, E>
+    TEST(ResultOnlyPointerError, ConstructingError) {
+        Result<void, int> result(std::make_unique<int>(dummyError));
+        TestError(&result, dummyError);
+    }
 
-// Test moving an error Result<const T*, E>
-TEST(ResultBothPointerWithConstResult, MovingError) {
-    Result<const float*, int> result(std::make_unique<int>(dummyError));
-    Result<const float*, int> movedResult(std::move(result));
-    TestError(&movedResult, dummyError);
-}
+    // Test moving an error Result<void, E>
+    TEST(ResultOnlyPointerError, MovingError) {
+        Result<void, int> result(std::make_unique<int>(dummyError));
+        Result<void, int> movedResult(std::move(result));
+        TestError(&movedResult, dummyError);
+    }
 
-// Test returning an error Result<const T*, E*>
-TEST(ResultBothPointerWithConstResult, ReturningError) {
-    auto CreateError = []() -> Result<const float*, int> {
-        return {std::make_unique<int>(dummyError)};
+    // Test returning an error Result<void, E>
+    TEST(ResultOnlyPointerError, ReturningError) {
+        auto CreateError = []() -> Result<void, int> {
+            return {std::make_unique<int>(dummyError)};
+        };
+
+        Result<void, int> result = CreateError();
+        TestError(&result, dummyError);
+    }
+
+    // Test constructing a success Result<void, E>
+    TEST(ResultOnlyPointerError, ConstructingSuccess) {
+        Result<void, int> result;
+        EXPECT_TRUE(result.IsSuccess());
+        EXPECT_FALSE(result.IsError());
+    }
+
+    // Test moving a success Result<void, E>
+    TEST(ResultOnlyPointerError, MovingSuccess) {
+        Result<void, int> result;
+        Result<void, int> movedResult(std::move(result));
+        EXPECT_TRUE(movedResult.IsSuccess());
+        EXPECT_FALSE(movedResult.IsError());
+    }
+
+    // Test returning a success Result<void, E>
+    TEST(ResultOnlyPointerError, ReturningSuccess) {
+        auto CreateError = []() -> Result<void, int> { return {}; };
+
+        Result<void, int> result = CreateError();
+        EXPECT_TRUE(result.IsSuccess());
+        EXPECT_FALSE(result.IsError());
+    }
+
+    // Result<T*, E*>
+
+    // Test constructing an error Result<T*, E>
+    TEST(ResultBothPointer, ConstructingError) {
+        Result<float*, int> result(std::make_unique<int>(dummyError));
+        TestError(&result, dummyError);
+    }
+
+    // Test moving an error Result<T*, E>
+    TEST(ResultBothPointer, MovingError) {
+        Result<float*, int> result(std::make_unique<int>(dummyError));
+        Result<float*, int> movedResult(std::move(result));
+        TestError(&movedResult, dummyError);
+    }
+
+    // Test returning an error Result<T*, E>
+    TEST(ResultBothPointer, ReturningError) {
+        auto CreateError = []() -> Result<float*, int> {
+            return {std::make_unique<int>(dummyError)};
+        };
+
+        Result<float*, int> result = CreateError();
+        TestError(&result, dummyError);
+    }
+
+    // Test constructing a success Result<T*, E>
+    TEST(ResultBothPointer, ConstructingSuccess) {
+        Result<float*, int> result(&dummySuccess);
+        TestSuccess(&result, &dummySuccess);
+    }
+
+    // Test moving a success Result<T*, E>
+    TEST(ResultBothPointer, MovingSuccess) {
+        Result<float*, int> result(&dummySuccess);
+        Result<float*, int> movedResult(std::move(result));
+        TestSuccess(&movedResult, &dummySuccess);
+    }
+
+    // Test returning a success Result<T*, E>
+    TEST(ResultBothPointer, ReturningSuccess) {
+        auto CreateSuccess = []() -> Result<float*, int*> { return {&dummySuccess}; };
+
+        Result<float*, int*> result = CreateSuccess();
+        TestSuccess(&result, &dummySuccess);
+    }
+
+    // Tests converting from a Result<TChild*, E>
+    TEST(ResultBothPointer, ConversionFromChildClass) {
+        struct T {
+            int a;
+        };
+        struct TChild : T {};
+
+        TChild child;
+        T* childAsT = &child;
+        {
+            Result<T*, int> result(&child);
+            TestSuccess(&result, childAsT);
+        }
+        {
+            Result<TChild*, int> resultChild(&child);
+            Result<T*, int> result(std::move(resultChild));
+            TestSuccess(&result, childAsT);
+        }
+        {
+            Result<TChild*, int> resultChild(&child);
+            Result<T*, int> result = std::move(resultChild);
+            TestSuccess(&result, childAsT);
+        }
+    }
+
+    // Result<const T*, E>
+
+    // Test constructing an error Result<const T*, E>
+    TEST(ResultBothPointerWithConstResult, ConstructingError) {
+        Result<const float*, int> result(std::make_unique<int>(dummyError));
+        TestError(&result, dummyError);
+    }
+
+    // Test moving an error Result<const T*, E>
+    TEST(ResultBothPointerWithConstResult, MovingError) {
+        Result<const float*, int> result(std::make_unique<int>(dummyError));
+        Result<const float*, int> movedResult(std::move(result));
+        TestError(&movedResult, dummyError);
+    }
+
+    // Test returning an error Result<const T*, E*>
+    TEST(ResultBothPointerWithConstResult, ReturningError) {
+        auto CreateError = []() -> Result<const float*, int> {
+            return {std::make_unique<int>(dummyError)};
+        };
+
+        Result<const float*, int> result = CreateError();
+        TestError(&result, dummyError);
+    }
+
+    // Test constructing a success Result<const T*, E*>
+    TEST(ResultBothPointerWithConstResult, ConstructingSuccess) {
+        Result<const float*, int> result(&dummyConstSuccess);
+        TestSuccess(&result, &dummyConstSuccess);
+    }
+
+    // Test moving a success Result<const T*, E*>
+    TEST(ResultBothPointerWithConstResult, MovingSuccess) {
+        Result<const float*, int> result(&dummyConstSuccess);
+        Result<const float*, int> movedResult(std::move(result));
+        TestSuccess(&movedResult, &dummyConstSuccess);
+    }
+
+    // Test returning a success Result<const T*, E*>
+    TEST(ResultBothPointerWithConstResult, ReturningSuccess) {
+        auto CreateSuccess = []() -> Result<const float*, int> { return {&dummyConstSuccess}; };
+
+        Result<const float*, int> result = CreateSuccess();
+        TestSuccess(&result, &dummyConstSuccess);
+    }
+
+    // Result<Ref<T>, E>
+
+    // Test constructing an error Result<Ref<T>, E>
+    TEST(ResultRefT, ConstructingError) {
+        Result<Ref<AClass>, int> result(std::make_unique<int>(dummyError));
+        TestError(&result, dummyError);
+    }
+
+    // Test moving an error Result<Ref<T>, E>
+    TEST(ResultRefT, MovingError) {
+        Result<Ref<AClass>, int> result(std::make_unique<int>(dummyError));
+        Result<Ref<AClass>, int> movedResult(std::move(result));
+        TestError(&movedResult, dummyError);
+    }
+
+    // Test returning an error Result<Ref<T>, E>
+    TEST(ResultRefT, ReturningError) {
+        auto CreateError = []() -> Result<Ref<AClass>, int> {
+            return {std::make_unique<int>(dummyError)};
+        };
+
+        Result<Ref<AClass>, int> result = CreateError();
+        TestError(&result, dummyError);
+    }
+
+    // Test constructing a success Result<Ref<T>, E>
+    TEST(ResultRefT, ConstructingSuccess) {
+        AClass success;
+
+        Ref<AClass> refObj(&success);
+        Result<Ref<AClass>, int> result(std::move(refObj));
+        TestSuccess(&result, &success);
+    }
+
+    // Test moving a success Result<Ref<T>, E>
+    TEST(ResultRefT, MovingSuccess) {
+        AClass success;
+
+        Ref<AClass> refObj(&success);
+        Result<Ref<AClass>, int> result(std::move(refObj));
+        Result<Ref<AClass>, int> movedResult(std::move(result));
+        TestSuccess(&movedResult, &success);
+    }
+
+    // Test returning a success Result<Ref<T>, E>
+    TEST(ResultRefT, ReturningSuccess) {
+        AClass success;
+        auto CreateSuccess = [&success]() -> Result<Ref<AClass>, int> {
+            return Ref<AClass>(&success);
+        };
+
+        Result<Ref<AClass>, int> result = CreateSuccess();
+        TestSuccess(&result, &success);
+    }
+
+    class OtherClass {
+      public:
+        int a = 0;
     };
+    class Base : public RefCounted {};
+    class Child : public OtherClass, public Base {};
 
-    Result<const float*, int> result = CreateError();
-    TestError(&result, dummyError);
-}
+    // Test constructing a Result<Ref<TChild>, E>
+    TEST(ResultRefT, ConversionFromChildConstructor) {
+        Child child;
+        Ref<Child> refChild(&child);
 
-// Test constructing a success Result<const T*, E*>
-TEST(ResultBothPointerWithConstResult, ConstructingSuccess) {
-    Result<const float*, int> result(&dummyConstSuccess);
-    TestSuccess(&result, &dummyConstSuccess);
-}
+        Result<Ref<Base>, int> result(std::move(refChild));
+        TestSuccess<Base>(&result, &child);
+    }
 
-// Test moving a success Result<const T*, E*>
-TEST(ResultBothPointerWithConstResult, MovingSuccess) {
-    Result<const float*, int> result(&dummyConstSuccess);
-    Result<const float*, int> movedResult(std::move(result));
-    TestSuccess(&movedResult, &dummyConstSuccess);
-}
+    // Test copy constructing Result<Ref<TChild>, E>
+    TEST(ResultRefT, ConversionFromChildCopyConstructor) {
+        Child child;
+        Ref<Child> refChild(&child);
 
-// Test returning a success Result<const T*, E*>
-TEST(ResultBothPointerWithConstResult, ReturningSuccess) {
-    auto CreateSuccess = []() -> Result<const float*, int> { return {&dummyConstSuccess}; };
+        Result<Ref<Child>, int> resultChild(std::move(refChild));
+        Result<Ref<Base>, int> result(std::move(resultChild));
+        TestSuccess<Base>(&result, &child);
+    }
 
-    Result<const float*, int> result = CreateSuccess();
-    TestSuccess(&result, &dummyConstSuccess);
-}
+    // Test assignment operator for Result<Ref<TChild>, E>
+    TEST(ResultRefT, ConversionFromChildAssignmentOperator) {
+        Child child;
+        Ref<Child> refChild(&child);
 
-// Result<Ref<T>, E>
+        Result<Ref<Child>, int> resultChild(std::move(refChild));
+        Result<Ref<Base>, int> result = std::move(resultChild);
+        TestSuccess<Base>(&result, &child);
+    }
 
-// Test constructing an error Result<Ref<T>, E>
-TEST(ResultRefT, ConstructingError) {
-    Result<Ref<AClass>, int> result(std::make_unique<int>(dummyError));
-    TestError(&result, dummyError);
-}
+    // Result<T, E>
 
-// Test moving an error Result<Ref<T>, E>
-TEST(ResultRefT, MovingError) {
-    Result<Ref<AClass>, int> result(std::make_unique<int>(dummyError));
-    Result<Ref<AClass>, int> movedResult(std::move(result));
-    TestError(&movedResult, dummyError);
-}
+    // Test constructing an error Result<T, E>
+    TEST(ResultGeneric, ConstructingError) {
+        Result<std::vector<float>, int> result(std::make_unique<int>(dummyError));
+        TestError(&result, dummyError);
+    }
 
-// Test returning an error Result<Ref<T>, E>
-TEST(ResultRefT, ReturningError) {
-    auto CreateError = []() -> Result<Ref<AClass>, int> {
-        return {std::make_unique<int>(dummyError)};
-    };
+    // Test moving an error Result<T, E>
+    TEST(ResultGeneric, MovingError) {
+        Result<std::vector<float>, int> result(std::make_unique<int>(dummyError));
+        Result<std::vector<float>, int> movedResult(std::move(result));
+        TestError(&movedResult, dummyError);
+    }
 
-    Result<Ref<AClass>, int> result = CreateError();
-    TestError(&result, dummyError);
-}
+    // Test returning an error Result<T, E>
+    TEST(ResultGeneric, ReturningError) {
+        auto CreateError = []() -> Result<std::vector<float>, int> {
+            return {std::make_unique<int>(dummyError)};
+        };
 
-// Test constructing a success Result<Ref<T>, E>
-TEST(ResultRefT, ConstructingSuccess) {
-    AClass success;
+        Result<std::vector<float>, int> result = CreateError();
+        TestError(&result, dummyError);
+    }
 
-    Ref<AClass> refObj(&success);
-    Result<Ref<AClass>, int> result(std::move(refObj));
-    TestSuccess(&result, &success);
-}
+    // Test constructing a success Result<T, E>
+    TEST(ResultGeneric, ConstructingSuccess) {
+        Result<std::vector<float>, int> result({1.0f});
+        TestSuccess(&result, {1.0f});
+    }
 
-// Test moving a success Result<Ref<T>, E>
-TEST(ResultRefT, MovingSuccess) {
-    AClass success;
+    // Test moving a success Result<T, E>
+    TEST(ResultGeneric, MovingSuccess) {
+        Result<std::vector<float>, int> result({1.0f});
+        Result<std::vector<float>, int> movedResult(std::move(result));
+        TestSuccess(&movedResult, {1.0f});
+    }
 
-    Ref<AClass> refObj(&success);
-    Result<Ref<AClass>, int> result(std::move(refObj));
-    Result<Ref<AClass>, int> movedResult(std::move(result));
-    TestSuccess(&movedResult, &success);
-}
+    // Test returning a success Result<T, E>
+    TEST(ResultGeneric, ReturningSuccess) {
+        auto CreateSuccess = []() -> Result<std::vector<float>, int> { return {{1.0f}}; };
 
-// Test returning a success Result<Ref<T>, E>
-TEST(ResultRefT, ReturningSuccess) {
-    AClass success;
-    auto CreateSuccess = [&success]() -> Result<Ref<AClass>, int> { return Ref<AClass>(&success); };
-
-    Result<Ref<AClass>, int> result = CreateSuccess();
-    TestSuccess(&result, &success);
-}
-
-class OtherClass {
-  public:
-    int a = 0;
-};
-class Base : public RefCounted {};
-class Child : public OtherClass, public Base {};
-
-// Test constructing a Result<Ref<TChild>, E>
-TEST(ResultRefT, ConversionFromChildConstructor) {
-    Child child;
-    Ref<Child> refChild(&child);
-
-    Result<Ref<Base>, int> result(std::move(refChild));
-    TestSuccess<Base>(&result, &child);
-}
-
-// Test copy constructing Result<Ref<TChild>, E>
-TEST(ResultRefT, ConversionFromChildCopyConstructor) {
-    Child child;
-    Ref<Child> refChild(&child);
-
-    Result<Ref<Child>, int> resultChild(std::move(refChild));
-    Result<Ref<Base>, int> result(std::move(resultChild));
-    TestSuccess<Base>(&result, &child);
-}
-
-// Test assignment operator for Result<Ref<TChild>, E>
-TEST(ResultRefT, ConversionFromChildAssignmentOperator) {
-    Child child;
-    Ref<Child> refChild(&child);
-
-    Result<Ref<Child>, int> resultChild(std::move(refChild));
-    Result<Ref<Base>, int> result = std::move(resultChild);
-    TestSuccess<Base>(&result, &child);
-}
-
-// Result<T, E>
-
-// Test constructing an error Result<T, E>
-TEST(ResultGeneric, ConstructingError) {
-    Result<std::vector<float>, int> result(std::make_unique<int>(dummyError));
-    TestError(&result, dummyError);
-}
-
-// Test moving an error Result<T, E>
-TEST(ResultGeneric, MovingError) {
-    Result<std::vector<float>, int> result(std::make_unique<int>(dummyError));
-    Result<std::vector<float>, int> movedResult(std::move(result));
-    TestError(&movedResult, dummyError);
-}
-
-// Test returning an error Result<T, E>
-TEST(ResultGeneric, ReturningError) {
-    auto CreateError = []() -> Result<std::vector<float>, int> {
-        return {std::make_unique<int>(dummyError)};
-    };
-
-    Result<std::vector<float>, int> result = CreateError();
-    TestError(&result, dummyError);
-}
-
-// Test constructing a success Result<T, E>
-TEST(ResultGeneric, ConstructingSuccess) {
-    Result<std::vector<float>, int> result({1.0f});
-    TestSuccess(&result, {1.0f});
-}
-
-// Test moving a success Result<T, E>
-TEST(ResultGeneric, MovingSuccess) {
-    Result<std::vector<float>, int> result({1.0f});
-    Result<std::vector<float>, int> movedResult(std::move(result));
-    TestSuccess(&movedResult, {1.0f});
-}
-
-// Test returning a success Result<T, E>
-TEST(ResultGeneric, ReturningSuccess) {
-    auto CreateSuccess = []() -> Result<std::vector<float>, int> { return {{1.0f}}; };
-
-    Result<std::vector<float>, int> result = CreateSuccess();
-    TestSuccess(&result, {1.0f});
-}
+        Result<std::vector<float>, int> result = CreateSuccess();
+        TestSuccess(&result, {1.0f});
+    }
 
 }  // anonymous namespace
diff --git a/src/tests/unittests/RingBufferAllocatorTests.cpp b/src/tests/unittests/RingBufferAllocatorTests.cpp
index a3e5a62..f0c256b 100644
--- a/src/tests/unittests/RingBufferAllocatorTests.cpp
+++ b/src/tests/unittests/RingBufferAllocatorTests.cpp
@@ -174,4 +174,4 @@
     ASSERT_EQ(allocator.Allocate(1, serial), 0u);
     ASSERT_EQ(allocator.Allocate(std::numeric_limits<uint64_t>::max(), serial + 1),
               RingBufferAllocator::kInvalidOffset);
-}
\ No newline at end of file
+}
diff --git a/src/tests/unittests/SerialQueueTests.cpp b/src/tests/unittests/SerialQueueTests.cpp
index 6f75eb7..2545c51 100644
--- a/src/tests/unittests/SerialQueueTests.cpp
+++ b/src/tests/unittests/SerialQueueTests.cpp
@@ -153,4 +153,4 @@
 
     queue.Enqueue({2}, 1);
     EXPECT_EQ(queue.LastSerial(), 1u);
-}
\ No newline at end of file
+}
diff --git a/src/tests/unittests/ToBackendTests.cpp b/src/tests/unittests/ToBackendTests.cpp
index c537a8e..5234e40 100644
--- a/src/tests/unittests/ToBackendTests.cpp
+++ b/src/tests/unittests/ToBackendTests.cpp
@@ -21,21 +21,19 @@
 
 // Make our own Base - Backend object pair, reusing the CommandBuffer name
 namespace dawn_native {
-    class CommandBufferBase : public RefCounted {
-    };
-}
+    class CommandBufferBase : public RefCounted {};
+}  // namespace dawn_native
 
 using namespace dawn_native;
 
-class MyCommandBuffer : public CommandBufferBase {
-};
+class MyCommandBuffer : public CommandBufferBase {};
 
 struct MyBackendTraits {
     using CommandBufferType = MyCommandBuffer;
 };
 
 // Instanciate ToBackend for our "backend"
-template<typename T>
+template <typename T>
 auto ToBackend(T&& common) -> decltype(ToBackendBase<MyBackendTraits>(common)) {
     return ToBackendBase<MyBackendTraits>(common);
 }
@@ -71,7 +69,8 @@
         const Ref<CommandBufferBase> base(cmdBuf);
 
         const auto& backendCmdBuf = ToBackend(base);
-        static_assert(std::is_same<decltype(ToBackend(base)), const Ref<MyCommandBuffer>&>::value, "");
+        static_assert(std::is_same<decltype(ToBackend(base)), const Ref<MyCommandBuffer>&>::value,
+                      "");
         ASSERT_EQ(cmdBuf, backendCmdBuf.Get());
 
         cmdBuf->Release();
diff --git a/src/tests/unittests/d3d12/CopySplitTests.cpp b/src/tests/unittests/d3d12/CopySplitTests.cpp
index 46f7047..f867fef 100644
--- a/src/tests/unittests/d3d12/CopySplitTests.cpp
+++ b/src/tests/unittests/d3d12/CopySplitTests.cpp
@@ -55,7 +55,8 @@
 
     // Check that the offset is aligned
     void ValidateOffset(const TextureCopySplit& copySplit) {
-        ASSERT_TRUE(Align(copySplit.offset, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT) == copySplit.offset);
+        ASSERT_TRUE(Align(copySplit.offset, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT) ==
+                    copySplit.offset);
     }
 
     bool RangesOverlap(uint32_t minA, uint32_t maxA, uint32_t minB, uint32_t maxB) {
@@ -68,9 +69,15 @@
             const auto& a = copySplit.copies[i];
             for (uint32_t j = i + 1; j < copySplit.count; ++j) {
                 const auto& b = copySplit.copies[j];
-                bool overlapX = RangesOverlap(a.textureOffset.x, a.textureOffset.x + a.copySize.width, b.textureOffset.x, b.textureOffset.x + b.copySize.width);
-                bool overlapY = RangesOverlap(a.textureOffset.y, a.textureOffset.y + a.copySize.height, b.textureOffset.y, b.textureOffset.y + b.copySize.height);
-                bool overlapZ = RangesOverlap(a.textureOffset.z, a.textureOffset.z + a.copySize.depth, b.textureOffset.z, b.textureOffset.z + b.copySize.depth);
+                bool overlapX =
+                    RangesOverlap(a.textureOffset.x, a.textureOffset.x + a.copySize.width,
+                                  b.textureOffset.x, b.textureOffset.x + b.copySize.width);
+                bool overlapY =
+                    RangesOverlap(a.textureOffset.y, a.textureOffset.y + a.copySize.height,
+                                  b.textureOffset.y, b.textureOffset.y + b.copySize.height);
+                bool overlapZ =
+                    RangesOverlap(a.textureOffset.z, a.textureOffset.z + a.copySize.depth,
+                                  b.textureOffset.z, b.textureOffset.z + b.copySize.depth);
                 ASSERT_TRUE(!overlapX || !overlapY || !overlapZ);
             }
         }
@@ -105,7 +112,8 @@
         ASSERT_EQ(maxZ, textureSpec.z + textureSpec.depth);
     }
 
-    // Validate that the number of pixels copied is exactly equal to the number of pixels in the texture region
+    // Validate that the number of pixels copied is exactly equal to the number of pixels in the
+    // texture region
     void ValidatePixelCount(const TextureSpec& textureSpec, const TextureCopySplit& copySplit) {
         uint32_t count = 0;
         for (uint32_t i = 0; i < copySplit.count; ++i) {
@@ -116,7 +124,9 @@
     }
 
     // Check that every buffer offset is at the correct pixel location
-    void ValidateBufferOffset(const TextureSpec& textureSpec, const BufferSpec& bufferSpec, const TextureCopySplit& copySplit) {
+    void ValidateBufferOffset(const TextureSpec& textureSpec,
+                              const BufferSpec& bufferSpec,
+                              const TextureCopySplit& copySplit) {
         ASSERT_TRUE(copySplit.count > 0);
 
         uint32_t texelsPerBlock = textureSpec.blockWidth * textureSpec.blockHeight;
@@ -149,7 +159,9 @@
         }
     }
 
-    void ValidateCopySplit(const TextureSpec& textureSpec, const BufferSpec& bufferSpec, const TextureCopySplit& copySplit) {
+    void ValidateCopySplit(const TextureSpec& textureSpec,
+                           const BufferSpec& bufferSpec,
+                           const TextureCopySplit& copySplit) {
         ValidateFootprints(copySplit);
         ValidateOffset(copySplit);
         ValidateDisjoint(copySplit);
@@ -176,8 +188,13 @@
         os << "CopySplit" << std::endl;
         for (uint32_t i = 0; i < copySplit.count; ++i) {
             const auto& copy = copySplit.copies[i];
-            os << "  " << i << ": Texture at (" << copy.textureOffset.x << ", " << copy.textureOffset.y << ", " << copy.textureOffset.z << "), size (" << copy.copySize.width << ", " << copy.copySize.height << ", " << copy.copySize.depth << ")" << std::endl;
-            os << "  " << i << ": Buffer at (" << copy.bufferOffset.x << ", " << copy.bufferOffset.y << ", " << copy.bufferOffset.z << "), footprint (" << copy.bufferSize.width << ", " << copy.bufferSize.height << ", " << copy.bufferSize.depth << ")" << std::endl;
+            os << "  " << i << ": Texture at (" << copy.textureOffset.x << ", "
+               << copy.textureOffset.y << ", " << copy.textureOffset.z << "), size ("
+               << copy.copySize.width << ", " << copy.copySize.height << ", " << copy.copySize.depth
+               << ")" << std::endl;
+            os << "  " << i << ": Buffer at (" << copy.bufferOffset.x << ", " << copy.bufferOffset.y
+               << ", " << copy.bufferOffset.z << "), footprint (" << copy.bufferSize.width << ", "
+               << copy.bufferSize.height << ", " << copy.bufferSize.depth << ")" << std::endl;
         }
         return os;
     }
@@ -260,42 +277,40 @@
     }
 
     // Define a list of values to set properties in the spec structs
-    constexpr uint32_t kCheckValues[] = {
-        1, 2, 3, 4, 5, 6, 7, 8,                // small values
-        16, 32, 64, 128, 256, 512, 1024, 2048, // powers of 2
-        15, 31, 63, 127, 257, 511, 1023, 2047, // misalignments
-        17, 33, 65, 129, 257, 513, 1025, 2049
-    };
+    constexpr uint32_t kCheckValues[] = {1,  2,  3,  4,   5,   6,   7,    8,     // small values
+                                         16, 32, 64, 128, 256, 512, 1024, 2048,  // powers of 2
+                                         15, 31, 63, 127, 257, 511, 1023, 2047,  // misalignments
+                                         17, 33, 65, 129, 257, 513, 1025, 2049};
 
-}
+}  // namespace
 
 class CopySplitTest : public testing::Test {
-    protected:
-        TextureCopySplit DoTest(const TextureSpec& textureSpec, const BufferSpec& bufferSpec) {
-            ASSERT(textureSpec.width % textureSpec.blockWidth == 0 &&
-                   textureSpec.height % textureSpec.blockHeight == 0);
-            dawn_native::Format fakeFormat = {};
-            fakeFormat.blockWidth = textureSpec.blockWidth;
-            fakeFormat.blockHeight = textureSpec.blockHeight;
-            fakeFormat.blockByteSize = textureSpec.texelBlockSizeInBytes;
-            TextureCopySplit copySplit = ComputeTextureCopySplit(
-                {textureSpec.x, textureSpec.y, textureSpec.z},
-                {textureSpec.width, textureSpec.height, textureSpec.depth}, fakeFormat,
-                bufferSpec.offset, bufferSpec.bytesPerRow, bufferSpec.rowsPerImage);
-            ValidateCopySplit(textureSpec, bufferSpec, copySplit);
-            return copySplit;
-        }
+  protected:
+    TextureCopySplit DoTest(const TextureSpec& textureSpec, const BufferSpec& bufferSpec) {
+        ASSERT(textureSpec.width % textureSpec.blockWidth == 0 &&
+               textureSpec.height % textureSpec.blockHeight == 0);
+        dawn_native::Format fakeFormat = {};
+        fakeFormat.blockWidth = textureSpec.blockWidth;
+        fakeFormat.blockHeight = textureSpec.blockHeight;
+        fakeFormat.blockByteSize = textureSpec.texelBlockSizeInBytes;
+        TextureCopySplit copySplit = ComputeTextureCopySplit(
+            {textureSpec.x, textureSpec.y, textureSpec.z},
+            {textureSpec.width, textureSpec.height, textureSpec.depth}, fakeFormat,
+            bufferSpec.offset, bufferSpec.bytesPerRow, bufferSpec.rowsPerImage);
+        ValidateCopySplit(textureSpec, bufferSpec, copySplit);
+        return copySplit;
+    }
 };
 
 TEST_F(CopySplitTest, General) {
     for (TextureSpec textureSpec : kBaseTextureSpecs) {
         for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
-
             TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
             if (HasFatalFailure()) {
                 std::ostringstream message;
-                message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                    << copySplit << std::endl;
+                message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                        << std::endl
+                        << copySplit << std::endl;
                 FAIL() << message.str();
             }
         }
@@ -310,12 +325,12 @@
             }
             textureSpec.width = val;
             for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
-
                 TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
                 if (HasFatalFailure()) {
                     std::ostringstream message;
-                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                        << copySplit << std::endl;
+                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                            << std::endl
+                            << copySplit << std::endl;
                     FAIL() << message.str();
                 }
             }
@@ -331,12 +346,12 @@
             }
             textureSpec.height = val;
             for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
-
                 TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
                 if (HasFatalFailure()) {
                     std::ostringstream message;
-                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                        << copySplit << std::endl;
+                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                            << std::endl
+                            << copySplit << std::endl;
                     FAIL() << message.str();
                 }
             }
@@ -349,12 +364,12 @@
         for (uint32_t val : kCheckValues) {
             textureSpec.x = val;
             for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
-
                 TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
                 if (HasFatalFailure()) {
                     std::ostringstream message;
-                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                        << copySplit << std::endl;
+                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                            << std::endl
+                            << copySplit << std::endl;
                     FAIL() << message.str();
                 }
             }
@@ -367,12 +382,12 @@
         for (uint32_t val : kCheckValues) {
             textureSpec.y = val;
             for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
-
                 TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
                 if (HasFatalFailure()) {
                     std::ostringstream message;
-                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                        << copySplit << std::endl;
+                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                            << std::endl
+                            << copySplit << std::endl;
                     FAIL() << message.str();
                 }
             }
@@ -385,12 +400,12 @@
         for (uint32_t texelSize : {4, 8, 16, 32, 64}) {
             textureSpec.texelBlockSizeInBytes = texelSize;
             for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
-
                 TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
                 if (HasFatalFailure()) {
                     std::ostringstream message;
-                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                        << copySplit << std::endl;
+                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                            << std::endl
+                            << copySplit << std::endl;
                     FAIL() << message.str();
                 }
             }
@@ -407,8 +422,9 @@
                 TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
                 if (HasFatalFailure()) {
                     std::ostringstream message;
-                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                        << copySplit << std::endl;
+                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                            << std::endl
+                            << copySplit << std::endl;
                     FAIL() << message.str();
                 }
             }
@@ -426,8 +442,9 @@
                 TextureCopySplit copySplit = DoTest(textureSpec, bufferSpec);
                 if (HasFatalFailure()) {
                     std::ostringstream message;
-                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << std::endl
-                        << copySplit << std::endl;
+                    message << "Failed generating splits: " << textureSpec << ", " << bufferSpec
+                            << std::endl
+                            << copySplit << std::endl;
                     FAIL() << message.str();
                 }
             }
diff --git a/src/tests/unittests/validation/BindGroupValidationTests.cpp b/src/tests/unittests/validation/BindGroupValidationTests.cpp
index 6dec976..9b3aeb5 100644
--- a/src/tests/unittests/validation/BindGroupValidationTests.cpp
+++ b/src/tests/unittests/validation/BindGroupValidationTests.cpp
@@ -121,16 +121,10 @@
                  {1, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}});
 
     // Control case: check that different bindings work
-    utils::MakeBindGroup(device, layout, {
-        {0, mSampler},
-        {1, mSampler}
-    });
+    utils::MakeBindGroup(device, layout, {{0, mSampler}, {1, mSampler}});
 
     // Check that setting the same binding twice is invalid
-    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {
-        {0, mSampler},
-        {0, mSampler}
-    }));
+    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, mSampler}, {0, mSampler}}));
 }
 
 // Check that a sampler binding must contain exactly one sampler
@@ -406,7 +400,7 @@
     utils::MakeBindGroup(device, layout, {{0, buffer, 0, 256}});
 
     // Success case, touching the end of the buffer works
-    utils::MakeBindGroup(device, layout, {{0, buffer, 3*256, 256}});
+    utils::MakeBindGroup(device, layout, {{0, buffer, 3 * 256, 256}});
 
     // Error case, zero size is invalid.
     ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 1024, 0}}));
@@ -419,16 +413,17 @@
     utils::MakeBindGroup(device, layout, {{0, buffer, 256, wgpu::kWholeSize}});
 
     // Error case, offset is OOB
-    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 256*5, 0}}));
+    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 256 * 5, 0}}));
 
     // Error case, size is OOB
-    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 0, 256*5}}));
+    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 0, 256 * 5}}));
 
     // Error case, offset+size is OOB
     ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 1024, 256}}));
 
     // Error case, offset+size overflows to be 0
-    ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, 256, uint32_t(0) - uint32_t(256)}}));
+    ASSERT_DEVICE_ERROR(
+        utils::MakeBindGroup(device, layout, {{0, buffer, 256, uint32_t(0) - uint32_t(256)}}));
 }
 
 // Tests constraints to be sure the uniform buffer binding isn't too large
@@ -1191,8 +1186,8 @@
 
     // Create buffers which are 3x, 2x, and 1x the size of the minimum buffer offset, plus 4 bytes
     // to spare (to avoid zero-sized bindings). We will offset the bindings so they reach the very
-    // end of the buffer. Any mismatch applying too-large of an offset to a smaller buffer will hit the
-    // out-of-bounds condition during validation.
+    // end of the buffer. Any mismatch applying too-large of an offset to a smaller buffer will hit
+    // the out-of-bounds condition during validation.
     wgpu::Buffer buffer3x =
         CreateBuffer(3 * kMinDynamicBufferOffsetAlignment + 4, wgpu::BufferUsage::Storage);
     wgpu::Buffer buffer2x =
@@ -1487,7 +1482,6 @@
     wgpu::RenderPipeline CreateFSRenderPipeline(
         const char* fsShader,
         std::vector<wgpu::BindGroupLayout> bindGroupLayout) {
-
         wgpu::ShaderModule vsModule =
             utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
                 #version 450
@@ -1520,7 +1514,7 @@
                 layout(location = 0) out vec4 fragColor;
                 void main() {
                 })",
-                std::move(bindGroupLayout));
+                                      std::move(bindGroupLayout));
     }
 
     wgpu::ComputePipeline CreateComputePipeline(
@@ -1558,7 +1552,7 @@
                 } rdst;
                 void main() {
                 })",
-                std::move(bindGroupLayout));
+                                     std::move(bindGroupLayout));
     }
 };
 
diff --git a/src/tests/unittests/validation/BufferValidationTests.cpp b/src/tests/unittests/validation/BufferValidationTests.cpp
index f807b52..a724057 100644
--- a/src/tests/unittests/validation/BufferValidationTests.cpp
+++ b/src/tests/unittests/validation/BufferValidationTests.cpp
@@ -21,13 +21,13 @@
 using namespace testing;
 
 class MockBufferMapReadCallback {
-    public:
-      MOCK_METHOD(void,
-                  Call,
-                  (WGPUBufferMapAsyncStatus status,
-                   const uint32_t* ptr,
-                   uint64_t dataLength,
-                   void* userdata));
+  public:
+    MOCK_METHOD(void,
+                Call,
+                (WGPUBufferMapAsyncStatus status,
+                 const uint32_t* ptr,
+                 uint64_t dataLength,
+                 void* userdata));
 };
 
 static std::unique_ptr<MockBufferMapReadCallback> mockBufferMapReadCallback;
@@ -41,11 +41,11 @@
 }
 
 class MockBufferMapWriteCallback {
-    public:
-      MOCK_METHOD(
-          void,
-          Call,
-          (WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata));
+  public:
+    MOCK_METHOD(
+        void,
+        Call,
+        (WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata));
 };
 
 static std::unique_ptr<MockBufferMapWriteCallback> mockBufferMapWriteCallback;
@@ -59,57 +59,57 @@
 }
 
 class BufferValidationTest : public ValidationTest {
-    protected:
-      wgpu::Buffer CreateMapReadBuffer(uint64_t size) {
-          wgpu::BufferDescriptor descriptor;
-          descriptor.size = size;
-          descriptor.usage = wgpu::BufferUsage::MapRead;
+  protected:
+    wgpu::Buffer CreateMapReadBuffer(uint64_t size) {
+        wgpu::BufferDescriptor descriptor;
+        descriptor.size = size;
+        descriptor.usage = wgpu::BufferUsage::MapRead;
 
-          return device.CreateBuffer(&descriptor);
-      }
-      wgpu::Buffer CreateMapWriteBuffer(uint64_t size) {
-          wgpu::BufferDescriptor descriptor;
-          descriptor.size = size;
-          descriptor.usage = wgpu::BufferUsage::MapWrite;
+        return device.CreateBuffer(&descriptor);
+    }
+    wgpu::Buffer CreateMapWriteBuffer(uint64_t size) {
+        wgpu::BufferDescriptor descriptor;
+        descriptor.size = size;
+        descriptor.usage = wgpu::BufferUsage::MapWrite;
 
-          return device.CreateBuffer(&descriptor);
-      }
+        return device.CreateBuffer(&descriptor);
+    }
 
-      wgpu::CreateBufferMappedResult CreateBufferMapped(uint64_t size, wgpu::BufferUsage usage) {
-          wgpu::BufferDescriptor descriptor;
-          descriptor.size = size;
-          descriptor.usage = usage;
+    wgpu::CreateBufferMappedResult CreateBufferMapped(uint64_t size, wgpu::BufferUsage usage) {
+        wgpu::BufferDescriptor descriptor;
+        descriptor.size = size;
+        descriptor.usage = usage;
 
-          return device.CreateBufferMapped(&descriptor);
-      }
+        return device.CreateBufferMapped(&descriptor);
+    }
 
-      wgpu::Buffer BufferMappedAtCreation(uint64_t size, wgpu::BufferUsage usage) {
-          wgpu::BufferDescriptor descriptor;
-          descriptor.size = size;
-          descriptor.usage = usage;
-          descriptor.mappedAtCreation = true;
+    wgpu::Buffer BufferMappedAtCreation(uint64_t size, wgpu::BufferUsage usage) {
+        wgpu::BufferDescriptor descriptor;
+        descriptor.size = size;
+        descriptor.usage = usage;
+        descriptor.mappedAtCreation = true;
 
-          return device.CreateBuffer(&descriptor);
-      }
+        return device.CreateBuffer(&descriptor);
+    }
 
-      wgpu::Queue queue;
+    wgpu::Queue queue;
 
-    private:
-        void SetUp() override {
-            ValidationTest::SetUp();
+  private:
+    void SetUp() override {
+        ValidationTest::SetUp();
 
-            mockBufferMapReadCallback = std::make_unique<MockBufferMapReadCallback>();
-            mockBufferMapWriteCallback = std::make_unique<MockBufferMapWriteCallback>();
-            queue = device.GetDefaultQueue();
-        }
+        mockBufferMapReadCallback = std::make_unique<MockBufferMapReadCallback>();
+        mockBufferMapWriteCallback = std::make_unique<MockBufferMapWriteCallback>();
+        queue = device.GetDefaultQueue();
+    }
 
-        void TearDown() override {
-            // Delete mocks so that expectations are checked
-            mockBufferMapReadCallback = nullptr;
-            mockBufferMapWriteCallback = nullptr;
+    void TearDown() override {
+        // Delete mocks so that expectations are checked
+        mockBufferMapReadCallback = nullptr;
+        mockBufferMapWriteCallback = nullptr;
 
-            ValidationTest::TearDown();
-        }
+        ValidationTest::TearDown();
+    }
 };
 
 // Test case where creation should succeed
@@ -416,7 +416,8 @@
     WaitForAllOperations(device);
 }
 
-// Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the callback
+// Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the
+// callback
 TEST_F(BufferValidationTest, DestroyInsideMapReadCallback) {
     wgpu::Buffer buf = CreateMapReadBuffer(4);
 
@@ -429,7 +430,8 @@
     WaitForAllOperations(device);
 }
 
-// Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the callback
+// Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the
+// callback
 TEST_F(BufferValidationTest, DestroyInsideMapWriteCallback) {
     wgpu::Buffer buf = CreateMapWriteBuffer(4);
 
diff --git a/src/tests/unittests/validation/CommandBufferValidationTests.cpp b/src/tests/unittests/validation/CommandBufferValidationTests.cpp
index e8909ac..e31879b 100644
--- a/src/tests/unittests/validation/CommandBufferValidationTests.cpp
+++ b/src/tests/unittests/validation/CommandBufferValidationTests.cpp
@@ -16,8 +16,7 @@
 
 #include "utils/WGPUHelpers.h"
 
-class CommandBufferValidationTest : public ValidationTest {
-};
+class CommandBufferValidationTest : public ValidationTest {};
 
 // Test for an empty command buffer
 TEST_F(CommandBufferValidationTest, Empty) {
diff --git a/src/tests/unittests/validation/ComputeValidationTests.cpp b/src/tests/unittests/validation/ComputeValidationTests.cpp
index fded925..8135997 100644
--- a/src/tests/unittests/validation/ComputeValidationTests.cpp
+++ b/src/tests/unittests/validation/ComputeValidationTests.cpp
@@ -14,7 +14,7 @@
 
 #include "tests/unittests/validation/ValidationTest.h"
 
-class ComputeValidationTest : public ValidationTest {
-};
+class ComputeValidationTest : public ValidationTest {};
 
-//TODO(cwallez@chromium.org): Add a regression test for Disptach validation trying to acces the input state.
+// TODO(cwallez@chromium.org): Add a regression test for Disptach validation trying to acces the
+// input state.
diff --git a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
index 1cd9e28..e5877af 100644
--- a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
+++ b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
@@ -1168,8 +1168,8 @@
 
 TEST_F(CopyCommandTest_T2T, 2DTextureArrayDepthStencil) {
     {
-        wgpu::Texture source = Create2DTexture(16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8,
-                                           wgpu::TextureUsage::CopySrc);
+        wgpu::Texture source = Create2DTexture(
+            16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopySrc);
         wgpu::Texture destination = Create2DTexture(
             16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst);
 
@@ -1179,8 +1179,8 @@
     }
 
     {
-        wgpu::Texture source = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8,
-                                           wgpu::TextureUsage::CopySrc);
+        wgpu::Texture source = Create2DTexture(
+            16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopySrc);
         wgpu::Texture destination = Create2DTexture(
             16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst);
 
@@ -1190,8 +1190,8 @@
     }
 
     {
-        wgpu::Texture source = Create2DTexture(16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8,
-                                           wgpu::TextureUsage::CopySrc);
+        wgpu::Texture source = Create2DTexture(
+            16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopySrc);
         wgpu::Texture destination = Create2DTexture(
             16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst);
 
@@ -1659,4 +1659,4 @@
                              {0, 0, 0});
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp b/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp
index 62e9ca9..cc16640 100644
--- a/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp
+++ b/src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp
@@ -223,8 +223,7 @@
     }
 }
 
-class SetScissorRectTest : public ValidationTest {
-};
+class SetScissorRectTest : public ValidationTest {};
 
 // Test to check basic use of SetScissor
 TEST_F(SetScissorRectTest, Success) {
@@ -284,8 +283,7 @@
     encoder.Finish();
 }
 
-class SetBlendColorTest : public ValidationTest {
-};
+class SetBlendColorTest : public ValidationTest {};
 
 // Test to check basic use of SetBlendColor
 TEST_F(SetBlendColorTest, Success) {
@@ -315,8 +313,7 @@
     encoder.Finish();
 }
 
-class SetStencilReferenceTest : public ValidationTest {
-};
+class SetStencilReferenceTest : public ValidationTest {};
 
 // Test to check basic use of SetStencilReferenceTest
 TEST_F(SetStencilReferenceTest, Success) {
diff --git a/src/tests/unittests/validation/QueueSubmitValidationTests.cpp b/src/tests/unittests/validation/QueueSubmitValidationTests.cpp
index 566c746..8779ce3 100644
--- a/src/tests/unittests/validation/QueueSubmitValidationTests.cpp
+++ b/src/tests/unittests/validation/QueueSubmitValidationTests.cpp
@@ -18,181 +18,180 @@
 
 namespace {
 
-class QueueSubmitValidationTest : public ValidationTest {
-};
+    class QueueSubmitValidationTest : public ValidationTest {};
 
-// Test submitting with a mapped buffer is disallowed
-TEST_F(QueueSubmitValidationTest, SubmitWithMappedBuffer) {
-    // Create a map-write buffer.
-    wgpu::BufferDescriptor descriptor;
-    descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc;
-    descriptor.size = 4;
-    wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
-
-    // Create a fake copy destination buffer
-    descriptor.usage = wgpu::BufferUsage::CopyDst;
-    wgpu::Buffer targetBuffer = device.CreateBuffer(&descriptor);
-
-    // Create a command buffer that reads from the mappable buffer.
-    wgpu::CommandBuffer commands;
-    {
-        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToBuffer(buffer, 0, targetBuffer, 0, 4);
-        commands = encoder.Finish();
-    }
-
-    wgpu::Queue queue = device.GetDefaultQueue();
-
-    // Submitting when the buffer has never been mapped should succeed
-    queue.Submit(1, &commands);
-
-    // Map the buffer, submitting when the buffer is mapped should fail
-    buffer.MapWriteAsync(nullptr, nullptr);
-
-    // Try submitting before the callback is fired.
-    ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
-
-    WaitForAllOperations(device);
-
-    // Try submitting after the callback is fired.
-    ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
-
-    // Unmap the buffer, queue submit should succeed
-    buffer.Unmap();
-    queue.Submit(1, &commands);
-}
-
-class QueueWriteBufferValidationTest : public ValidationTest {
-  private:
-    void SetUp() override {
-        ValidationTest::SetUp();
-        queue = device.GetDefaultQueue();
-    }
-
-  protected:
-    wgpu::Buffer CreateBuffer(uint64_t size) {
+    // Test submitting with a mapped buffer is disallowed
+    TEST_F(QueueSubmitValidationTest, SubmitWithMappedBuffer) {
+        // Create a map-write buffer.
         wgpu::BufferDescriptor descriptor;
-        descriptor.size = size;
-        descriptor.usage = wgpu::BufferUsage::CopyDst;
-        return device.CreateBuffer(&descriptor);
-    }
-
-    wgpu::Queue queue;
-};
-
-// Test the success case for WriteBuffer
-TEST_F(QueueWriteBufferValidationTest, Success) {
-    wgpu::Buffer buf = CreateBuffer(4);
-
-    uint32_t foo = 0x01020304;
-    queue.WriteBuffer(buf, 0, &foo, sizeof(foo));
-}
-
-// Test error case for WriteBuffer out of bounds
-TEST_F(QueueWriteBufferValidationTest, OutOfBounds) {
-    wgpu::Buffer buf = CreateBuffer(4);
-
-    uint32_t foo[2] = {0, 0};
-    ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, foo, 8));
-}
-
-// Test error case for WriteBuffer out of bounds with an overflow
-TEST_F(QueueWriteBufferValidationTest, OutOfBoundsOverflow) {
-    wgpu::Buffer buf = CreateBuffer(1024);
-
-    uint32_t foo[2] = {0, 0};
-
-    // An offset that when added to "4" would overflow to be zero and pass validation without
-    // overflow checks.
-    uint64_t offset = uint64_t(int64_t(0) - int64_t(4));
-
-    ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, offset, foo, 4));
-}
-
-// Test error case for WriteBuffer with the wrong usage
-TEST_F(QueueWriteBufferValidationTest, WrongUsage) {
-    wgpu::BufferDescriptor descriptor;
-    descriptor.size = 4;
-    descriptor.usage = wgpu::BufferUsage::Vertex;
-    wgpu::Buffer buf = device.CreateBuffer(&descriptor);
-
-    uint32_t foo = 0;
-    ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &foo, sizeof(foo)));
-}
-
-// Test WriteBuffer with unaligned size
-TEST_F(QueueWriteBufferValidationTest, UnalignedSize) {
-    wgpu::Buffer buf = CreateBuffer(4);
-
-    uint16_t value = 123;
-    ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
-}
-
-// Test WriteBuffer with unaligned offset
-TEST_F(QueueWriteBufferValidationTest, UnalignedOffset) {
-    wgpu::Buffer buf = CreateBuffer(8);
-
-    uint32_t value = 0x01020304;
-    ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 2, &value, sizeof(value)));
-}
-
-// Test WriteBuffer with destroyed buffer
-TEST_F(QueueWriteBufferValidationTest, DestroyedBuffer) {
-    wgpu::Buffer buf = CreateBuffer(4);
-    buf.Destroy();
-
-    uint32_t value = 0;
-    ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
-}
-
-// Test WriteBuffer with mapped buffer
-TEST_F(QueueWriteBufferValidationTest, MappedBuffer) {
-    // CreateBufferMapped
-    {
-        wgpu::BufferDescriptor descriptor;
+        descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc;
         descriptor.size = 4;
-        descriptor.usage = wgpu::BufferUsage::CopyDst;
-        wgpu::CreateBufferMappedResult result = device.CreateBufferMapped(&descriptor);
-
-        uint32_t value = 0;
-        ASSERT_DEVICE_ERROR(queue.WriteBuffer(result.buffer, 0, &value, sizeof(value)));
-    }
-
-    // mappedAtCreation
-    {
-        wgpu::BufferDescriptor descriptor;
-        descriptor.size = 4;
-        descriptor.usage = wgpu::BufferUsage::CopyDst;
-        descriptor.mappedAtCreation = true;
         wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
 
-        uint32_t value = 0;
-        ASSERT_DEVICE_ERROR(queue.WriteBuffer(buffer, 0, &value, sizeof(value)));
+        // Create a fake copy destination buffer
+        descriptor.usage = wgpu::BufferUsage::CopyDst;
+        wgpu::Buffer targetBuffer = device.CreateBuffer(&descriptor);
+
+        // Create a command buffer that reads from the mappable buffer.
+        wgpu::CommandBuffer commands;
+        {
+            wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+            encoder.CopyBufferToBuffer(buffer, 0, targetBuffer, 0, 4);
+            commands = encoder.Finish();
+        }
+
+        wgpu::Queue queue = device.GetDefaultQueue();
+
+        // Submitting when the buffer has never been mapped should succeed
+        queue.Submit(1, &commands);
+
+        // Map the buffer, submitting when the buffer is mapped should fail
+        buffer.MapWriteAsync(nullptr, nullptr);
+
+        // Try submitting before the callback is fired.
+        ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
+
+        WaitForAllOperations(device);
+
+        // Try submitting after the callback is fired.
+        ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
+
+        // Unmap the buffer, queue submit should succeed
+        buffer.Unmap();
+        queue.Submit(1, &commands);
     }
 
-    // MapReadAsync
-    {
+    class QueueWriteBufferValidationTest : public ValidationTest {
+      private:
+        void SetUp() override {
+            ValidationTest::SetUp();
+            queue = device.GetDefaultQueue();
+        }
+
+      protected:
+        wgpu::Buffer CreateBuffer(uint64_t size) {
+            wgpu::BufferDescriptor descriptor;
+            descriptor.size = size;
+            descriptor.usage = wgpu::BufferUsage::CopyDst;
+            return device.CreateBuffer(&descriptor);
+        }
+
+        wgpu::Queue queue;
+    };
+
+    // Test the success case for WriteBuffer
+    TEST_F(QueueWriteBufferValidationTest, Success) {
+        wgpu::Buffer buf = CreateBuffer(4);
+
+        uint32_t foo = 0x01020304;
+        queue.WriteBuffer(buf, 0, &foo, sizeof(foo));
+    }
+
+    // Test error case for WriteBuffer out of bounds
+    TEST_F(QueueWriteBufferValidationTest, OutOfBounds) {
+        wgpu::Buffer buf = CreateBuffer(4);
+
+        uint32_t foo[2] = {0, 0};
+        ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, foo, 8));
+    }
+
+    // Test error case for WriteBuffer out of bounds with an overflow
+    TEST_F(QueueWriteBufferValidationTest, OutOfBoundsOverflow) {
+        wgpu::Buffer buf = CreateBuffer(1024);
+
+        uint32_t foo[2] = {0, 0};
+
+        // An offset that when added to "4" would overflow to be zero and pass validation without
+        // overflow checks.
+        uint64_t offset = uint64_t(int64_t(0) - int64_t(4));
+
+        ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, offset, foo, 4));
+    }
+
+    // Test error case for WriteBuffer with the wrong usage
+    TEST_F(QueueWriteBufferValidationTest, WrongUsage) {
         wgpu::BufferDescriptor descriptor;
         descriptor.size = 4;
-        descriptor.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead;
+        descriptor.usage = wgpu::BufferUsage::Vertex;
         wgpu::Buffer buf = device.CreateBuffer(&descriptor);
 
-        buf.MapReadAsync(nullptr, nullptr);
+        uint32_t foo = 0;
+        ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &foo, sizeof(foo)));
+    }
+
+    // Test WriteBuffer with unaligned size
+    TEST_F(QueueWriteBufferValidationTest, UnalignedSize) {
+        wgpu::Buffer buf = CreateBuffer(4);
+
+        uint16_t value = 123;
+        ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
+    }
+
+    // Test WriteBuffer with unaligned offset
+    TEST_F(QueueWriteBufferValidationTest, UnalignedOffset) {
+        wgpu::Buffer buf = CreateBuffer(8);
+
+        uint32_t value = 0x01020304;
+        ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 2, &value, sizeof(value)));
+    }
+
+    // Test WriteBuffer with destroyed buffer
+    TEST_F(QueueWriteBufferValidationTest, DestroyedBuffer) {
+        wgpu::Buffer buf = CreateBuffer(4);
+        buf.Destroy();
+
         uint32_t value = 0;
         ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
     }
 
-    // MapWriteAsync
-    {
-        wgpu::BufferDescriptor descriptor;
-        descriptor.size = 4;
-        descriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::MapWrite;
-        wgpu::Buffer buf = device.CreateBuffer(&descriptor);
+    // Test WriteBuffer with mapped buffer
+    TEST_F(QueueWriteBufferValidationTest, MappedBuffer) {
+        // CreateBufferMapped
+        {
+            wgpu::BufferDescriptor descriptor;
+            descriptor.size = 4;
+            descriptor.usage = wgpu::BufferUsage::CopyDst;
+            wgpu::CreateBufferMappedResult result = device.CreateBufferMapped(&descriptor);
 
-        buf.MapWriteAsync(nullptr, nullptr);
-        uint32_t value = 0;
-        ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
+            uint32_t value = 0;
+            ASSERT_DEVICE_ERROR(queue.WriteBuffer(result.buffer, 0, &value, sizeof(value)));
+        }
+
+        // mappedAtCreation
+        {
+            wgpu::BufferDescriptor descriptor;
+            descriptor.size = 4;
+            descriptor.usage = wgpu::BufferUsage::CopyDst;
+            descriptor.mappedAtCreation = true;
+            wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
+
+            uint32_t value = 0;
+            ASSERT_DEVICE_ERROR(queue.WriteBuffer(buffer, 0, &value, sizeof(value)));
+        }
+
+        // MapReadAsync
+        {
+            wgpu::BufferDescriptor descriptor;
+            descriptor.size = 4;
+            descriptor.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead;
+            wgpu::Buffer buf = device.CreateBuffer(&descriptor);
+
+            buf.MapReadAsync(nullptr, nullptr);
+            uint32_t value = 0;
+            ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
+        }
+
+        // MapWriteAsync
+        {
+            wgpu::BufferDescriptor descriptor;
+            descriptor.size = 4;
+            descriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::MapWrite;
+            wgpu::Buffer buf = device.CreateBuffer(&descriptor);
+
+            buf.MapWriteAsync(nullptr, nullptr);
+            uint32_t value = 0;
+            ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
+        }
     }
-}
 
 }  // anonymous namespace
diff --git a/src/tests/unittests/validation/QueueWriteTextureValidationTests.cpp b/src/tests/unittests/validation/QueueWriteTextureValidationTests.cpp
index 039da11..c238acf 100644
--- a/src/tests/unittests/validation/QueueWriteTextureValidationTests.cpp
+++ b/src/tests/unittests/validation/QueueWriteTextureValidationTests.cpp
@@ -636,4 +636,4 @@
         }
     }
 
-}  // anonymous namespace
\ No newline at end of file
+}  // anonymous namespace
diff --git a/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp b/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp
index 7c9b11b..5b99a1f 100644
--- a/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp
+++ b/src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp
@@ -22,720 +22,746 @@
 
 namespace {
 
-class RenderPassDescriptorValidationTest : public ValidationTest {
-  public:
-    void AssertBeginRenderPassSuccess(const wgpu::RenderPassDescriptor* descriptor) {
-        wgpu::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor);
-        commandEncoder.Finish();
-    }
-    void AssertBeginRenderPassError(const wgpu::RenderPassDescriptor* descriptor) {
-        wgpu::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor);
-        ASSERT_DEVICE_ERROR(commandEncoder.Finish());
+    class RenderPassDescriptorValidationTest : public ValidationTest {
+      public:
+        void AssertBeginRenderPassSuccess(const wgpu::RenderPassDescriptor* descriptor) {
+            wgpu::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor);
+            commandEncoder.Finish();
+        }
+        void AssertBeginRenderPassError(const wgpu::RenderPassDescriptor* descriptor) {
+            wgpu::CommandEncoder commandEncoder = TestBeginRenderPass(descriptor);
+            ASSERT_DEVICE_ERROR(commandEncoder.Finish());
+        }
+
+      private:
+        wgpu::CommandEncoder TestBeginRenderPass(const wgpu::RenderPassDescriptor* descriptor) {
+            wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
+            wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(descriptor);
+            renderPassEncoder.EndPass();
+            return commandEncoder;
+        }
+    };
+
+    wgpu::Texture CreateTexture(wgpu::Device& device,
+                                wgpu::TextureDimension dimension,
+                                wgpu::TextureFormat format,
+                                uint32_t width,
+                                uint32_t height,
+                                uint32_t arrayLayerCount,
+                                uint32_t mipLevelCount,
+                                uint32_t sampleCount = 1,
+                                wgpu::TextureUsage usage = wgpu::TextureUsage::OutputAttachment) {
+        wgpu::TextureDescriptor descriptor;
+        descriptor.dimension = dimension;
+        descriptor.size.width = width;
+        descriptor.size.height = height;
+        descriptor.size.depth = arrayLayerCount;
+        descriptor.sampleCount = sampleCount;
+        descriptor.format = format;
+        descriptor.mipLevelCount = mipLevelCount;
+        descriptor.usage = usage;
+
+        return device.CreateTexture(&descriptor);
     }
 
-  private:
-    wgpu::CommandEncoder TestBeginRenderPass(const wgpu::RenderPassDescriptor* descriptor) {
-        wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
-        wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(descriptor);
-        renderPassEncoder.EndPass();
-        return commandEncoder;
+    wgpu::TextureView Create2DAttachment(wgpu::Device& device,
+                                         uint32_t width,
+                                         uint32_t height,
+                                         wgpu::TextureFormat format) {
+        wgpu::Texture texture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, format, width, height, 1, 1);
+        return texture.CreateView();
     }
-};
 
-wgpu::Texture CreateTexture(wgpu::Device& device,
-                            wgpu::TextureDimension dimension,
-                            wgpu::TextureFormat format,
-                            uint32_t width,
-                            uint32_t height,
-                            uint32_t arrayLayerCount,
-                            uint32_t mipLevelCount,
-                            uint32_t sampleCount = 1,
-                            wgpu::TextureUsage usage = wgpu::TextureUsage::OutputAttachment) {
-    wgpu::TextureDescriptor descriptor;
-    descriptor.dimension = dimension;
-    descriptor.size.width = width;
-    descriptor.size.height = height;
-    descriptor.size.depth = arrayLayerCount;
-    descriptor.sampleCount = sampleCount;
-    descriptor.format = format;
-    descriptor.mipLevelCount = mipLevelCount;
-    descriptor.usage = usage;
+    // Using BeginRenderPass with no attachments isn't valid
+    TEST_F(RenderPassDescriptorValidationTest, Empty) {
+        utils::ComboRenderPassDescriptor renderPass({}, nullptr);
+        AssertBeginRenderPassError(&renderPass);
+    }
 
-    return device.CreateTexture(&descriptor);
-}
+    // A render pass with only one color or one depth attachment is ok
+    TEST_F(RenderPassDescriptorValidationTest, OneAttachment) {
+        // One color attachment
+        {
+            wgpu::TextureView color =
+                Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+            utils::ComboRenderPassDescriptor renderPass({color});
 
-wgpu::TextureView Create2DAttachment(wgpu::Device& device,
-                                     uint32_t width,
-                                     uint32_t height,
-                                     wgpu::TextureFormat format) {
-    wgpu::Texture texture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, format, width, height, 1, 1);
-    return texture.CreateView();
-}
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+        // One depth-stencil attachment
+        {
+            wgpu::TextureView depthStencil =
+                Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8);
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencil);
 
-// Using BeginRenderPass with no attachments isn't valid
-TEST_F(RenderPassDescriptorValidationTest, Empty) {
-    utils::ComboRenderPassDescriptor renderPass({}, nullptr);
-    AssertBeginRenderPassError(&renderPass);
-}
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+    }
 
-// A render pass with only one color or one depth attachment is ok
-TEST_F(RenderPassDescriptorValidationTest, OneAttachment) {
-    // One color attachment
-    {
+    // Test OOB color attachment indices are handled
+    TEST_F(RenderPassDescriptorValidationTest, ColorAttachmentOutOfBounds) {
+        wgpu::TextureView color0 =
+            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+        wgpu::TextureView color1 =
+            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+        wgpu::TextureView color2 =
+            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+        wgpu::TextureView color3 =
+            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+        // For setting the color attachment, control case
+        {
+            utils::ComboRenderPassDescriptor renderPass({color0, color1, color2, color3});
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+        // For setting the color attachment, OOB
+        {
+            // We cannot use utils::ComboRenderPassDescriptor here because it only supports at most
+            // kMaxColorAttachments(4) color attachments.
+            std::array<wgpu::RenderPassColorAttachmentDescriptor, 5> colorAttachments;
+            colorAttachments[0].attachment = color0;
+            colorAttachments[0].resolveTarget = nullptr;
+            colorAttachments[0].clearColor = {0.0f, 0.0f, 0.0f, 0.0f};
+            colorAttachments[0].loadOp = wgpu::LoadOp::Clear;
+            colorAttachments[0].storeOp = wgpu::StoreOp::Store;
+
+            colorAttachments[1] = colorAttachments[0];
+            colorAttachments[1].attachment = color1;
+
+            colorAttachments[2] = colorAttachments[0];
+            colorAttachments[2].attachment = color2;
+
+            colorAttachments[3] = colorAttachments[0];
+            colorAttachments[3].attachment = color3;
+
+            colorAttachments[4] = colorAttachments[0];
+            colorAttachments[4].attachment =
+                Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+
+            wgpu::RenderPassDescriptor renderPass;
+            renderPass.colorAttachmentCount = 5;
+            renderPass.colorAttachments = colorAttachments.data();
+            renderPass.depthStencilAttachment = nullptr;
+            AssertBeginRenderPassError(&renderPass);
+        }
+    }
+
+    // Attachments must have the same size
+    TEST_F(RenderPassDescriptorValidationTest, SizeMustMatch) {
+        wgpu::TextureView color1x1A =
+            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+        wgpu::TextureView color1x1B =
+            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+        wgpu::TextureView color2x2 =
+            Create2DAttachment(device, 2, 2, wgpu::TextureFormat::RGBA8Unorm);
+
+        wgpu::TextureView depthStencil1x1 =
+            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8);
+        wgpu::TextureView depthStencil2x2 =
+            Create2DAttachment(device, 2, 2, wgpu::TextureFormat::Depth24PlusStencil8);
+
+        // Control case: all the same size (1x1)
+        {
+            utils::ComboRenderPassDescriptor renderPass({color1x1A, color1x1B}, depthStencil1x1);
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // One of the color attachments has a different size
+        {
+            utils::ComboRenderPassDescriptor renderPass({color1x1A, color2x2});
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // The depth stencil attachment has a different size
+        {
+            utils::ComboRenderPassDescriptor renderPass({color1x1A, color1x1B}, depthStencil2x2);
+            AssertBeginRenderPassError(&renderPass);
+        }
+    }
+
+    // Attachments formats must match whether they are used for color or depth-stencil
+    TEST_F(RenderPassDescriptorValidationTest, FormatMismatch) {
         wgpu::TextureView color = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-        utils::ComboRenderPassDescriptor renderPass({color});
-
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-    // One depth-stencil attachment
-    {
         wgpu::TextureView depthStencil =
             Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8);
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencil);
 
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-}
+        // Using depth-stencil for color
+        {
+            utils::ComboRenderPassDescriptor renderPass({depthStencil});
+            AssertBeginRenderPassError(&renderPass);
+        }
 
-// Test OOB color attachment indices are handled
-TEST_F(RenderPassDescriptorValidationTest, ColorAttachmentOutOfBounds) {
-    wgpu::TextureView color0 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-    wgpu::TextureView color1 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-    wgpu::TextureView color2 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-    wgpu::TextureView color3 = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-    // For setting the color attachment, control case
-    {
-        utils::ComboRenderPassDescriptor renderPass({color0, color1, color2, color3});
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-    // For setting the color attachment, OOB
-    {
-        // We cannot use utils::ComboRenderPassDescriptor here because it only supports at most
-        // kMaxColorAttachments(4) color attachments.
-        std::array<wgpu::RenderPassColorAttachmentDescriptor, 5> colorAttachments;
-        colorAttachments[0].attachment = color0;
-        colorAttachments[0].resolveTarget = nullptr;
-        colorAttachments[0].clearColor = {0.0f, 0.0f, 0.0f, 0.0f};
-        colorAttachments[0].loadOp = wgpu::LoadOp::Clear;
-        colorAttachments[0].storeOp = wgpu::StoreOp::Store;
-
-        colorAttachments[1] = colorAttachments[0];
-        colorAttachments[1].attachment = color1;
-
-        colorAttachments[2] = colorAttachments[0];
-        colorAttachments[2].attachment = color2;
-
-        colorAttachments[3] = colorAttachments[0];
-        colorAttachments[3].attachment = color3;
-
-        colorAttachments[4] = colorAttachments[0];
-        colorAttachments[4].attachment =
-            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-
-        wgpu::RenderPassDescriptor renderPass;
-        renderPass.colorAttachmentCount = 5;
-        renderPass.colorAttachments = colorAttachments.data();
-        renderPass.depthStencilAttachment = nullptr;
-        AssertBeginRenderPassError(&renderPass);
-    }
-}
-
-// Attachments must have the same size
-TEST_F(RenderPassDescriptorValidationTest, SizeMustMatch) {
-    wgpu::TextureView color1x1A = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-    wgpu::TextureView color1x1B = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-    wgpu::TextureView color2x2 = Create2DAttachment(device, 2, 2, wgpu::TextureFormat::RGBA8Unorm);
-
-    wgpu::TextureView depthStencil1x1 =
-        Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8);
-    wgpu::TextureView depthStencil2x2 =
-        Create2DAttachment(device, 2, 2, wgpu::TextureFormat::Depth24PlusStencil8);
-
-    // Control case: all the same size (1x1)
-    {
-        utils::ComboRenderPassDescriptor renderPass({color1x1A, color1x1B}, depthStencil1x1);
-        AssertBeginRenderPassSuccess(&renderPass);
+        // Using color for depth-stencil
+        {
+            utils::ComboRenderPassDescriptor renderPass({}, color);
+            AssertBeginRenderPassError(&renderPass);
+        }
     }
 
-    // One of the color attachments has a different size
-    {
-        utils::ComboRenderPassDescriptor renderPass({color1x1A, color2x2});
-        AssertBeginRenderPassError(&renderPass);
-    }
+    // Depth and stencil storeOps must match
+    TEST_F(RenderPassDescriptorValidationTest, DepthStencilStoreOpMismatch) {
+        constexpr uint32_t kArrayLayers = 1;
+        constexpr uint32_t kLevelCount = 1;
+        constexpr uint32_t kSize = 32;
+        constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
+        constexpr wgpu::TextureFormat kDepthStencilFormat =
+            wgpu::TextureFormat::Depth24PlusStencil8;
 
-    // The depth stencil attachment has a different size
-    {
-        utils::ComboRenderPassDescriptor renderPass({color1x1A, color1x1B}, depthStencil2x2);
-        AssertBeginRenderPassError(&renderPass);
-    }
-}
-
-// Attachments formats must match whether they are used for color or depth-stencil
-TEST_F(RenderPassDescriptorValidationTest, FormatMismatch) {
-    wgpu::TextureView color = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-    wgpu::TextureView depthStencil =
-        Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8);
-
-    // Using depth-stencil for color
-    {
-        utils::ComboRenderPassDescriptor renderPass({depthStencil});
-        AssertBeginRenderPassError(&renderPass);
-    }
-
-    // Using color for depth-stencil
-    {
-        utils::ComboRenderPassDescriptor renderPass({}, color);
-        AssertBeginRenderPassError(&renderPass);
-    }
-}
-
-// Depth and stencil storeOps must match
-TEST_F(RenderPassDescriptorValidationTest, DepthStencilStoreOpMismatch) {
-    constexpr uint32_t kArrayLayers = 1;
-    constexpr uint32_t kLevelCount = 1;
-    constexpr uint32_t kSize = 32;
-    constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
-    constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8;
-
-    wgpu::Texture colorTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat,
-                                               kSize, kSize, kArrayLayers, kLevelCount);
-    wgpu::Texture depthStencilTexture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
-                      kArrayLayers, kLevelCount);
-
-    wgpu::TextureViewDescriptor descriptor;
-    descriptor.dimension = wgpu::TextureViewDimension::e2D;
-    descriptor.baseArrayLayer = 0;
-    descriptor.arrayLayerCount = kArrayLayers;
-    descriptor.baseMipLevel = 0;
-    descriptor.mipLevelCount = kLevelCount;
-    wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
-    wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
-
-    // StoreOps mismatch causing the render pass to error
-    {
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store;
-        renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Clear;
-        AssertBeginRenderPassError(&renderPass);
-    }
-
-    // StoreOps match so render pass is a success
-    {
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store;
-        renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Store;
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // StoreOps match so render pass is a success
-    {
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Clear;
-        renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Clear;
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-}
-
-// Currently only texture views with arrayLayerCount == 1 are allowed to be color and depth stencil
-// attachments
-TEST_F(RenderPassDescriptorValidationTest, TextureViewLayerCountForColorAndDepthStencil) {
-    constexpr uint32_t kLevelCount = 1;
-    constexpr uint32_t kSize = 32;
-    constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
-    constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8;
-
-    constexpr uint32_t kArrayLayers = 10;
-
-    wgpu::Texture colorTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat,
-                                               kSize, kSize, kArrayLayers, kLevelCount);
-    wgpu::Texture depthStencilTexture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
-                      kArrayLayers, kLevelCount);
-
-    wgpu::TextureViewDescriptor baseDescriptor;
-    baseDescriptor.dimension = wgpu::TextureViewDimension::e2DArray;
-    baseDescriptor.baseArrayLayer = 0;
-    baseDescriptor.arrayLayerCount = kArrayLayers;
-    baseDescriptor.baseMipLevel = 0;
-    baseDescriptor.mipLevelCount = kLevelCount;
-
-    // Using 2D array texture view with arrayLayerCount > 1 is not allowed for color
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kColorFormat;
-        descriptor.arrayLayerCount = 5;
-
-        wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({colorTextureView});
-        AssertBeginRenderPassError(&renderPass);
-    }
-
-    // Using 2D array texture view with arrayLayerCount > 1 is not allowed for depth stencil
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kDepthStencilFormat;
-        descriptor.arrayLayerCount = 5;
-
-        wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        AssertBeginRenderPassError(&renderPass);
-    }
-
-    // Using 2D array texture view that covers the first layer of the texture is OK for color
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kColorFormat;
-        descriptor.baseArrayLayer = 0;
-        descriptor.arrayLayerCount = 1;
-
-        wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({colorTextureView});
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // Using 2D array texture view that covers the first layer is OK for depth stencil
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kDepthStencilFormat;
-        descriptor.baseArrayLayer = 0;
-        descriptor.arrayLayerCount = 1;
-
-        wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // Using 2D array texture view that covers the last layer is OK for color
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kColorFormat;
-        descriptor.baseArrayLayer = kArrayLayers - 1;
-        descriptor.arrayLayerCount = 1;
-
-        wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({colorTextureView});
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // Using 2D array texture view that covers the last layer is OK for depth stencil
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kDepthStencilFormat;
-        descriptor.baseArrayLayer = kArrayLayers - 1;
-        descriptor.arrayLayerCount = 1;
-
-        wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-}
-
-// Only 2D texture views with mipLevelCount == 1 are allowed to be color attachments
-TEST_F(RenderPassDescriptorValidationTest, TextureViewLevelCountForColorAndDepthStencil) {
-    constexpr uint32_t kArrayLayers = 1;
-    constexpr uint32_t kSize = 32;
-    constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
-    constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8;
-
-    constexpr uint32_t kLevelCount = 4;
-
-    wgpu::Texture colorTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat,
-                                               kSize, kSize, kArrayLayers, kLevelCount);
-    wgpu::Texture depthStencilTexture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
-                      kArrayLayers, kLevelCount);
-
-    wgpu::TextureViewDescriptor baseDescriptor;
-    baseDescriptor.dimension = wgpu::TextureViewDimension::e2D;
-    baseDescriptor.baseArrayLayer = 0;
-    baseDescriptor.arrayLayerCount = kArrayLayers;
-    baseDescriptor.baseMipLevel = 0;
-    baseDescriptor.mipLevelCount = kLevelCount;
-
-    // Using 2D texture view with mipLevelCount > 1 is not allowed for color
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kColorFormat;
-        descriptor.mipLevelCount = 2;
-
-        wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({colorTextureView});
-        AssertBeginRenderPassError(&renderPass);
-    }
-
-    // Using 2D texture view with mipLevelCount > 1 is not allowed for depth stencil
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kDepthStencilFormat;
-        descriptor.mipLevelCount = 2;
-
-        wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        AssertBeginRenderPassError(&renderPass);
-    }
-
-    // Using 2D texture view that covers the first level of the texture is OK for color
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kColorFormat;
-        descriptor.baseMipLevel = 0;
-        descriptor.mipLevelCount = 1;
-
-        wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({colorTextureView});
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // Using 2D texture view that covers the first level is OK for depth stencil
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kDepthStencilFormat;
-        descriptor.baseMipLevel = 0;
-        descriptor.mipLevelCount = 1;
-
-        wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // Using 2D texture view that covers the last level is OK for color
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kColorFormat;
-        descriptor.baseMipLevel = kLevelCount - 1;
-        descriptor.mipLevelCount = 1;
-
-        wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({colorTextureView});
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // Using 2D texture view that covers the last level is OK for depth stencil
-    {
-        wgpu::TextureViewDescriptor descriptor = baseDescriptor;
-        descriptor.format = kDepthStencilFormat;
-        descriptor.baseMipLevel = kLevelCount - 1;
-        descriptor.mipLevelCount = 1;
-
-        wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
-        utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-}
-
-// It is not allowed to set resolve target when the color attachment is non-multisampled.
-TEST_F(RenderPassDescriptorValidationTest, NonMultisampledColorWithResolveTarget) {
-    static constexpr uint32_t kArrayLayers = 1;
-    static constexpr uint32_t kLevelCount = 1;
-    static constexpr uint32_t kSize = 32;
-    static constexpr uint32_t kSampleCount = 1;
-    static constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
-
-    wgpu::Texture colorTexture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers,
-                      kLevelCount, kSampleCount);
-    wgpu::Texture resolveTargetTexture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers,
-                      kLevelCount, kSampleCount);
-    wgpu::TextureView colorTextureView = colorTexture.CreateView();
-    wgpu::TextureView resolveTargetTextureView = resolveTargetTexture.CreateView();
-
-    utils::ComboRenderPassDescriptor renderPass({colorTextureView});
-    renderPass.cColorAttachments[0].resolveTarget = resolveTargetTextureView;
-    AssertBeginRenderPassError(&renderPass);
-}
-
-class MultisampledRenderPassDescriptorValidationTest : public RenderPassDescriptorValidationTest {
-  public:
-    utils::ComboRenderPassDescriptor CreateMultisampledRenderPass() {
-        return utils::ComboRenderPassDescriptor({CreateMultisampledColorTextureView()});
-    }
-
-    wgpu::TextureView CreateMultisampledColorTextureView() {
-        return CreateColorTextureView(kSampleCount);
-    }
-
-    wgpu::TextureView CreateNonMultisampledColorTextureView() {
-        return CreateColorTextureView(1);
-    }
-
-    static constexpr uint32_t kArrayLayers = 1;
-    static constexpr uint32_t kLevelCount = 1;
-    static constexpr uint32_t kSize = 32;
-    static constexpr uint32_t kSampleCount = 4;
-    static constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
-
-  private:
-    wgpu::TextureView CreateColorTextureView(uint32_t sampleCount) {
         wgpu::Texture colorTexture =
             CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
-                          kArrayLayers, kLevelCount, sampleCount);
-
-        return colorTexture.CreateView();
-    }
-};
-
-// Tests on the use of multisampled textures as color attachments
-TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorAttachments) {
-    wgpu::TextureView colorTextureView = CreateNonMultisampledColorTextureView();
-    wgpu::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView();
-    wgpu::TextureView multisampledColorTextureView = CreateMultisampledColorTextureView();
-
-    // It is allowed to use a multisampled color attachment without setting resolve target.
-    {
-        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // It is not allowed to use multiple color attachments with different sample counts.
-    {
-        utils::ComboRenderPassDescriptor renderPass(
-            {multisampledColorTextureView, colorTextureView});
-        AssertBeginRenderPassError(&renderPass);
-    }
-}
-
-// It is not allowed to use a multisampled resolve target.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledResolveTarget) {
-    wgpu::TextureView multisampledResolveTargetView = CreateMultisampledColorTextureView();
-
-    utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-    renderPass.cColorAttachments[0].resolveTarget = multisampledResolveTargetView;
-    AssertBeginRenderPassError(&renderPass);
-}
-
-// It is not allowed to use a resolve target with array layer count > 1.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetArrayLayerMoreThanOne) {
-    constexpr uint32_t kArrayLayers2 = 2;
-    wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat,
-                                                 kSize, kSize, kArrayLayers2, kLevelCount);
-    wgpu::TextureView resolveTextureView = resolveTexture.CreateView();
-
-    utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-    renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
-    AssertBeginRenderPassError(&renderPass);
-}
-
-// It is not allowed to use a resolve target with mipmap level count > 1.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetMipmapLevelMoreThanOne) {
-    constexpr uint32_t kLevelCount2 = 2;
-    wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat,
-                                                 kSize, kSize, kArrayLayers, kLevelCount2);
-    wgpu::TextureView resolveTextureView = resolveTexture.CreateView();
-
-    utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-    renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
-    AssertBeginRenderPassError(&renderPass);
-}
-
-// It is not allowed to use a resolve target which is created from a texture whose usage does not
-// include wgpu::TextureUsage::OutputAttachment.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetUsageNoOutputAttachment) {
-    constexpr wgpu::TextureUsage kUsage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
-    wgpu::Texture nonColorUsageResolveTexture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize, kArrayLayers,
-                      kLevelCount, 1, kUsage);
-    wgpu::TextureView nonColorUsageResolveTextureView = nonColorUsageResolveTexture.CreateView();
-
-    utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-    renderPass.cColorAttachments[0].resolveTarget = nonColorUsageResolveTextureView;
-    AssertBeginRenderPassError(&renderPass);
-}
-
-// It is not allowed to use a resolve target which is in error state.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetInErrorState) {
-    wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat,
-                                                 kSize, kSize, kArrayLayers, kLevelCount);
-    wgpu::TextureViewDescriptor errorTextureView;
-    errorTextureView.dimension = wgpu::TextureViewDimension::e2D;
-    errorTextureView.format = kColorFormat;
-    errorTextureView.baseArrayLayer = kArrayLayers + 1;
-    ASSERT_DEVICE_ERROR(wgpu::TextureView errorResolveTarget =
-                            resolveTexture.CreateView(&errorTextureView));
-
-    utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-    renderPass.cColorAttachments[0].resolveTarget = errorResolveTarget;
-    AssertBeginRenderPassError(&renderPass);
-}
-
-// It is allowed to use a multisampled color attachment and a non-multisampled resolve target.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorWithResolveTarget) {
-    wgpu::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView();
-
-    utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-    renderPass.cColorAttachments[0].resolveTarget = resolveTargetTextureView;
-    AssertBeginRenderPassSuccess(&renderPass);
-}
-
-// It is not allowed to use a resolve target in a format different from the color attachment.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetDifferentFormat) {
-    constexpr wgpu::TextureFormat kColorFormat2 = wgpu::TextureFormat::BGRA8Unorm;
-    wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat2,
-                                                 kSize, kSize, kArrayLayers, kLevelCount);
-    wgpu::TextureView resolveTextureView = resolveTexture.CreateView();
-
-    utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-    renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
-    AssertBeginRenderPassError(&renderPass);
-}
-
-// Tests on the size of the resolve target.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, ColorAttachmentResolveTargetCompatibility) {
-    constexpr uint32_t kSize2 = kSize * 2;
-    wgpu::Texture resolveTexture = CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat,
-                                                 kSize2, kSize2, kArrayLayers, kLevelCount + 1);
-
-    wgpu::TextureViewDescriptor textureViewDescriptor;
-    textureViewDescriptor.nextInChain = nullptr;
-    textureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D;
-    textureViewDescriptor.format = kColorFormat;
-    textureViewDescriptor.mipLevelCount = 1;
-    textureViewDescriptor.baseArrayLayer = 0;
-    textureViewDescriptor.arrayLayerCount = 1;
-
-    {
-        wgpu::TextureViewDescriptor firstMipLevelDescriptor = textureViewDescriptor;
-        firstMipLevelDescriptor.baseMipLevel = 0;
-
-        wgpu::TextureView resolveTextureView = resolveTexture.CreateView(&firstMipLevelDescriptor);
-
-        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-        renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
-        AssertBeginRenderPassError(&renderPass);
-    }
-
-    {
-        wgpu::TextureViewDescriptor secondMipLevelDescriptor = textureViewDescriptor;
-        secondMipLevelDescriptor.baseMipLevel = 1;
-
-        wgpu::TextureView resolveTextureView = resolveTexture.CreateView(&secondMipLevelDescriptor);
-
-        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
-        renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-}
-
-// Tests on the sample count of depth stencil attachment.
-TEST_F(MultisampledRenderPassDescriptorValidationTest, DepthStencilAttachmentSampleCount) {
-    constexpr wgpu::TextureFormat kDepthStencilFormat = wgpu::TextureFormat::Depth24PlusStencil8;
-    wgpu::Texture multisampledDepthStencilTexture =
-        CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
-                      kArrayLayers, kLevelCount, kSampleCount);
-    wgpu::TextureView multisampledDepthStencilTextureView =
-        multisampledDepthStencilTexture.CreateView();
-
-    // It is not allowed to use a depth stencil attachment whose sample count is different from the
-    // one of the color attachment.
-    {
+                          kArrayLayers, kLevelCount);
         wgpu::Texture depthStencilTexture =
             CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
                           kArrayLayers, kLevelCount);
-        wgpu::TextureView depthStencilTextureView = depthStencilTexture.CreateView();
 
-        utils::ComboRenderPassDescriptor renderPass(
-            {CreateMultisampledColorTextureView()}, depthStencilTextureView);
+        wgpu::TextureViewDescriptor descriptor;
+        descriptor.dimension = wgpu::TextureViewDimension::e2D;
+        descriptor.baseArrayLayer = 0;
+        descriptor.arrayLayerCount = kArrayLayers;
+        descriptor.baseMipLevel = 0;
+        descriptor.mipLevelCount = kLevelCount;
+        wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
+        wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
+
+        // StoreOps mismatch causing the render pass to error
+        {
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store;
+            renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Clear;
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // StoreOps match so render pass is a success
+        {
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Store;
+            renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Store;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // StoreOps match so render pass is a success
+        {
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            renderPass.cDepthStencilAttachmentInfo.stencilStoreOp = wgpu::StoreOp::Clear;
+            renderPass.cDepthStencilAttachmentInfo.depthStoreOp = wgpu::StoreOp::Clear;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+    }
+
+    // Currently only texture views with arrayLayerCount == 1 are allowed to be color and depth
+    // stencil attachments
+    TEST_F(RenderPassDescriptorValidationTest, TextureViewLayerCountForColorAndDepthStencil) {
+        constexpr uint32_t kLevelCount = 1;
+        constexpr uint32_t kSize = 32;
+        constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
+        constexpr wgpu::TextureFormat kDepthStencilFormat =
+            wgpu::TextureFormat::Depth24PlusStencil8;
+
+        constexpr uint32_t kArrayLayers = 10;
+
+        wgpu::Texture colorTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount);
+        wgpu::Texture depthStencilTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount);
+
+        wgpu::TextureViewDescriptor baseDescriptor;
+        baseDescriptor.dimension = wgpu::TextureViewDimension::e2DArray;
+        baseDescriptor.baseArrayLayer = 0;
+        baseDescriptor.arrayLayerCount = kArrayLayers;
+        baseDescriptor.baseMipLevel = 0;
+        baseDescriptor.mipLevelCount = kLevelCount;
+
+        // Using 2D array texture view with arrayLayerCount > 1 is not allowed for color
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kColorFormat;
+            descriptor.arrayLayerCount = 5;
+
+            wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({colorTextureView});
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // Using 2D array texture view with arrayLayerCount > 1 is not allowed for depth stencil
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kDepthStencilFormat;
+            descriptor.arrayLayerCount = 5;
+
+            wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // Using 2D array texture view that covers the first layer of the texture is OK for color
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kColorFormat;
+            descriptor.baseArrayLayer = 0;
+            descriptor.arrayLayerCount = 1;
+
+            wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({colorTextureView});
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // Using 2D array texture view that covers the first layer is OK for depth stencil
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kDepthStencilFormat;
+            descriptor.baseArrayLayer = 0;
+            descriptor.arrayLayerCount = 1;
+
+            wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // Using 2D array texture view that covers the last layer is OK for color
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kColorFormat;
+            descriptor.baseArrayLayer = kArrayLayers - 1;
+            descriptor.arrayLayerCount = 1;
+
+            wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({colorTextureView});
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // Using 2D array texture view that covers the last layer is OK for depth stencil
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kDepthStencilFormat;
+            descriptor.baseArrayLayer = kArrayLayers - 1;
+            descriptor.arrayLayerCount = 1;
+
+            wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+    }
+
+    // Only 2D texture views with mipLevelCount == 1 are allowed to be color attachments
+    TEST_F(RenderPassDescriptorValidationTest, TextureViewLevelCountForColorAndDepthStencil) {
+        constexpr uint32_t kArrayLayers = 1;
+        constexpr uint32_t kSize = 32;
+        constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
+        constexpr wgpu::TextureFormat kDepthStencilFormat =
+            wgpu::TextureFormat::Depth24PlusStencil8;
+
+        constexpr uint32_t kLevelCount = 4;
+
+        wgpu::Texture colorTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount);
+        wgpu::Texture depthStencilTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount);
+
+        wgpu::TextureViewDescriptor baseDescriptor;
+        baseDescriptor.dimension = wgpu::TextureViewDimension::e2D;
+        baseDescriptor.baseArrayLayer = 0;
+        baseDescriptor.arrayLayerCount = kArrayLayers;
+        baseDescriptor.baseMipLevel = 0;
+        baseDescriptor.mipLevelCount = kLevelCount;
+
+        // Using 2D texture view with mipLevelCount > 1 is not allowed for color
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kColorFormat;
+            descriptor.mipLevelCount = 2;
+
+            wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({colorTextureView});
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // Using 2D texture view with mipLevelCount > 1 is not allowed for depth stencil
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kDepthStencilFormat;
+            descriptor.mipLevelCount = 2;
+
+            wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // Using 2D texture view that covers the first level of the texture is OK for color
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kColorFormat;
+            descriptor.baseMipLevel = 0;
+            descriptor.mipLevelCount = 1;
+
+            wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({colorTextureView});
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // Using 2D texture view that covers the first level is OK for depth stencil
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kDepthStencilFormat;
+            descriptor.baseMipLevel = 0;
+            descriptor.mipLevelCount = 1;
+
+            wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // Using 2D texture view that covers the last level is OK for color
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kColorFormat;
+            descriptor.baseMipLevel = kLevelCount - 1;
+            descriptor.mipLevelCount = 1;
+
+            wgpu::TextureView colorTextureView = colorTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({colorTextureView});
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // Using 2D texture view that covers the last level is OK for depth stencil
+        {
+            wgpu::TextureViewDescriptor descriptor = baseDescriptor;
+            descriptor.format = kDepthStencilFormat;
+            descriptor.baseMipLevel = kLevelCount - 1;
+            descriptor.mipLevelCount = 1;
+
+            wgpu::TextureView depthStencilView = depthStencilTexture.CreateView(&descriptor);
+            utils::ComboRenderPassDescriptor renderPass({}, depthStencilView);
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+    }
+
+    // It is not allowed to set resolve target when the color attachment is non-multisampled.
+    TEST_F(RenderPassDescriptorValidationTest, NonMultisampledColorWithResolveTarget) {
+        static constexpr uint32_t kArrayLayers = 1;
+        static constexpr uint32_t kLevelCount = 1;
+        static constexpr uint32_t kSize = 32;
+        static constexpr uint32_t kSampleCount = 1;
+        static constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
+
+        wgpu::Texture colorTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount, kSampleCount);
+        wgpu::Texture resolveTargetTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount, kSampleCount);
+        wgpu::TextureView colorTextureView = colorTexture.CreateView();
+        wgpu::TextureView resolveTargetTextureView = resolveTargetTexture.CreateView();
+
+        utils::ComboRenderPassDescriptor renderPass({colorTextureView});
+        renderPass.cColorAttachments[0].resolveTarget = resolveTargetTextureView;
         AssertBeginRenderPassError(&renderPass);
     }
 
-    {
-        utils::ComboRenderPassDescriptor renderPass(
-            {CreateNonMultisampledColorTextureView()}, multisampledDepthStencilTextureView);
+    class MultisampledRenderPassDescriptorValidationTest
+        : public RenderPassDescriptorValidationTest {
+      public:
+        utils::ComboRenderPassDescriptor CreateMultisampledRenderPass() {
+            return utils::ComboRenderPassDescriptor({CreateMultisampledColorTextureView()});
+        }
+
+        wgpu::TextureView CreateMultisampledColorTextureView() {
+            return CreateColorTextureView(kSampleCount);
+        }
+
+        wgpu::TextureView CreateNonMultisampledColorTextureView() {
+            return CreateColorTextureView(1);
+        }
+
+        static constexpr uint32_t kArrayLayers = 1;
+        static constexpr uint32_t kLevelCount = 1;
+        static constexpr uint32_t kSize = 32;
+        static constexpr uint32_t kSampleCount = 4;
+        static constexpr wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm;
+
+      private:
+        wgpu::TextureView CreateColorTextureView(uint32_t sampleCount) {
+            wgpu::Texture colorTexture =
+                CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                              kArrayLayers, kLevelCount, sampleCount);
+
+            return colorTexture.CreateView();
+        }
+    };
+
+    // Tests on the use of multisampled textures as color attachments
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorAttachments) {
+        wgpu::TextureView colorTextureView = CreateNonMultisampledColorTextureView();
+        wgpu::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView();
+        wgpu::TextureView multisampledColorTextureView = CreateMultisampledColorTextureView();
+
+        // It is allowed to use a multisampled color attachment without setting resolve target.
+        {
+            utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // It is not allowed to use multiple color attachments with different sample counts.
+        {
+            utils::ComboRenderPassDescriptor renderPass(
+                {multisampledColorTextureView, colorTextureView});
+            AssertBeginRenderPassError(&renderPass);
+        }
+    }
+
+    // It is not allowed to use a multisampled resolve target.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledResolveTarget) {
+        wgpu::TextureView multisampledResolveTargetView = CreateMultisampledColorTextureView();
+
+        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+        renderPass.cColorAttachments[0].resolveTarget = multisampledResolveTargetView;
         AssertBeginRenderPassError(&renderPass);
     }
 
-    // It is allowed to use a multisampled depth stencil attachment whose sample count is equal to
-    // the one of the color attachment.
-    {
-        utils::ComboRenderPassDescriptor renderPass(
-            {CreateMultisampledColorTextureView()}, multisampledDepthStencilTextureView);
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
+    // It is not allowed to use a resolve target with array layer count > 1.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetArrayLayerMoreThanOne) {
+        constexpr uint32_t kArrayLayers2 = 2;
+        wgpu::Texture resolveTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers2, kLevelCount);
+        wgpu::TextureView resolveTextureView = resolveTexture.CreateView();
 
-    // It is allowed to use a multisampled depth stencil attachment while there is no color
-    // attachment.
-    {
-        utils::ComboRenderPassDescriptor renderPass({}, multisampledDepthStencilTextureView);
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-}
-
-// Tests that NaN cannot be accepted as a valid color or depth clear value and INFINITY is valid in
-// both color and depth clear values.
-TEST_F(RenderPassDescriptorValidationTest, UseNaNOrINFINITYAsColorOrDepthClearValue) {
-    wgpu::TextureView color = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
-
-    // Tests that NaN cannot be used in clearColor.
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.r = NAN;
+        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+        renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
         AssertBeginRenderPassError(&renderPass);
     }
 
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.g = NAN;
+    // It is not allowed to use a resolve target with mipmap level count > 1.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetMipmapLevelMoreThanOne) {
+        constexpr uint32_t kLevelCount2 = 2;
+        wgpu::Texture resolveTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount2);
+        wgpu::TextureView resolveTextureView = resolveTexture.CreateView();
+
+        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+        renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
         AssertBeginRenderPassError(&renderPass);
     }
 
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.b = NAN;
+    // It is not allowed to use a resolve target which is created from a texture whose usage does
+    // not include wgpu::TextureUsage::OutputAttachment.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetUsageNoOutputAttachment) {
+        constexpr wgpu::TextureUsage kUsage =
+            wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
+        wgpu::Texture nonColorUsageResolveTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount, 1, kUsage);
+        wgpu::TextureView nonColorUsageResolveTextureView =
+            nonColorUsageResolveTexture.CreateView();
+
+        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+        renderPass.cColorAttachments[0].resolveTarget = nonColorUsageResolveTextureView;
         AssertBeginRenderPassError(&renderPass);
     }
 
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.a = NAN;
+    // It is not allowed to use a resolve target which is in error state.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetInErrorState) {
+        wgpu::Texture resolveTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount);
+        wgpu::TextureViewDescriptor errorTextureView;
+        errorTextureView.dimension = wgpu::TextureViewDimension::e2D;
+        errorTextureView.format = kColorFormat;
+        errorTextureView.baseArrayLayer = kArrayLayers + 1;
+        ASSERT_DEVICE_ERROR(wgpu::TextureView errorResolveTarget =
+                                resolveTexture.CreateView(&errorTextureView));
+
+        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+        renderPass.cColorAttachments[0].resolveTarget = errorResolveTarget;
         AssertBeginRenderPassError(&renderPass);
     }
 
-    // Tests that INFINITY can be used in clearColor.
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.r = INFINITY;
+    // It is allowed to use a multisampled color attachment and a non-multisampled resolve target.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, MultisampledColorWithResolveTarget) {
+        wgpu::TextureView resolveTargetTextureView = CreateNonMultisampledColorTextureView();
+
+        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+        renderPass.cColorAttachments[0].resolveTarget = resolveTargetTextureView;
         AssertBeginRenderPassSuccess(&renderPass);
     }
 
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.g = INFINITY;
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
+    // It is not allowed to use a resolve target in a format different from the color attachment.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, ResolveTargetDifferentFormat) {
+        constexpr wgpu::TextureFormat kColorFormat2 = wgpu::TextureFormat::BGRA8Unorm;
+        wgpu::Texture resolveTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat2, kSize, kSize,
+                          kArrayLayers, kLevelCount);
+        wgpu::TextureView resolveTextureView = resolveTexture.CreateView();
 
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.b = INFINITY;
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    {
-        utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
-        renderPass.cColorAttachments[0].clearColor.a = INFINITY;
-        AssertBeginRenderPassSuccess(&renderPass);
-    }
-
-    // Tests that NaN cannot be used in clearDepth.
-    {
-        wgpu::TextureView depth =
-            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24Plus);
-        utils::ComboRenderPassDescriptor renderPass({color}, depth);
-        renderPass.cDepthStencilAttachmentInfo.clearDepth = NAN;
+        utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+        renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
         AssertBeginRenderPassError(&renderPass);
     }
 
-    // Tests that INFINITY can be used in clearDepth.
-    {
-        wgpu::TextureView depth =
-            Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24Plus);
-        utils::ComboRenderPassDescriptor renderPass({color}, depth);
-        renderPass.cDepthStencilAttachmentInfo.clearDepth = INFINITY;
-        AssertBeginRenderPassSuccess(&renderPass);
+    // Tests on the size of the resolve target.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest,
+           ColorAttachmentResolveTargetCompatibility) {
+        constexpr uint32_t kSize2 = kSize * 2;
+        wgpu::Texture resolveTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kColorFormat, kSize2, kSize2,
+                          kArrayLayers, kLevelCount + 1);
+
+        wgpu::TextureViewDescriptor textureViewDescriptor;
+        textureViewDescriptor.nextInChain = nullptr;
+        textureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D;
+        textureViewDescriptor.format = kColorFormat;
+        textureViewDescriptor.mipLevelCount = 1;
+        textureViewDescriptor.baseArrayLayer = 0;
+        textureViewDescriptor.arrayLayerCount = 1;
+
+        {
+            wgpu::TextureViewDescriptor firstMipLevelDescriptor = textureViewDescriptor;
+            firstMipLevelDescriptor.baseMipLevel = 0;
+
+            wgpu::TextureView resolveTextureView =
+                resolveTexture.CreateView(&firstMipLevelDescriptor);
+
+            utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+            renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        {
+            wgpu::TextureViewDescriptor secondMipLevelDescriptor = textureViewDescriptor;
+            secondMipLevelDescriptor.baseMipLevel = 1;
+
+            wgpu::TextureView resolveTextureView =
+                resolveTexture.CreateView(&secondMipLevelDescriptor);
+
+            utils::ComboRenderPassDescriptor renderPass = CreateMultisampledRenderPass();
+            renderPass.cColorAttachments[0].resolveTarget = resolveTextureView;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
     }
-}
 
-// TODO(cwallez@chromium.org): Constraints on attachment aliasing?
+    // Tests on the sample count of depth stencil attachment.
+    TEST_F(MultisampledRenderPassDescriptorValidationTest, DepthStencilAttachmentSampleCount) {
+        constexpr wgpu::TextureFormat kDepthStencilFormat =
+            wgpu::TextureFormat::Depth24PlusStencil8;
+        wgpu::Texture multisampledDepthStencilTexture =
+            CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize, kSize,
+                          kArrayLayers, kLevelCount, kSampleCount);
+        wgpu::TextureView multisampledDepthStencilTextureView =
+            multisampledDepthStencilTexture.CreateView();
 
-} // anonymous namespace
+        // It is not allowed to use a depth stencil attachment whose sample count is different from
+        // the one of the color attachment.
+        {
+            wgpu::Texture depthStencilTexture =
+                CreateTexture(device, wgpu::TextureDimension::e2D, kDepthStencilFormat, kSize,
+                              kSize, kArrayLayers, kLevelCount);
+            wgpu::TextureView depthStencilTextureView = depthStencilTexture.CreateView();
+
+            utils::ComboRenderPassDescriptor renderPass({CreateMultisampledColorTextureView()},
+                                                        depthStencilTextureView);
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        {
+            utils::ComboRenderPassDescriptor renderPass({CreateNonMultisampledColorTextureView()},
+                                                        multisampledDepthStencilTextureView);
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // It is allowed to use a multisampled depth stencil attachment whose sample count is equal
+        // to the one of the color attachment.
+        {
+            utils::ComboRenderPassDescriptor renderPass({CreateMultisampledColorTextureView()},
+                                                        multisampledDepthStencilTextureView);
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // It is allowed to use a multisampled depth stencil attachment while there is no color
+        // attachment.
+        {
+            utils::ComboRenderPassDescriptor renderPass({}, multisampledDepthStencilTextureView);
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+    }
+
+    // Tests that NaN cannot be accepted as a valid color or depth clear value and INFINITY is valid
+    // in both color and depth clear values.
+    TEST_F(RenderPassDescriptorValidationTest, UseNaNOrINFINITYAsColorOrDepthClearValue) {
+        wgpu::TextureView color = Create2DAttachment(device, 1, 1, wgpu::TextureFormat::RGBA8Unorm);
+
+        // Tests that NaN cannot be used in clearColor.
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.r = NAN;
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.g = NAN;
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.b = NAN;
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.a = NAN;
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // Tests that INFINITY can be used in clearColor.
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.r = INFINITY;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.g = INFINITY;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.b = INFINITY;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        {
+            utils::ComboRenderPassDescriptor renderPass({color}, nullptr);
+            renderPass.cColorAttachments[0].clearColor.a = INFINITY;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+
+        // Tests that NaN cannot be used in clearDepth.
+        {
+            wgpu::TextureView depth =
+                Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24Plus);
+            utils::ComboRenderPassDescriptor renderPass({color}, depth);
+            renderPass.cDepthStencilAttachmentInfo.clearDepth = NAN;
+            AssertBeginRenderPassError(&renderPass);
+        }
+
+        // Tests that INFINITY can be used in clearDepth.
+        {
+            wgpu::TextureView depth =
+                Create2DAttachment(device, 1, 1, wgpu::TextureFormat::Depth24Plus);
+            utils::ComboRenderPassDescriptor renderPass({color}, depth);
+            renderPass.cDepthStencilAttachmentInfo.clearDepth = INFINITY;
+            AssertBeginRenderPassSuccess(&renderPass);
+        }
+    }
+
+    // TODO(cwallez@chromium.org): Constraints on attachment aliasing?
+
+}  // anonymous namespace
diff --git a/src/tests/unittests/validation/RenderPipelineValidationTests.cpp b/src/tests/unittests/validation/RenderPipelineValidationTests.cpp
index 867cd11..19cc817 100644
--- a/src/tests/unittests/validation/RenderPipelineValidationTests.cpp
+++ b/src/tests/unittests/validation/RenderPipelineValidationTests.cpp
@@ -22,26 +22,26 @@
 #include <sstream>
 
 class RenderPipelineValidationTest : public ValidationTest {
-    protected:
-        void SetUp() override {
-            ValidationTest::SetUp();
+  protected:
+    void SetUp() override {
+        ValidationTest::SetUp();
 
-            vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        vsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
                 #version 450
                 void main() {
                     gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
                 })");
 
-            fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
                 #version 450
                 layout(location = 0) out vec4 fragColor;
                 void main() {
                     fragColor = vec4(0.0, 1.0, 0.0, 1.0);
                 })");
-        }
+    }
 
-        wgpu::ShaderModule vsModule;
-        wgpu::ShaderModule fsModule;
+    wgpu::ShaderModule vsModule;
+    wgpu::ShaderModule fsModule;
 };
 
 // Test cases where creation should succeed
diff --git a/src/tests/unittests/validation/ShaderModuleValidationTests.cpp b/src/tests/unittests/validation/ShaderModuleValidationTests.cpp
index bb08ecc..1e570eb 100644
--- a/src/tests/unittests/validation/ShaderModuleValidationTests.cpp
+++ b/src/tests/unittests/validation/ShaderModuleValidationTests.cpp
@@ -20,8 +20,7 @@
 
 #include <sstream>
 
-class ShaderModuleValidationTest : public ValidationTest {
-};
+class ShaderModuleValidationTest : public ValidationTest {};
 
 // Test case with a simpler shader that should successfully be created
 TEST_F(ShaderModuleValidationTest, CreationSuccess) {
@@ -112,8 +111,8 @@
 // Test that it is invalid to create a shader module with no chained descriptor. (It must be
 // WGSL or SPIRV, not empty)
 TEST_F(ShaderModuleValidationTest, NoChainedDescriptor) {
-  wgpu::ShaderModuleDescriptor desc = {};
-  ASSERT_DEVICE_ERROR(device.CreateShaderModule(&desc));
+    wgpu::ShaderModuleDescriptor desc = {};
+    ASSERT_DEVICE_ERROR(device.CreateShaderModule(&desc));
 }
 
 // Test that it is not allowed to use combined texture and sampler.
diff --git a/src/tests/unittests/validation/TextureValidationTests.cpp b/src/tests/unittests/validation/TextureValidationTests.cpp
index c3d9612..52dc159 100644
--- a/src/tests/unittests/validation/TextureValidationTests.cpp
+++ b/src/tests/unittests/validation/TextureValidationTests.cpp
@@ -21,474 +21,476 @@
 
 namespace {
 
-class TextureValidationTest : public ValidationTest {
-  protected:
-    void SetUp() override {
-        queue = device.GetDefaultQueue();
-    }
+    class TextureValidationTest : public ValidationTest {
+      protected:
+        void SetUp() override {
+            queue = device.GetDefaultQueue();
+        }
 
-    wgpu::TextureDescriptor CreateDefaultTextureDescriptor() {
-        wgpu::TextureDescriptor descriptor;
-        descriptor.size.width = kWidth;
-        descriptor.size.height = kHeight;
-        descriptor.size.depth = kDefaultDepth;
-        descriptor.mipLevelCount = kDefaultMipLevels;
-        descriptor.sampleCount = kDefaultSampleCount;
-        descriptor.dimension = wgpu::TextureDimension::e2D;
-        descriptor.format = kDefaultTextureFormat;
-        descriptor.usage = wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::Sampled;
-        return descriptor;
-    }
+        wgpu::TextureDescriptor CreateDefaultTextureDescriptor() {
+            wgpu::TextureDescriptor descriptor;
+            descriptor.size.width = kWidth;
+            descriptor.size.height = kHeight;
+            descriptor.size.depth = kDefaultDepth;
+            descriptor.mipLevelCount = kDefaultMipLevels;
+            descriptor.sampleCount = kDefaultSampleCount;
+            descriptor.dimension = wgpu::TextureDimension::e2D;
+            descriptor.format = kDefaultTextureFormat;
+            descriptor.usage = wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::Sampled;
+            return descriptor;
+        }
 
-    wgpu::Queue queue;
+        wgpu::Queue queue;
 
-  private:
-    static constexpr uint32_t kWidth = 32;
-    static constexpr uint32_t kHeight = 32;
-    static constexpr uint32_t kDefaultDepth = 1;
-    static constexpr uint32_t kDefaultMipLevels = 1;
-    static constexpr uint32_t kDefaultSampleCount = 1;
+      private:
+        static constexpr uint32_t kWidth = 32;
+        static constexpr uint32_t kHeight = 32;
+        static constexpr uint32_t kDefaultDepth = 1;
+        static constexpr uint32_t kDefaultMipLevels = 1;
+        static constexpr uint32_t kDefaultSampleCount = 1;
 
-    static constexpr wgpu::TextureFormat kDefaultTextureFormat = wgpu::TextureFormat::RGBA8Unorm;
-};
-
-// Test the validation of sample count
-TEST_F(TextureValidationTest, SampleCount) {
-    wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
-
-    // sampleCount == 1 is allowed.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.sampleCount = 1;
-
-        device.CreateTexture(&descriptor);
-    }
-
-    // sampleCount == 4 is allowed.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.sampleCount = 4;
-
-        device.CreateTexture(&descriptor);
-    }
-
-    // It is an error to create a texture with an invalid sampleCount.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.sampleCount = 3;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // It is an error to create a multisampled texture with mipLevelCount > 1.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.sampleCount = 4;
-        descriptor.mipLevelCount = 2;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // Currently we do not support multisampled 2D array textures.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.sampleCount = 4;
-        descriptor.size.depth = 2;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // It is an error to set TextureUsage::Storage when sampleCount > 1.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.sampleCount = 4;
-        descriptor.usage |= wgpu::TextureUsage::Storage;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-}
-
-// Test the validation of the mip level count
-TEST_F(TextureValidationTest, MipLevelCount) {
-    wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
-
-    // mipLevelCount == 1 is allowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 32;
-        descriptor.size.height = 32;
-        descriptor.mipLevelCount = 1;
-
-        device.CreateTexture(&descriptor);
-    }
-
-    // mipLevelCount == 0 is an error
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 32;
-        descriptor.size.height = 32;
-        descriptor.mipLevelCount = 0;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // Full mip chains are allowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 32;
-        descriptor.size.height = 32;
-        // Mip level sizes: 32, 16, 8, 4, 2, 1
-        descriptor.mipLevelCount = 6;
-
-        device.CreateTexture(&descriptor);
-    }
-
-    // Too big mip chains on width are disallowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 31;
-        descriptor.size.height = 32;
-        // Mip level width: 31, 15, 7, 3, 1, 1
-        descriptor.mipLevelCount = 7;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // Too big mip chains on height are disallowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 32;
-        descriptor.size.height = 31;
-        // Mip level height: 31, 15, 7, 3, 1, 1
-        descriptor.mipLevelCount = 7;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // Undefined shift check if miplevel is bigger than the integer bit width.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 32;
-        descriptor.size.height = 32;
-        descriptor.mipLevelCount = 100;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // Non square mip map halves the resolution until a 1x1 dimension.
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 32;
-        descriptor.size.height = 8;
-        // Mip maps: 32 * 8, 16 * 4, 8 * 2, 4 * 1, 2 * 1, 1 * 1
-        descriptor.mipLevelCount = 6;
-
-        device.CreateTexture(&descriptor);
-    }
-
-    // Mip level exceeding kMaxTexture2DMipLevels not allowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = 1 >> kMaxTexture2DMipLevels;
-        descriptor.size.height = 1 >> kMaxTexture2DMipLevels;
-        descriptor.mipLevelCount = kMaxTexture2DMipLevels + 1u;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-}
-// Test the validation of array layer count
-TEST_F(TextureValidationTest, ArrayLayerCount) {
-    wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
-
-    // Array layer count exceeding kMaxTexture2DArrayLayers is not allowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.depth = kMaxTexture2DArrayLayers + 1u;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // Array layer count less than kMaxTexture2DArrayLayers is allowed;
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.depth = kMaxTexture2DArrayLayers >> 1;
-
-        device.CreateTexture(&descriptor);
-    }
-
-    // Array layer count equal to kMaxTexture2DArrayLayers is allowed;
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.depth = kMaxTexture2DArrayLayers;
-
-        device.CreateTexture(&descriptor);
-    }
-}
-
-// Test the validation of texture size
-TEST_F(TextureValidationTest, TextureSize) {
-    wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
-
-    // Texture size exceeding kMaxTextureSize is not allowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = kMaxTextureSize + 1u;
-        descriptor.size.height = kMaxTextureSize + 1u;
-
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-
-    // Texture size less than kMaxTextureSize is allowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = kMaxTextureSize >> 1;
-        descriptor.size.height = kMaxTextureSize >> 1;
-
-        device.CreateTexture(&descriptor);
-    }
-
-    // Texture equal to kMaxTextureSize is allowed
-    {
-        wgpu::TextureDescriptor descriptor = defaultDescriptor;
-        descriptor.size.width = kMaxTextureSize;
-        descriptor.size.height = kMaxTextureSize;
-
-        device.CreateTexture(&descriptor);
-    }
-}
-
-// Test that it is valid to destroy a texture
-TEST_F(TextureValidationTest, DestroyTexture) {
-    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-    wgpu::Texture texture = device.CreateTexture(&descriptor);
-    texture.Destroy();
-}
-
-// Test that it's valid to destroy a destroyed texture
-TEST_F(TextureValidationTest, DestroyDestroyedTexture) {
-    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-    wgpu::Texture texture = device.CreateTexture(&descriptor);
-    texture.Destroy();
-    texture.Destroy();
-}
-
-// Test that it's invalid to submit a destroyed texture in a queue
-// in the case of destroy, encode, submit
-TEST_F(TextureValidationTest, DestroyEncodeSubmit) {
-    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-    wgpu::Texture texture = device.CreateTexture(&descriptor);
-    wgpu::TextureView textureView = texture.CreateView();
-
-    utils::ComboRenderPassDescriptor renderPass({textureView});
-
-    // Destroy the texture
-    texture.Destroy();
-
-    wgpu::CommandEncoder encoder_post_destroy = device.CreateCommandEncoder();
-    {
-        wgpu::RenderPassEncoder pass = encoder_post_destroy.BeginRenderPass(&renderPass);
-        pass.EndPass();
-    }
-    wgpu::CommandBuffer commands = encoder_post_destroy.Finish();
-
-    // Submit should fail due to destroyed texture
-    ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
-}
-
-// Test that it's invalid to submit a destroyed texture in a queue
-// in the case of encode, destroy, submit
-TEST_F(TextureValidationTest, EncodeDestroySubmit) {
-    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-    wgpu::Texture texture = device.CreateTexture(&descriptor);
-    wgpu::TextureView textureView = texture.CreateView();
-
-    utils::ComboRenderPassDescriptor renderPass({textureView});
-
-    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    {
-        wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
-        pass.EndPass();
-    }
-    wgpu::CommandBuffer commands = encoder.Finish();
-
-    // Destroy the texture
-    texture.Destroy();
-
-    // Submit should fail due to destroyed texture
-    ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
-}
-
-// Test it is an error to create an OutputAttachment texture with a non-renderable format.
-TEST_F(TextureValidationTest, NonRenderableAndOutputAttachment) {
-    wgpu::TextureDescriptor descriptor;
-    descriptor.size = {1, 1, 1};
-    descriptor.usage = wgpu::TextureUsage::OutputAttachment;
-
-    // Succeeds because RGBA8Unorm is renderable
-    descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
-    device.CreateTexture(&descriptor);
-
-    wgpu::TextureFormat nonRenderableFormats[] = {
-        wgpu::TextureFormat::RG11B10Float,
-        wgpu::TextureFormat::R8Snorm,
-        wgpu::TextureFormat::RG8Snorm,
-        wgpu::TextureFormat::RGBA8Snorm,
+        static constexpr wgpu::TextureFormat kDefaultTextureFormat =
+            wgpu::TextureFormat::RGBA8Unorm;
     };
 
-    for (wgpu::TextureFormat format : nonRenderableFormats) {
-        // Fails because `format` is non-renderable
-        descriptor.format = format;
-        ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-    }
-}
+    // Test the validation of sample count
+    TEST_F(TextureValidationTest, SampleCount) {
+        wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
 
-// Test it is an error to create a Storage texture with any format that doesn't support
-// TextureUsage::Storage texture usages.
-TEST_F(TextureValidationTest, TextureFormatNotSupportTextureUsageStorage) {
-    wgpu::TextureDescriptor descriptor;
-    descriptor.size = {1, 1, 1};
-    descriptor.usage = wgpu::TextureUsage::Storage;
-
-    for (wgpu::TextureFormat format : utils::kAllTextureFormats) {
-        descriptor.format = format;
-        if (utils::TextureFormatSupportsStorageTexture(format)) {
-            device.CreateTexture(&descriptor);
-        } else {
-            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-        }
-    }
-}
-
-// Test it is an error to create a texture with format "Undefined".
-TEST_F(TextureValidationTest, TextureFormatUndefined) {
-    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-    descriptor.format = wgpu::TextureFormat::Undefined;
-    ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
-}
-
-// TODO(jiawei.shao@intel.com): add tests to verify we cannot create 1D or 3D textures with
-// compressed texture formats.
-class CompressedTextureFormatsValidationTests : public TextureValidationTest {
-  public:
-    CompressedTextureFormatsValidationTests() : TextureValidationTest() {
-        device = CreateDeviceFromAdapter(adapter, {"texture_compression_bc"});
-    }
-
-  protected:
-    wgpu::TextureDescriptor CreateDefaultTextureDescriptor() {
-        wgpu::TextureDescriptor descriptor =
-            TextureValidationTest::CreateDefaultTextureDescriptor();
-        descriptor.usage =
-            wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::Sampled;
-        return descriptor;
-    }
-
-    const std::array<wgpu::TextureFormat, 14> kBCFormats = {
-        wgpu::TextureFormat::BC1RGBAUnorm,  wgpu::TextureFormat::BC1RGBAUnormSrgb,
-        wgpu::TextureFormat::BC2RGBAUnorm,  wgpu::TextureFormat::BC2RGBAUnormSrgb,
-        wgpu::TextureFormat::BC3RGBAUnorm,  wgpu::TextureFormat::BC3RGBAUnormSrgb,
-        wgpu::TextureFormat::BC4RUnorm,     wgpu::TextureFormat::BC4RSnorm,
-        wgpu::TextureFormat::BC5RGUnorm,    wgpu::TextureFormat::BC5RGSnorm,
-        wgpu::TextureFormat::BC6HRGBUfloat, wgpu::TextureFormat::BC6HRGBSfloat,
-        wgpu::TextureFormat::BC7RGBAUnorm,  wgpu::TextureFormat::BC7RGBAUnormSrgb};
-};
-
-// Test the validation of texture size when creating textures in compressed texture formats.
-TEST_F(CompressedTextureFormatsValidationTests, TextureSize) {
-    // Test that it is invalid to use a number that is not a multiple of 4 (the compressed block
-    // width and height of all BC formats) as the width or height of textures in BC formats.
-    for (wgpu::TextureFormat format : kBCFormats) {
+        // sampleCount == 1 is allowed.
         {
-            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-            descriptor.format = format;
-            ASSERT_TRUE(descriptor.size.width % 4 == 0 && descriptor.size.height % 4 == 0);
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.sampleCount = 1;
+
             device.CreateTexture(&descriptor);
         }
 
+        // sampleCount == 4 is allowed.
         {
-            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-            descriptor.format = format;
-            descriptor.size.width = 31;
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.sampleCount = 4;
+
+            device.CreateTexture(&descriptor);
+        }
+
+        // It is an error to create a texture with an invalid sampleCount.
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.sampleCount = 3;
+
             ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
         }
 
+        // It is an error to create a multisampled texture with mipLevelCount > 1.
         {
-            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-            descriptor.format = format;
-            descriptor.size.height = 31;
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.sampleCount = 4;
+            descriptor.mipLevelCount = 2;
+
             ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
         }
 
+        // Currently we do not support multisampled 2D array textures.
         {
-            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-            descriptor.format = format;
-            descriptor.size.width = 12;
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.sampleCount = 4;
+            descriptor.size.depth = 2;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+
+        // It is an error to set TextureUsage::Storage when sampleCount > 1.
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.sampleCount = 4;
+            descriptor.usage |= wgpu::TextureUsage::Storage;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+    }
+
+    // Test the validation of the mip level count
+    TEST_F(TextureValidationTest, MipLevelCount) {
+        wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
+
+        // mipLevelCount == 1 is allowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 32;
             descriptor.size.height = 32;
+            descriptor.mipLevelCount = 1;
+
+            device.CreateTexture(&descriptor);
+        }
+
+        // mipLevelCount == 0 is an error
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 32;
+            descriptor.size.height = 32;
+            descriptor.mipLevelCount = 0;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+
+        // Full mip chains are allowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 32;
+            descriptor.size.height = 32;
+            // Mip level sizes: 32, 16, 8, 4, 2, 1
+            descriptor.mipLevelCount = 6;
+
+            device.CreateTexture(&descriptor);
+        }
+
+        // Too big mip chains on width are disallowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 31;
+            descriptor.size.height = 32;
+            // Mip level width: 31, 15, 7, 3, 1, 1
+            descriptor.mipLevelCount = 7;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+
+        // Too big mip chains on height are disallowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 32;
+            descriptor.size.height = 31;
+            // Mip level height: 31, 15, 7, 3, 1, 1
+            descriptor.mipLevelCount = 7;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+
+        // Undefined shift check if miplevel is bigger than the integer bit width.
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 32;
+            descriptor.size.height = 32;
+            descriptor.mipLevelCount = 100;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+
+        // Non square mip map halves the resolution until a 1x1 dimension.
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 32;
+            descriptor.size.height = 8;
+            // Mip maps: 32 * 8, 16 * 4, 8 * 2, 4 * 1, 2 * 1, 1 * 1
+            descriptor.mipLevelCount = 6;
+
+            device.CreateTexture(&descriptor);
+        }
+
+        // Mip level exceeding kMaxTexture2DMipLevels not allowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = 1 >> kMaxTexture2DMipLevels;
+            descriptor.size.height = 1 >> kMaxTexture2DMipLevels;
+            descriptor.mipLevelCount = kMaxTexture2DMipLevels + 1u;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+    }
+    // Test the validation of array layer count
+    TEST_F(TextureValidationTest, ArrayLayerCount) {
+        wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
+
+        // Array layer count exceeding kMaxTexture2DArrayLayers is not allowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.depth = kMaxTexture2DArrayLayers + 1u;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+
+        // Array layer count less than kMaxTexture2DArrayLayers is allowed;
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.depth = kMaxTexture2DArrayLayers >> 1;
+
+            device.CreateTexture(&descriptor);
+        }
+
+        // Array layer count equal to kMaxTexture2DArrayLayers is allowed;
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.depth = kMaxTexture2DArrayLayers;
+
             device.CreateTexture(&descriptor);
         }
     }
-}
 
-// Test the creation of a texture with BC format will fail when the extension textureCompressionBC
-// is not enabled.
-TEST_F(CompressedTextureFormatsValidationTests, UseBCFormatWithoutEnablingExtension) {
-    const std::vector<const char*> kEmptyVector;
-    wgpu::Device deviceWithoutExtension = CreateDeviceFromAdapter(adapter, kEmptyVector);
-    for (wgpu::TextureFormat format : kBCFormats) {
-        wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-        descriptor.format = format;
-        ASSERT_DEVICE_ERROR(deviceWithoutExtension.CreateTexture(&descriptor));
+    // Test the validation of texture size
+    TEST_F(TextureValidationTest, TextureSize) {
+        wgpu::TextureDescriptor defaultDescriptor = CreateDefaultTextureDescriptor();
+
+        // Texture size exceeding kMaxTextureSize is not allowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = kMaxTextureSize + 1u;
+            descriptor.size.height = kMaxTextureSize + 1u;
+
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+
+        // Texture size less than kMaxTextureSize is allowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = kMaxTextureSize >> 1;
+            descriptor.size.height = kMaxTextureSize >> 1;
+
+            device.CreateTexture(&descriptor);
+        }
+
+        // Texture equal to kMaxTextureSize is allowed
+        {
+            wgpu::TextureDescriptor descriptor = defaultDescriptor;
+            descriptor.size.width = kMaxTextureSize;
+            descriptor.size.height = kMaxTextureSize;
+
+            device.CreateTexture(&descriptor);
+        }
     }
-}
 
-// Test the validation of texture usages when creating textures in compressed texture formats.
-TEST_F(CompressedTextureFormatsValidationTests, TextureUsage) {
-    // Test that only CopySrc, CopyDst and Sampled are accepted as the texture usage of the
-    // textures in BC formats.
-    for (wgpu::TextureFormat format : kBCFormats) {
+    // Test that it is valid to destroy a texture
+    TEST_F(TextureValidationTest, DestroyTexture) {
+        wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+        wgpu::Texture texture = device.CreateTexture(&descriptor);
+        texture.Destroy();
+    }
+
+    // Test that it's valid to destroy a destroyed texture
+    TEST_F(TextureValidationTest, DestroyDestroyedTexture) {
+        wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+        wgpu::Texture texture = device.CreateTexture(&descriptor);
+        texture.Destroy();
+        texture.Destroy();
+    }
+
+    // Test that it's invalid to submit a destroyed texture in a queue
+    // in the case of destroy, encode, submit
+    TEST_F(TextureValidationTest, DestroyEncodeSubmit) {
+        wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+        wgpu::Texture texture = device.CreateTexture(&descriptor);
+        wgpu::TextureView textureView = texture.CreateView();
+
+        utils::ComboRenderPassDescriptor renderPass({textureView});
+
+        // Destroy the texture
+        texture.Destroy();
+
+        wgpu::CommandEncoder encoder_post_destroy = device.CreateCommandEncoder();
         {
-            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-            descriptor.format = format;
-            descriptor.usage = wgpu::TextureUsage::OutputAttachment;
-            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            wgpu::RenderPassEncoder pass = encoder_post_destroy.BeginRenderPass(&renderPass);
+            pass.EndPass();
         }
+        wgpu::CommandBuffer commands = encoder_post_destroy.Finish();
 
+        // Submit should fail due to destroyed texture
+        ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
+    }
+
+    // Test that it's invalid to submit a destroyed texture in a queue
+    // in the case of encode, destroy, submit
+    TEST_F(TextureValidationTest, EncodeDestroySubmit) {
+        wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+        wgpu::Texture texture = device.CreateTexture(&descriptor);
+        wgpu::TextureView textureView = texture.CreateView();
+
+        utils::ComboRenderPassDescriptor renderPass({textureView});
+
+        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         {
-            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-            descriptor.format = format;
-            descriptor.usage = wgpu::TextureUsage::Storage;
-            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
+            pass.EndPass();
         }
+        wgpu::CommandBuffer commands = encoder.Finish();
 
-        {
-            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+        // Destroy the texture
+        texture.Destroy();
+
+        // Submit should fail due to destroyed texture
+        ASSERT_DEVICE_ERROR(queue.Submit(1, &commands));
+    }
+
+    // Test it is an error to create an OutputAttachment texture with a non-renderable format.
+    TEST_F(TextureValidationTest, NonRenderableAndOutputAttachment) {
+        wgpu::TextureDescriptor descriptor;
+        descriptor.size = {1, 1, 1};
+        descriptor.usage = wgpu::TextureUsage::OutputAttachment;
+
+        // Succeeds because RGBA8Unorm is renderable
+        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
+        device.CreateTexture(&descriptor);
+
+        wgpu::TextureFormat nonRenderableFormats[] = {
+            wgpu::TextureFormat::RG11B10Float,
+            wgpu::TextureFormat::R8Snorm,
+            wgpu::TextureFormat::RG8Snorm,
+            wgpu::TextureFormat::RGBA8Snorm,
+        };
+
+        for (wgpu::TextureFormat format : nonRenderableFormats) {
+            // Fails because `format` is non-renderable
             descriptor.format = format;
-            descriptor.usage = wgpu::TextureUsage::Present;
             ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
         }
     }
-}
 
-// Test the validation of sample count when creating textures in compressed texture formats.
-TEST_F(CompressedTextureFormatsValidationTests, SampleCount) {
-    // Test that it is invalid to specify SampleCount > 1 when we create a texture in BC formats.
-    for (wgpu::TextureFormat format : kBCFormats) {
+    // Test it is an error to create a Storage texture with any format that doesn't support
+    // TextureUsage::Storage texture usages.
+    TEST_F(TextureValidationTest, TextureFormatNotSupportTextureUsageStorage) {
+        wgpu::TextureDescriptor descriptor;
+        descriptor.size = {1, 1, 1};
+        descriptor.usage = wgpu::TextureUsage::Storage;
+
+        for (wgpu::TextureFormat format : utils::kAllTextureFormats) {
+            descriptor.format = format;
+            if (utils::TextureFormatSupportsStorageTexture(format)) {
+                device.CreateTexture(&descriptor);
+            } else {
+                ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            }
+        }
+    }
+
+    // Test it is an error to create a texture with format "Undefined".
+    TEST_F(TextureValidationTest, TextureFormatUndefined) {
         wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-        descriptor.format = format;
-        descriptor.sampleCount = 4;
+        descriptor.format = wgpu::TextureFormat::Undefined;
         ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
     }
-}
 
-// Test the validation of creating 2D array textures in compressed texture formats.
-TEST_F(CompressedTextureFormatsValidationTests, 2DArrayTexture) {
-    // Test that it is allowed to create a 2D array texture in BC formats.
-    for (wgpu::TextureFormat format : kBCFormats) {
-        wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
-        descriptor.format = format;
-        descriptor.size.depth = 6;
-        device.CreateTexture(&descriptor);
+    // TODO(jiawei.shao@intel.com): add tests to verify we cannot create 1D or 3D textures with
+    // compressed texture formats.
+    class CompressedTextureFormatsValidationTests : public TextureValidationTest {
+      public:
+        CompressedTextureFormatsValidationTests() : TextureValidationTest() {
+            device = CreateDeviceFromAdapter(adapter, {"texture_compression_bc"});
+        }
+
+      protected:
+        wgpu::TextureDescriptor CreateDefaultTextureDescriptor() {
+            wgpu::TextureDescriptor descriptor =
+                TextureValidationTest::CreateDefaultTextureDescriptor();
+            descriptor.usage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst |
+                               wgpu::TextureUsage::Sampled;
+            return descriptor;
+        }
+
+        const std::array<wgpu::TextureFormat, 14> kBCFormats = {
+            wgpu::TextureFormat::BC1RGBAUnorm,  wgpu::TextureFormat::BC1RGBAUnormSrgb,
+            wgpu::TextureFormat::BC2RGBAUnorm,  wgpu::TextureFormat::BC2RGBAUnormSrgb,
+            wgpu::TextureFormat::BC3RGBAUnorm,  wgpu::TextureFormat::BC3RGBAUnormSrgb,
+            wgpu::TextureFormat::BC4RUnorm,     wgpu::TextureFormat::BC4RSnorm,
+            wgpu::TextureFormat::BC5RGUnorm,    wgpu::TextureFormat::BC5RGSnorm,
+            wgpu::TextureFormat::BC6HRGBUfloat, wgpu::TextureFormat::BC6HRGBSfloat,
+            wgpu::TextureFormat::BC7RGBAUnorm,  wgpu::TextureFormat::BC7RGBAUnormSrgb};
+    };
+
+    // Test the validation of texture size when creating textures in compressed texture formats.
+    TEST_F(CompressedTextureFormatsValidationTests, TextureSize) {
+        // Test that it is invalid to use a number that is not a multiple of 4 (the compressed block
+        // width and height of all BC formats) as the width or height of textures in BC formats.
+        for (wgpu::TextureFormat format : kBCFormats) {
+            {
+                wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+                descriptor.format = format;
+                ASSERT_TRUE(descriptor.size.width % 4 == 0 && descriptor.size.height % 4 == 0);
+                device.CreateTexture(&descriptor);
+            }
+
+            {
+                wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+                descriptor.format = format;
+                descriptor.size.width = 31;
+                ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            }
+
+            {
+                wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+                descriptor.format = format;
+                descriptor.size.height = 31;
+                ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            }
+
+            {
+                wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+                descriptor.format = format;
+                descriptor.size.width = 12;
+                descriptor.size.height = 32;
+                device.CreateTexture(&descriptor);
+            }
+        }
     }
-}
+
+    // Test the creation of a texture with BC format will fail when the extension
+    // textureCompressionBC is not enabled.
+    TEST_F(CompressedTextureFormatsValidationTests, UseBCFormatWithoutEnablingExtension) {
+        const std::vector<const char*> kEmptyVector;
+        wgpu::Device deviceWithoutExtension = CreateDeviceFromAdapter(adapter, kEmptyVector);
+        for (wgpu::TextureFormat format : kBCFormats) {
+            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+            descriptor.format = format;
+            ASSERT_DEVICE_ERROR(deviceWithoutExtension.CreateTexture(&descriptor));
+        }
+    }
+
+    // Test the validation of texture usages when creating textures in compressed texture formats.
+    TEST_F(CompressedTextureFormatsValidationTests, TextureUsage) {
+        // Test that only CopySrc, CopyDst and Sampled are accepted as the texture usage of the
+        // textures in BC formats.
+        for (wgpu::TextureFormat format : kBCFormats) {
+            {
+                wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+                descriptor.format = format;
+                descriptor.usage = wgpu::TextureUsage::OutputAttachment;
+                ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            }
+
+            {
+                wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+                descriptor.format = format;
+                descriptor.usage = wgpu::TextureUsage::Storage;
+                ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            }
+
+            {
+                wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+                descriptor.format = format;
+                descriptor.usage = wgpu::TextureUsage::Present;
+                ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+            }
+        }
+    }
+
+    // Test the validation of sample count when creating textures in compressed texture formats.
+    TEST_F(CompressedTextureFormatsValidationTests, SampleCount) {
+        // Test that it is invalid to specify SampleCount > 1 when we create a texture in BC
+        // formats.
+        for (wgpu::TextureFormat format : kBCFormats) {
+            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+            descriptor.format = format;
+            descriptor.sampleCount = 4;
+            ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
+        }
+    }
+
+    // Test the validation of creating 2D array textures in compressed texture formats.
+    TEST_F(CompressedTextureFormatsValidationTests, 2DArrayTexture) {
+        // Test that it is allowed to create a 2D array texture in BC formats.
+        for (wgpu::TextureFormat format : kBCFormats) {
+            wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+            descriptor.format = format;
+            descriptor.size.depth = 6;
+            device.CreateTexture(&descriptor);
+        }
+    }
 
 }  // namespace
diff --git a/src/tests/unittests/validation/TextureViewValidationTests.cpp b/src/tests/unittests/validation/TextureViewValidationTests.cpp
index 32bf7a3..c5c3242 100644
--- a/src/tests/unittests/validation/TextureViewValidationTests.cpp
+++ b/src/tests/unittests/validation/TextureViewValidationTests.cpp
@@ -16,349 +16,348 @@
 
 namespace {
 
-class TextureViewValidationTest : public ValidationTest {
-};
+    class TextureViewValidationTest : public ValidationTest {};
 
-constexpr uint32_t kWidth = 32u;
-constexpr uint32_t kHeight = 32u;
-constexpr uint32_t kDefaultMipLevels = 6u;
+    constexpr uint32_t kWidth = 32u;
+    constexpr uint32_t kHeight = 32u;
+    constexpr uint32_t kDefaultMipLevels = 6u;
 
-constexpr wgpu::TextureFormat kDefaultTextureFormat = wgpu::TextureFormat::RGBA8Unorm;
+    constexpr wgpu::TextureFormat kDefaultTextureFormat = wgpu::TextureFormat::RGBA8Unorm;
 
-wgpu::Texture Create2DArrayTexture(wgpu::Device& device,
-                                   uint32_t arrayLayerCount,
-                                   uint32_t width = kWidth,
-                                   uint32_t height = kHeight,
-                                   uint32_t mipLevelCount = kDefaultMipLevels,
-                                   uint32_t sampleCount = 1) {
-    wgpu::TextureDescriptor descriptor;
-    descriptor.dimension = wgpu::TextureDimension::e2D;
-    descriptor.size.width = width;
-    descriptor.size.height = height;
-    descriptor.size.depth = arrayLayerCount;
-    descriptor.sampleCount = sampleCount;
-    descriptor.format = kDefaultTextureFormat;
-    descriptor.mipLevelCount = mipLevelCount;
-    descriptor.usage = wgpu::TextureUsage::Sampled;
-    return device.CreateTexture(&descriptor);
-}
-
-wgpu::TextureViewDescriptor CreateDefaultViewDescriptor(wgpu::TextureViewDimension dimension) {
-    wgpu::TextureViewDescriptor descriptor;
-    descriptor.format = kDefaultTextureFormat;
-    descriptor.dimension = dimension;
-    descriptor.baseMipLevel = 0;
-    descriptor.mipLevelCount = kDefaultMipLevels;
-    descriptor.baseArrayLayer = 0;
-    descriptor.arrayLayerCount = 1;
-    return descriptor;
-}
-
-// Test creating texture view on a 2D non-array texture
-TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2D) {
-    wgpu::Texture texture = Create2DArrayTexture(device, 1);
-
-    wgpu::TextureViewDescriptor base2DTextureViewDescriptor =
-        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);
-
-    // It is OK to create a 2D texture view on a 2D texture.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
-        descriptor.arrayLayerCount = 1;
-        texture.CreateView(&descriptor);
+    wgpu::Texture Create2DArrayTexture(wgpu::Device& device,
+                                       uint32_t arrayLayerCount,
+                                       uint32_t width = kWidth,
+                                       uint32_t height = kHeight,
+                                       uint32_t mipLevelCount = kDefaultMipLevels,
+                                       uint32_t sampleCount = 1) {
+        wgpu::TextureDescriptor descriptor;
+        descriptor.dimension = wgpu::TextureDimension::e2D;
+        descriptor.size.width = width;
+        descriptor.size.height = height;
+        descriptor.size.depth = arrayLayerCount;
+        descriptor.sampleCount = sampleCount;
+        descriptor.format = kDefaultTextureFormat;
+        descriptor.mipLevelCount = mipLevelCount;
+        descriptor.usage = wgpu::TextureUsage::Sampled;
+        return device.CreateTexture(&descriptor);
     }
 
-    // It is an error to view a layer past the end of the texture.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
-        descriptor.arrayLayerCount = 2;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-
-    // It is OK to create a 1-layer 2D array texture view on a 2D texture.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
-        descriptor.arrayLayerCount = 1;
-        texture.CreateView(&descriptor);
-    }
-
-    // baseMipLevel == k && mipLevelCount == 0 means to use levels k..end.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
-        descriptor.mipLevelCount = 0;
-
+    wgpu::TextureViewDescriptor CreateDefaultViewDescriptor(wgpu::TextureViewDimension dimension) {
+        wgpu::TextureViewDescriptor descriptor;
+        descriptor.format = kDefaultTextureFormat;
+        descriptor.dimension = dimension;
         descriptor.baseMipLevel = 0;
-        texture.CreateView(&descriptor);
-        descriptor.baseMipLevel = 1;
-        texture.CreateView(&descriptor);
-        descriptor.baseMipLevel = kDefaultMipLevels - 1;
-        texture.CreateView(&descriptor);
-        descriptor.baseMipLevel = kDefaultMipLevels;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-
-    // It is an error to make the mip level out of range.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
-        descriptor.baseMipLevel = 0;
-        descriptor.mipLevelCount = kDefaultMipLevels + 1;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-        descriptor.baseMipLevel = 1;
         descriptor.mipLevelCount = kDefaultMipLevels;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-        descriptor.baseMipLevel = kDefaultMipLevels - 1;
-        descriptor.mipLevelCount = 2;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-        descriptor.baseMipLevel = kDefaultMipLevels;
-        descriptor.mipLevelCount = 1;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-}
-
-// Test creating texture view on a 2D array texture
-TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2DArray) {
-    constexpr uint32_t kDefaultArrayLayers = 6;
-
-    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
-
-    wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor =
-        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray);
-
-    // It is OK to create a 2D texture view on a 2D array texture.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::e2D;
-        descriptor.arrayLayerCount = 1;
-        texture.CreateView(&descriptor);
-    }
-
-    // It is OK to create a 2D array texture view on a 2D array texture.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.arrayLayerCount = kDefaultArrayLayers;
-        texture.CreateView(&descriptor);
-    }
-
-    // baseArrayLayer == k && arrayLayerCount == 0 means to use layers k..end.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.arrayLayerCount = 0;
-
         descriptor.baseArrayLayer = 0;
-        texture.CreateView(&descriptor);
-        descriptor.baseArrayLayer = 1;
-        texture.CreateView(&descriptor);
-        descriptor.baseArrayLayer = kDefaultArrayLayers - 1;
-        texture.CreateView(&descriptor);
-        descriptor.baseArrayLayer = kDefaultArrayLayers;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-
-    // It is an error for the array layer range of the view to exceed that of the texture.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.baseArrayLayer = 0;
-        descriptor.arrayLayerCount = kDefaultArrayLayers + 1;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-        descriptor.baseArrayLayer = 1;
-        descriptor.arrayLayerCount = kDefaultArrayLayers;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-        descriptor.baseArrayLayer = kDefaultArrayLayers - 1;
-        descriptor.arrayLayerCount = 2;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-        descriptor.baseArrayLayer = kDefaultArrayLayers;
         descriptor.arrayLayerCount = 1;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-}
-
-// Using the "none" ("default") values validates the same as explicitly
-// specifying the values they're supposed to default to.
-// Variant for a texture with more than 1 array layer.
-TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsArray) {
-    constexpr uint32_t kDefaultArrayLayers = 6;
-    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
-
-    { texture.CreateView(); }
-    {
-        wgpu::TextureViewDescriptor descriptor;
-        descriptor.format = wgpu::TextureFormat::Undefined;
-        texture.CreateView(&descriptor);
-        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
-        texture.CreateView(&descriptor);
-        descriptor.format = wgpu::TextureFormat::R8Unorm;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-    {
-        wgpu::TextureViewDescriptor descriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::Undefined;
-        texture.CreateView(&descriptor);
-        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
-        texture.CreateView(&descriptor);
-        descriptor.dimension = wgpu::TextureViewDimension::e2D;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-    {
-        wgpu::TextureViewDescriptor descriptor;
-
-        // Setting array layers to non-0 means the dimensionality will
-        // default to 2D so by itself it causes an error.
-        descriptor.arrayLayerCount = kDefaultArrayLayers;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
-        texture.CreateView(&descriptor);
-
-        descriptor.mipLevelCount = kDefaultMipLevels;
-        texture.CreateView(&descriptor);
-    }
-}
-
-// Using the "none" ("default") values validates the same as explicitly
-// specifying the values they're supposed to default to.
-// Variant for a texture with only 1 array layer.
-TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsNonArray) {
-    constexpr uint32_t kDefaultArrayLayers = 1;
-    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
-
-    { texture.CreateView(); }
-    {
-        wgpu::TextureViewDescriptor descriptor;
-        descriptor.format = wgpu::TextureFormat::Undefined;
-        texture.CreateView(&descriptor);
-        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
-        texture.CreateView(&descriptor);
-        descriptor.format = wgpu::TextureFormat::R8Unorm;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-    {
-        wgpu::TextureViewDescriptor descriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::Undefined;
-        texture.CreateView(&descriptor);
-        descriptor.dimension = wgpu::TextureViewDimension::e2D;
-        texture.CreateView(&descriptor);
-        descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
-        texture.CreateView(&descriptor);
-    }
-    {
-        wgpu::TextureViewDescriptor descriptor;
-        descriptor.arrayLayerCount = 0;
-        texture.CreateView(&descriptor);
-        descriptor.arrayLayerCount = 1;
-        texture.CreateView(&descriptor);
-        descriptor.arrayLayerCount = 2;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-    {
-        wgpu::TextureViewDescriptor descriptor;
-        descriptor.mipLevelCount = kDefaultMipLevels;
-        texture.CreateView(&descriptor);
-        descriptor.arrayLayerCount = kDefaultArrayLayers;
-        texture.CreateView(&descriptor);
-    }
-}
-
-// Test creating cube map texture view
-TEST_F(TextureViewValidationTest, CreateCubeMapTextureView) {
-    constexpr uint32_t kDefaultArrayLayers = 16;
-
-    wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
-
-    wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor =
-        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray);
-
-    // It is OK to create a cube map texture view with arrayLayerCount == 6.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::Cube;
-        descriptor.arrayLayerCount = 6;
-        texture.CreateView(&descriptor);
+        return descriptor;
     }
 
-    // It is an error to create a cube map texture view with arrayLayerCount != 6.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::Cube;
-        descriptor.arrayLayerCount = 3;
+    // Test creating texture view on a 2D non-array texture
+    TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2D) {
+        wgpu::Texture texture = Create2DArrayTexture(device, 1);
+
+        wgpu::TextureViewDescriptor base2DTextureViewDescriptor =
+            CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);
+
+        // It is OK to create a 2D texture view on a 2D texture.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
+            descriptor.arrayLayerCount = 1;
+            texture.CreateView(&descriptor);
+        }
+
+        // It is an error to view a layer past the end of the texture.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
+            descriptor.arrayLayerCount = 2;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+
+        // It is OK to create a 1-layer 2D array texture view on a 2D texture.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
+            descriptor.arrayLayerCount = 1;
+            texture.CreateView(&descriptor);
+        }
+
+        // baseMipLevel == k && mipLevelCount == 0 means to use levels k..end.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
+            descriptor.mipLevelCount = 0;
+
+            descriptor.baseMipLevel = 0;
+            texture.CreateView(&descriptor);
+            descriptor.baseMipLevel = 1;
+            texture.CreateView(&descriptor);
+            descriptor.baseMipLevel = kDefaultMipLevels - 1;
+            texture.CreateView(&descriptor);
+            descriptor.baseMipLevel = kDefaultMipLevels;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+
+        // It is an error to make the mip level out of range.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
+            descriptor.baseMipLevel = 0;
+            descriptor.mipLevelCount = kDefaultMipLevels + 1;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+            descriptor.baseMipLevel = 1;
+            descriptor.mipLevelCount = kDefaultMipLevels;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+            descriptor.baseMipLevel = kDefaultMipLevels - 1;
+            descriptor.mipLevelCount = 2;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+            descriptor.baseMipLevel = kDefaultMipLevels;
+            descriptor.mipLevelCount = 1;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+    }
+
+    // Test creating texture view on a 2D array texture
+    TEST_F(TextureViewValidationTest, CreateTextureViewOnTexture2DArray) {
+        constexpr uint32_t kDefaultArrayLayers = 6;
+
+        wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
+
+        wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor =
+            CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray);
+
+        // It is OK to create a 2D texture view on a 2D array texture.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::e2D;
+            descriptor.arrayLayerCount = 1;
+            texture.CreateView(&descriptor);
+        }
+
+        // It is OK to create a 2D array texture view on a 2D array texture.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.arrayLayerCount = kDefaultArrayLayers;
+            texture.CreateView(&descriptor);
+        }
+
+        // baseArrayLayer == k && arrayLayerCount == 0 means to use layers k..end.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.arrayLayerCount = 0;
+
+            descriptor.baseArrayLayer = 0;
+            texture.CreateView(&descriptor);
+            descriptor.baseArrayLayer = 1;
+            texture.CreateView(&descriptor);
+            descriptor.baseArrayLayer = kDefaultArrayLayers - 1;
+            texture.CreateView(&descriptor);
+            descriptor.baseArrayLayer = kDefaultArrayLayers;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+
+        // It is an error for the array layer range of the view to exceed that of the texture.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.baseArrayLayer = 0;
+            descriptor.arrayLayerCount = kDefaultArrayLayers + 1;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+            descriptor.baseArrayLayer = 1;
+            descriptor.arrayLayerCount = kDefaultArrayLayers;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+            descriptor.baseArrayLayer = kDefaultArrayLayers - 1;
+            descriptor.arrayLayerCount = 2;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+            descriptor.baseArrayLayer = kDefaultArrayLayers;
+            descriptor.arrayLayerCount = 1;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+    }
+
+    // Using the "none" ("default") values validates the same as explicitly
+    // specifying the values they're supposed to default to.
+    // Variant for a texture with more than 1 array layer.
+    TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsArray) {
+        constexpr uint32_t kDefaultArrayLayers = 6;
+        wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
+
+        { texture.CreateView(); }
+        {
+            wgpu::TextureViewDescriptor descriptor;
+            descriptor.format = wgpu::TextureFormat::Undefined;
+            texture.CreateView(&descriptor);
+            descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
+            texture.CreateView(&descriptor);
+            descriptor.format = wgpu::TextureFormat::R8Unorm;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+        {
+            wgpu::TextureViewDescriptor descriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::Undefined;
+            texture.CreateView(&descriptor);
+            descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
+            texture.CreateView(&descriptor);
+            descriptor.dimension = wgpu::TextureViewDimension::e2D;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+        {
+            wgpu::TextureViewDescriptor descriptor;
+
+            // Setting array layers to non-0 means the dimensionality will
+            // default to 2D so by itself it causes an error.
+            descriptor.arrayLayerCount = kDefaultArrayLayers;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+            descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
+            texture.CreateView(&descriptor);
+
+            descriptor.mipLevelCount = kDefaultMipLevels;
+            texture.CreateView(&descriptor);
+        }
+    }
+
+    // Using the "none" ("default") values validates the same as explicitly
+    // specifying the values they're supposed to default to.
+    // Variant for a texture with only 1 array layer.
+    TEST_F(TextureViewValidationTest, TextureViewDescriptorDefaultsNonArray) {
+        constexpr uint32_t kDefaultArrayLayers = 1;
+        wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
+
+        { texture.CreateView(); }
+        {
+            wgpu::TextureViewDescriptor descriptor;
+            descriptor.format = wgpu::TextureFormat::Undefined;
+            texture.CreateView(&descriptor);
+            descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
+            texture.CreateView(&descriptor);
+            descriptor.format = wgpu::TextureFormat::R8Unorm;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+        {
+            wgpu::TextureViewDescriptor descriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::Undefined;
+            texture.CreateView(&descriptor);
+            descriptor.dimension = wgpu::TextureViewDimension::e2D;
+            texture.CreateView(&descriptor);
+            descriptor.dimension = wgpu::TextureViewDimension::e2DArray;
+            texture.CreateView(&descriptor);
+        }
+        {
+            wgpu::TextureViewDescriptor descriptor;
+            descriptor.arrayLayerCount = 0;
+            texture.CreateView(&descriptor);
+            descriptor.arrayLayerCount = 1;
+            texture.CreateView(&descriptor);
+            descriptor.arrayLayerCount = 2;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+        {
+            wgpu::TextureViewDescriptor descriptor;
+            descriptor.mipLevelCount = kDefaultMipLevels;
+            texture.CreateView(&descriptor);
+            descriptor.arrayLayerCount = kDefaultArrayLayers;
+            texture.CreateView(&descriptor);
+        }
+    }
+
+    // Test creating cube map texture view
+    TEST_F(TextureViewValidationTest, CreateCubeMapTextureView) {
+        constexpr uint32_t kDefaultArrayLayers = 16;
+
+        wgpu::Texture texture = Create2DArrayTexture(device, kDefaultArrayLayers);
+
+        wgpu::TextureViewDescriptor base2DArrayTextureViewDescriptor =
+            CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2DArray);
+
+        // It is OK to create a cube map texture view with arrayLayerCount == 6.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::Cube;
+            descriptor.arrayLayerCount = 6;
+            texture.CreateView(&descriptor);
+        }
+
+        // It is an error to create a cube map texture view with arrayLayerCount != 6.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::Cube;
+            descriptor.arrayLayerCount = 3;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+
+        // It is OK to create a cube map array texture view with arrayLayerCount % 6 == 0.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
+            descriptor.arrayLayerCount = 12;
+            texture.CreateView(&descriptor);
+        }
+
+        // It is an error to create a cube map array texture view with arrayLayerCount % 6 != 0.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
+            descriptor.arrayLayerCount = 11;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+
+        // It is an error to create a cube map texture view with width != height.
+        {
+            wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5);
+
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::Cube;
+            descriptor.arrayLayerCount = 6;
+            ASSERT_DEVICE_ERROR(nonSquareTexture.CreateView(&descriptor));
+        }
+
+        // It is an error to create a cube map array texture view with width != height.
+        {
+            wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5);
+
+            wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
+            descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
+            descriptor.arrayLayerCount = 12;
+            ASSERT_DEVICE_ERROR(nonSquareTexture.CreateView(&descriptor));
+        }
+    }
+
+    // Test the format compatibility rules when creating a texture view.
+    // TODO(jiawei.shao@intel.com): add more tests when the rules are fully implemented.
+    TEST_F(TextureViewValidationTest, TextureViewFormatCompatibility) {
+        wgpu::Texture texture = Create2DArrayTexture(device, 1);
+
+        wgpu::TextureViewDescriptor base2DTextureViewDescriptor =
+            CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);
+
+        // It is an error to create a texture view in depth-stencil format on a RGBA texture.
+        {
+            wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
+            descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
+            ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
+        }
+    }
+
+    // Test that it's invalid to create a texture view from a destroyed texture
+    TEST_F(TextureViewValidationTest, DestroyCreateTextureView) {
+        wgpu::Texture texture = Create2DArrayTexture(device, 1);
+        wgpu::TextureViewDescriptor descriptor =
+            CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);
+        texture.Destroy();
         ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
     }
 
-    // It is OK to create a cube map array texture view with arrayLayerCount % 6 == 0.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
-        descriptor.arrayLayerCount = 12;
-        texture.CreateView(&descriptor);
+    // Test that only TextureAspect::All is supported
+    TEST_F(TextureViewValidationTest, AspectMustBeAll) {
+        wgpu::TextureDescriptor descriptor = {};
+        descriptor.size = {1, 1, 1};
+        descriptor.format = wgpu::TextureFormat::Depth32Float;
+        descriptor.usage = wgpu::TextureUsage::Sampled | wgpu::TextureUsage::OutputAttachment;
+        wgpu::Texture texture = device.CreateTexture(&descriptor);
+
+        wgpu::TextureViewDescriptor viewDescriptor = {};
+        viewDescriptor.aspect = wgpu::TextureAspect::All;
+        texture.CreateView(&viewDescriptor);
+
+        viewDescriptor.aspect = wgpu::TextureAspect::DepthOnly;
+        ASSERT_DEVICE_ERROR(texture.CreateView(&viewDescriptor));
     }
 
-    // It is an error to create a cube map array texture view with arrayLayerCount % 6 != 0.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
-        descriptor.arrayLayerCount = 11;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-
-    // It is an error to create a cube map texture view with width != height.
-    {
-        wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5);
-
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::Cube;
-        descriptor.arrayLayerCount = 6;
-        ASSERT_DEVICE_ERROR(nonSquareTexture.CreateView(&descriptor));
-    }
-
-    // It is an error to create a cube map array texture view with width != height.
-    {
-        wgpu::Texture nonSquareTexture = Create2DArrayTexture(device, 18, 32, 16, 5);
-
-        wgpu::TextureViewDescriptor descriptor = base2DArrayTextureViewDescriptor;
-        descriptor.dimension = wgpu::TextureViewDimension::CubeArray;
-        descriptor.arrayLayerCount = 12;
-        ASSERT_DEVICE_ERROR(nonSquareTexture.CreateView(&descriptor));
-    }
-}
-
-// Test the format compatibility rules when creating a texture view.
-// TODO(jiawei.shao@intel.com): add more tests when the rules are fully implemented.
-TEST_F(TextureViewValidationTest, TextureViewFormatCompatibility) {
-    wgpu::Texture texture = Create2DArrayTexture(device, 1);
-
-    wgpu::TextureViewDescriptor base2DTextureViewDescriptor =
-        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);
-
-    // It is an error to create a texture view in depth-stencil format on a RGBA texture.
-    {
-        wgpu::TextureViewDescriptor descriptor = base2DTextureViewDescriptor;
-        descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
-        ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-    }
-}
-
-// Test that it's invalid to create a texture view from a destroyed texture
-TEST_F(TextureViewValidationTest, DestroyCreateTextureView) {
-    wgpu::Texture texture = Create2DArrayTexture(device, 1);
-    wgpu::TextureViewDescriptor descriptor =
-        CreateDefaultViewDescriptor(wgpu::TextureViewDimension::e2D);
-    texture.Destroy();
-    ASSERT_DEVICE_ERROR(texture.CreateView(&descriptor));
-}
-
-// Test that only TextureAspect::All is supported
-TEST_F(TextureViewValidationTest, AspectMustBeAll) {
-    wgpu::TextureDescriptor descriptor = {};
-    descriptor.size = {1, 1, 1};
-    descriptor.format = wgpu::TextureFormat::Depth32Float;
-    descriptor.usage = wgpu::TextureUsage::Sampled | wgpu::TextureUsage::OutputAttachment;
-    wgpu::Texture texture = device.CreateTexture(&descriptor);
-
-    wgpu::TextureViewDescriptor viewDescriptor = {};
-    viewDescriptor.aspect = wgpu::TextureAspect::All;
-    texture.CreateView(&viewDescriptor);
-
-    viewDescriptor.aspect = wgpu::TextureAspect::DepthOnly;
-    ASSERT_DEVICE_ERROR(texture.CreateView(&viewDescriptor));
-}
-
 }  // anonymous namespace
diff --git a/src/tests/unittests/validation/ToggleValidationTests.cpp b/src/tests/unittests/validation/ToggleValidationTests.cpp
index 950c889..b0f489f 100644
--- a/src/tests/unittests/validation/ToggleValidationTests.cpp
+++ b/src/tests/unittests/validation/ToggleValidationTests.cpp
@@ -16,34 +16,67 @@
 
 namespace {
 
-class ToggleValidationTest : public ValidationTest {
-};
+    class ToggleValidationTest : public ValidationTest {};
 
-// Tests querying the detail of a toggle from dawn_native::InstanceBase works correctly.
-TEST_F(ToggleValidationTest, QueryToggleInfo) {
-    // Query with a valid toggle name
-    {
-        const char* kValidToggleName = "emulate_store_and_msaa_resolve";
-        const dawn_native::ToggleInfo* toggleInfo = instance->GetToggleInfo(kValidToggleName);
-        ASSERT_NE(nullptr, toggleInfo);
-        ASSERT_NE(nullptr, toggleInfo->name);
-        ASSERT_NE(nullptr, toggleInfo->description);
-        ASSERT_NE(nullptr, toggleInfo->url);
+    // Tests querying the detail of a toggle from dawn_native::InstanceBase works correctly.
+    TEST_F(ToggleValidationTest, QueryToggleInfo) {
+        // Query with a valid toggle name
+        {
+            const char* kValidToggleName = "emulate_store_and_msaa_resolve";
+            const dawn_native::ToggleInfo* toggleInfo = instance->GetToggleInfo(kValidToggleName);
+            ASSERT_NE(nullptr, toggleInfo);
+            ASSERT_NE(nullptr, toggleInfo->name);
+            ASSERT_NE(nullptr, toggleInfo->description);
+            ASSERT_NE(nullptr, toggleInfo->url);
+        }
+
+        // Query with an invalid toggle name
+        {
+            const char* kInvalidToggleName = "!@#$%^&*";
+            const dawn_native::ToggleInfo* toggleInfo = instance->GetToggleInfo(kInvalidToggleName);
+            ASSERT_EQ(nullptr, toggleInfo);
+        }
     }
 
-    // Query with an invalid toggle name
-    {
-        const char* kInvalidToggleName = "!@#$%^&*";
-        const dawn_native::ToggleInfo* toggleInfo = instance->GetToggleInfo(kInvalidToggleName);
-        ASSERT_EQ(nullptr, toggleInfo);
-    }
-}
+    // Tests overriding toggles when creating a device works correctly.
+    TEST_F(ToggleValidationTest, OverrideToggleUsage) {
+        // Create device with a valid name of a toggle
+        {
+            const char* kValidToggleName = "emulate_store_and_msaa_resolve";
+            dawn_native::DeviceDescriptor descriptor;
+            descriptor.forceEnabledToggles.push_back(kValidToggleName);
 
-// Tests overriding toggles when creating a device works correctly.
-TEST_F(ToggleValidationTest, OverrideToggleUsage) {
-    // Create device with a valid name of a toggle
-    {
-        const char* kValidToggleName = "emulate_store_and_msaa_resolve";
+            WGPUDevice deviceWithToggle = adapter.CreateDevice(&descriptor);
+            std::vector<const char*> toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle);
+            bool validToggleExists = false;
+            for (const char* toggle : toggleNames) {
+                if (strcmp(toggle, kValidToggleName) == 0) {
+                    validToggleExists = true;
+                }
+            }
+            ASSERT_EQ(validToggleExists, true);
+        }
+
+        // Create device with an invalid toggle name
+        {
+            const char* kInvalidToggleName = "!@#$%^&*";
+            dawn_native::DeviceDescriptor descriptor;
+            descriptor.forceEnabledToggles.push_back(kInvalidToggleName);
+
+            WGPUDevice deviceWithToggle = adapter.CreateDevice(&descriptor);
+            std::vector<const char*> toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle);
+            bool InvalidToggleExists = false;
+            for (const char* toggle : toggleNames) {
+                if (strcmp(toggle, kInvalidToggleName) == 0) {
+                    InvalidToggleExists = true;
+                }
+            }
+            ASSERT_EQ(InvalidToggleExists, false);
+        }
+    }
+
+    TEST_F(ToggleValidationTest, TurnOffVsyncWithToggle) {
+        const char* kValidToggleName = "turn_off_vsync";
         dawn_native::DeviceDescriptor descriptor;
         descriptor.forceEnabledToggles.push_back(kValidToggleName);
 
@@ -57,38 +90,4 @@
         }
         ASSERT_EQ(validToggleExists, true);
     }
-
-    // Create device with an invalid toggle name
-    {
-        const char* kInvalidToggleName = "!@#$%^&*";
-        dawn_native::DeviceDescriptor descriptor;
-        descriptor.forceEnabledToggles.push_back(kInvalidToggleName);
-
-        WGPUDevice deviceWithToggle = adapter.CreateDevice(&descriptor);
-        std::vector<const char*> toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle);
-        bool InvalidToggleExists = false;
-        for (const char* toggle : toggleNames) {
-            if (strcmp(toggle, kInvalidToggleName) == 0) {
-                InvalidToggleExists = true;
-            }
-        }
-        ASSERT_EQ(InvalidToggleExists, false);
-    }
-}
-
-TEST_F(ToggleValidationTest, TurnOffVsyncWithToggle) {
-    const char* kValidToggleName = "turn_off_vsync";
-    dawn_native::DeviceDescriptor descriptor;
-    descriptor.forceEnabledToggles.push_back(kValidToggleName);
-
-    WGPUDevice deviceWithToggle = adapter.CreateDevice(&descriptor);
-    std::vector<const char*> toggleNames = dawn_native::GetTogglesUsed(deviceWithToggle);
-    bool validToggleExists = false;
-    for (const char* toggle : toggleNames) {
-        if (strcmp(toggle, kValidToggleName) == 0) {
-            validToggleExists = true;
-        }
-    }
-    ASSERT_EQ(validToggleExists, true);
-}
 }  // anonymous namespace
diff --git a/src/tests/unittests/validation/ValidationTest.cpp b/src/tests/unittests/validation/ValidationTest.cpp
index 21f028a..6b533b4 100644
--- a/src/tests/unittests/validation/ValidationTest.cpp
+++ b/src/tests/unittests/validation/ValidationTest.cpp
@@ -27,7 +27,7 @@
 
     // Validation tests run against the null backend, find the corresponding adapter
     bool foundNullAdapter = false;
-    for (auto &currentAdapter : adapters) {
+    for (auto& currentAdapter : adapters) {
         wgpu::AdapterProperties adapterProperties;
         currentAdapter.GetProperties(&adapterProperties);
 
@@ -129,7 +129,7 @@
     wgpu::TextureView view = attachment.CreateView();
     mColorAttachment.attachment = view;
     mColorAttachment.resolveTarget = nullptr;
-    mColorAttachment.clearColor = { 0.0f, 0.0f, 0.0f, 0.0f };
+    mColorAttachment.clearColor = {0.0f, 0.0f, 0.0f, 0.0f};
     mColorAttachment.loadOp = wgpu::LoadOp::Clear;
     mColorAttachment.storeOp = wgpu::StoreOp::Store;
 
diff --git a/src/tests/unittests/validation/ValidationTest.h b/src/tests/unittests/validation/ValidationTest.h
index 7862b4c..c922dd6 100644
--- a/src/tests/unittests/validation/ValidationTest.h
+++ b/src/tests/unittests/validation/ValidationTest.h
@@ -70,4 +70,4 @@
     bool mError = false;
 };
 
-#endif // TESTS_UNITTESTS_VALIDATIONTEST_H_
+#endif  // TESTS_UNITTESTS_VALIDATIONTEST_H_
diff --git a/src/tests/unittests/validation/VertexBufferValidationTests.cpp b/src/tests/unittests/validation/VertexBufferValidationTests.cpp
index 9c67a0f..4c8722e 100644
--- a/src/tests/unittests/validation/VertexBufferValidationTests.cpp
+++ b/src/tests/unittests/validation/VertexBufferValidationTests.cpp
@@ -21,68 +21,68 @@
 #include "utils/WGPUHelpers.h"
 
 class VertexBufferValidationTest : public ValidationTest {
-    protected:
-        void SetUp() override {
-            ValidationTest::SetUp();
+  protected:
+    void SetUp() override {
+        ValidationTest::SetUp();
 
-            fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        fsModule = utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
                 #version 450
                 layout(location = 0) out vec4 fragColor;
                 void main() {
                     fragColor = vec4(0.0, 1.0, 0.0, 1.0);
                 })");
+    }
+
+    wgpu::Buffer MakeVertexBuffer() {
+        wgpu::BufferDescriptor descriptor;
+        descriptor.size = 256;
+        descriptor.usage = wgpu::BufferUsage::Vertex;
+
+        return device.CreateBuffer(&descriptor);
+    }
+
+    wgpu::ShaderModule MakeVertexShader(unsigned int bufferCount) {
+        std::ostringstream vs;
+        vs << "#version 450\n";
+        for (unsigned int i = 0; i < bufferCount; ++i) {
+            vs << "layout(location = " << i << ") in vec3 a_position" << i << ";\n";
         }
+        vs << "void main() {\n";
 
-        wgpu::Buffer MakeVertexBuffer() {
-            wgpu::BufferDescriptor descriptor;
-            descriptor.size = 256;
-            descriptor.usage = wgpu::BufferUsage::Vertex;
-
-            return device.CreateBuffer(&descriptor);
-        }
-
-        wgpu::ShaderModule MakeVertexShader(unsigned int bufferCount) {
-            std::ostringstream vs;
-            vs << "#version 450\n";
-            for (unsigned int i = 0; i < bufferCount; ++i) {
-                vs << "layout(location = " << i << ") in vec3 a_position" << i << ";\n";
+        vs << "gl_Position = vec4(";
+        for (unsigned int i = 0; i < bufferCount; ++i) {
+            vs << "a_position" << i;
+            if (i != bufferCount - 1) {
+                vs << " + ";
             }
-            vs << "void main() {\n";
-
-            vs << "gl_Position = vec4(";
-            for (unsigned int i = 0; i < bufferCount; ++i) {
-                vs << "a_position" << i;
-                if (i != bufferCount - 1) {
-                    vs << " + ";
-                }
-            }
-            vs << ", 1.0);";
-
-            vs << "}\n";
-
-            return utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex,
-                                             vs.str().c_str());
         }
+        vs << ", 1.0);";
 
-        wgpu::RenderPipeline MakeRenderPipeline(const wgpu::ShaderModule& vsModule,
-                                                unsigned int bufferCount) {
-            utils::ComboRenderPipelineDescriptor descriptor(device);
-            descriptor.vertexStage.module = vsModule;
-            descriptor.cFragmentStage.module = fsModule;
+        vs << "}\n";
 
-            for (unsigned int i = 0; i < bufferCount; ++i) {
-                descriptor.cVertexState.cVertexBuffers[i].attributeCount = 1;
-                descriptor.cVertexState.cVertexBuffers[i].attributes =
-                    &descriptor.cVertexState.cAttributes[i];
-                descriptor.cVertexState.cAttributes[i].shaderLocation = i;
-                descriptor.cVertexState.cAttributes[i].format = wgpu::VertexFormat::Float3;
-            }
-            descriptor.cVertexState.vertexBufferCount = bufferCount;
+        return utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex,
+                                         vs.str().c_str());
+    }
 
-            return device.CreateRenderPipeline(&descriptor);
+    wgpu::RenderPipeline MakeRenderPipeline(const wgpu::ShaderModule& vsModule,
+                                            unsigned int bufferCount) {
+        utils::ComboRenderPipelineDescriptor descriptor(device);
+        descriptor.vertexStage.module = vsModule;
+        descriptor.cFragmentStage.module = fsModule;
+
+        for (unsigned int i = 0; i < bufferCount; ++i) {
+            descriptor.cVertexState.cVertexBuffers[i].attributeCount = 1;
+            descriptor.cVertexState.cVertexBuffers[i].attributes =
+                &descriptor.cVertexState.cAttributes[i];
+            descriptor.cVertexState.cAttributes[i].shaderLocation = i;
+            descriptor.cVertexState.cAttributes[i].format = wgpu::VertexFormat::Float3;
         }
+        descriptor.cVertexState.vertexBufferCount = bufferCount;
 
-        wgpu::ShaderModule fsModule;
+        return device.CreateRenderPipeline(&descriptor);
+    }
+
+    wgpu::ShaderModule fsModule;
 };
 
 TEST_F(VertexBufferValidationTest, VertexBuffersInheritedBetweenPipelines) {
diff --git a/src/tests/unittests/wire/WireArgumentTests.cpp b/src/tests/unittests/wire/WireArgumentTests.cpp
index 2185028..95685cf 100644
--- a/src/tests/unittests/wire/WireArgumentTests.cpp
+++ b/src/tests/unittests/wire/WireArgumentTests.cpp
@@ -185,7 +185,6 @@
     FlushClient();
 }
 
-
 // Test that the wire is able to send objects as value arguments
 TEST_F(WireArgumentTests, ObjectAsValueArgument) {
     WGPUCommandEncoder cmdBufEncoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
diff --git a/src/tests/unittests/wire/WireBufferMappingTests.cpp b/src/tests/unittests/wire/WireBufferMappingTests.cpp
index 1307b95..990a300 100644
--- a/src/tests/unittests/wire/WireBufferMappingTests.cpp
+++ b/src/tests/unittests/wire/WireBufferMappingTests.cpp
@@ -613,4 +613,3 @@
 
     FlushClient();
 }
-
diff --git a/src/tests/unittests/wire/WireErrorCallbackTests.cpp b/src/tests/unittests/wire/WireErrorCallbackTests.cpp
index 6f31977..3fe25f0 100644
--- a/src/tests/unittests/wire/WireErrorCallbackTests.cpp
+++ b/src/tests/unittests/wire/WireErrorCallbackTests.cpp
@@ -64,7 +64,8 @@
         WireTest::SetUp();
 
         mockDeviceErrorCallback = std::make_unique<StrictMock<MockDeviceErrorCallback>>();
-        mockDevicePopErrorScopeCallback = std::make_unique<StrictMock<MockDevicePopErrorScopeCallback>>();
+        mockDevicePopErrorScopeCallback =
+            std::make_unique<StrictMock<MockDevicePopErrorScopeCallback>>();
         mockDeviceLostCallback = std::make_unique<StrictMock<MockDeviceLostCallback>>();
     }
 
@@ -206,8 +207,7 @@
 
     EXPECT_TRUE(wgpuDevicePopErrorScope(device, ToMockDevicePopErrorScopeCallback, this));
 
-    EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _))
-        .WillOnce(Return(true));
+    EXPECT_CALL(api, OnDevicePopErrorScopeCallback(apiDevice, _, _)).WillOnce(Return(true));
     FlushClient();
 
     // Incomplete callback called in Device destructor.
diff --git a/src/tests/unittests/wire/WireExtensionTests.cpp b/src/tests/unittests/wire/WireExtensionTests.cpp
index 78f9de7..d36fc5f 100644
--- a/src/tests/unittests/wire/WireExtensionTests.cpp
+++ b/src/tests/unittests/wire/WireExtensionTests.cpp
@@ -40,8 +40,9 @@
         .WillOnce(Invoke([&](Unused, const WGPUSamplerDescriptor* serverDesc) -> WGPUSampler {
             EXPECT_STREQ(serverDesc->label, clientDesc.label);
 
-            const auto* ext = reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
-                serverDesc->nextInChain);
+            const auto* ext =
+                reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
+                    serverDesc->nextInChain);
             EXPECT_EQ(ext->chain.sType, clientExt.chain.sType);
             EXPECT_EQ(ext->maxAnisotropy, clientExt.maxAnisotropy);
 
@@ -73,13 +74,15 @@
         .WillOnce(Invoke([&](Unused, const WGPUSamplerDescriptor* serverDesc) -> WGPUSampler {
             EXPECT_STREQ(serverDesc->label, clientDesc.label);
 
-            const auto* ext1 = reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
-                serverDesc->nextInChain);
+            const auto* ext1 =
+                reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
+                    serverDesc->nextInChain);
             EXPECT_EQ(ext1->chain.sType, clientExt1.chain.sType);
             EXPECT_EQ(ext1->maxAnisotropy, clientExt1.maxAnisotropy);
 
-            const auto* ext2 = reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
-                ext1->chain.next);
+            const auto* ext2 =
+                reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
+                    ext1->chain.next);
             EXPECT_EQ(ext2->chain.sType, clientExt2.chain.sType);
             EXPECT_EQ(ext2->maxAnisotropy, clientExt2.maxAnisotropy);
 
@@ -99,13 +102,15 @@
         .WillOnce(Invoke([&](Unused, const WGPUSamplerDescriptor* serverDesc) -> WGPUSampler {
             EXPECT_STREQ(serverDesc->label, clientDesc.label);
 
-            const auto* ext2 = reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
-                serverDesc->nextInChain);
+            const auto* ext2 =
+                reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
+                    serverDesc->nextInChain);
             EXPECT_EQ(ext2->chain.sType, clientExt2.chain.sType);
             EXPECT_EQ(ext2->maxAnisotropy, clientExt2.maxAnisotropy);
 
-            const auto* ext1 = reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
-                ext2->chain.next);
+            const auto* ext1 =
+                reinterpret_cast<const WGPUSamplerDescriptorDummyAnisotropicFiltering*>(
+                    ext2->chain.next);
             EXPECT_EQ(ext1->chain.sType, clientExt1.chain.sType);
             EXPECT_EQ(ext1->maxAnisotropy, clientExt1.maxAnisotropy);
 
diff --git a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
index bb1efb6..026b52e 100644
--- a/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
+++ b/src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp
@@ -180,9 +180,7 @@
         ClientReadHandle* handle = clientMemoryTransferService.NewReadHandle();
 
         EXPECT_CALL(clientMemoryTransferService, OnCreateReadHandle(sizeof(mBufferContent)))
-            .WillOnce(InvokeWithoutArgs([=]() {
-                return handle;
-            }));
+            .WillOnce(InvokeWithoutArgs([=]() { return handle; }));
 
         return handle;
     }
@@ -259,9 +257,7 @@
         ClientWriteHandle* handle = clientMemoryTransferService.NewWriteHandle();
 
         EXPECT_CALL(clientMemoryTransferService, OnCreateWriteHandle(sizeof(mBufferContent)))
-            .WillOnce(InvokeWithoutArgs([=]() {
-                return handle;
-            }));
+            .WillOnce(InvokeWithoutArgs([=]() { return handle; }));
 
         return handle;
     }
@@ -300,22 +296,18 @@
         EXPECT_CALL(serverMemoryTransferService,
                     OnDeserializeWriteHandle(Pointee(Eq(mSerializeCreateInfo)),
                                              sizeof(mSerializeCreateInfo), _))
-            .WillOnce(InvokeWithoutArgs([&]() {
-                return false;
-            }));
+            .WillOnce(InvokeWithoutArgs([&]() { return false; }));
     }
 
     void ExpectClientWriteHandleOpen(ClientWriteHandle* handle, uint32_t* mappedData) {
         EXPECT_CALL(clientMemoryTransferService, OnWriteHandleOpen(handle))
-            .WillOnce(InvokeWithoutArgs([=]() {
-                return std::make_pair(mappedData, sizeof(*mappedData));
-            }));
+            .WillOnce(InvokeWithoutArgs(
+                [=]() { return std::make_pair(mappedData, sizeof(*mappedData)); }));
     }
 
     void MockClientWriteHandleOpenFailure(ClientWriteHandle* handle) {
         EXPECT_CALL(clientMemoryTransferService, OnWriteHandleOpen(handle))
-            .WillOnce(InvokeWithoutArgs(
-                [&]() { return std::make_pair(nullptr, 0); }));
+            .WillOnce(InvokeWithoutArgs([&]() { return std::make_pair(nullptr, 0); }));
     }
 
     void ExpectClientWriteHandleSerializeFlush(ClientWriteHandle* handle) {
@@ -348,8 +340,8 @@
 
     // Arbitrary values used within tests to check if serialized data is correctly passed
     // between the client and server. The static data changes between runs of the tests and
-    // test expectations will check that serialized values are passed to the respective deserialization
-    // function.
+    // test expectations will check that serialized values are passed to the respective
+    // deserialization function.
     static uint32_t mSerializeCreateInfo;
     static uint32_t mSerializeInitialDataInfo;
     static uint32_t mSerializeFlushInfo;
@@ -360,8 +352,9 @@
     // The client's zero-initialized buffer for writing.
     uint32_t mMappedBufferContent = 0;
 
-    // |mMappedBufferContent| should be set equal to |mUpdatedBufferContent| when the client performs a write.
-    // Test expectations should check that |mBufferContent == mUpdatedBufferContent| after all writes are flushed.
+    // |mMappedBufferContent| should be set equal to |mUpdatedBufferContent| when the client
+    // performs a write. Test expectations should check that |mBufferContent ==
+    // mUpdatedBufferContent| after all writes are flushed.
     static uint32_t mUpdatedBufferContent;
 
     testing::StrictMock<dawn_wire::server::MockMemoryTransferService> serverMemoryTransferService;
diff --git a/src/tests/unittests/wire/WireTest.h b/src/tests/unittests/wire/WireTest.h
index 7a8ed5a..d4537d6 100644
--- a/src/tests/unittests/wire/WireTest.h
+++ b/src/tests/unittests/wire/WireTest.h
@@ -68,9 +68,11 @@
 
 class StringMessageMatcher : public testing::MatcherInterface<const char*> {
   public:
-    explicit StringMessageMatcher() {}
+    explicit StringMessageMatcher() {
+    }
 
-    bool MatchAndExplain(const char* message, testing::MatchResultListener* listener) const override {
+    bool MatchAndExplain(const char* message,
+                         testing::MatchResultListener* listener) const override {
         if (message == nullptr) {
             *listener << "missing error message";
             return false;
@@ -83,11 +85,11 @@
     }
 
     void DescribeTo(std::ostream* os) const override {
-      *os << "valid error message";
+        *os << "valid error message";
     }
 
     void DescribeNegationTo(std::ostream* os) const override {
-      *os << "invalid error message";
+        *os << "invalid error message";
     }
 };