diff --git a/src/common/Math.h b/src/common/Math.h
index 69cab24..408c0a9 100644
--- a/src/common/Math.h
+++ b/src/common/Math.h
@@ -89,6 +89,11 @@
 float Float16ToFloat32(uint16_t fp16);
 bool IsFloat16NaN(uint16_t fp16);
 
+template <typename T>
+T FloatToUnorm(float value) {
+    return static_cast<T>(value * static_cast<float>(std::numeric_limits<T>::max()));
+}
+
 float SRGBToLinear(float srgb);
 
 template <typename T1,
diff --git a/src/dawn_native/d3d12/AdapterD3D12.cpp b/src/dawn_native/d3d12/AdapterD3D12.cpp
index 6e40c7a..df8ec50 100644
--- a/src/dawn_native/d3d12/AdapterD3D12.cpp
+++ b/src/dawn_native/d3d12/AdapterD3D12.cpp
@@ -135,6 +135,9 @@
         mSupportedFeatures.EnableFeature(Feature::TextureCompressionBC);
         mSupportedFeatures.EnableFeature(Feature::PipelineStatisticsQuery);
         mSupportedFeatures.EnableFeature(Feature::MultiPlanarFormats);
+        mSupportedFeatures.EnableFeature(Feature::Depth24UnormStencil8);
+        mSupportedFeatures.EnableFeature(Feature::Depth32FloatStencil8);
+
         return {};
     }
 
diff --git a/src/dawn_native/d3d12/TextureD3D12.cpp b/src/dawn_native/d3d12/TextureD3D12.cpp
index 7a913a2..4168134 100644
--- a/src/dawn_native/d3d12/TextureD3D12.cpp
+++ b/src/dawn_native/d3d12/TextureD3D12.cpp
@@ -178,7 +178,10 @@
                 case wgpu::TextureFormat::Depth24Plus:
                     return DXGI_FORMAT_R32_TYPELESS;
 
+                case wgpu::TextureFormat::Depth24UnormStencil8:
+                    return DXGI_FORMAT_R24G8_TYPELESS;
                 case wgpu::TextureFormat::Depth24PlusStencil8:
+                case wgpu::TextureFormat::Depth32FloatStencil8:
                     return DXGI_FORMAT_R32G8X24_TYPELESS;
 
                 case wgpu::TextureFormat::BC1RGBAUnorm:
@@ -252,10 +255,6 @@
                 case wgpu::TextureFormat::R8BG8Biplanar420Unorm:
                 // TODO(dawn:666): implement stencil8
                 case wgpu::TextureFormat::Stencil8:
-                // TODO(dawn:690): implement depth24unorm-stencil8
-                case wgpu::TextureFormat::Depth24UnormStencil8:
-                // TODO(dawn:690): implement depth32float-stencil8
-                case wgpu::TextureFormat::Depth32FloatStencil8:
                 case wgpu::TextureFormat::Undefined:
                     UNREACHABLE();
             }
@@ -342,14 +341,16 @@
             case wgpu::TextureFormat::RGBA32Float:
                 return DXGI_FORMAT_R32G32B32A32_FLOAT;
 
-            case wgpu::TextureFormat::Depth32Float:
-                return DXGI_FORMAT_D32_FLOAT;
-            case wgpu::TextureFormat::Depth24Plus:
-                return DXGI_FORMAT_D32_FLOAT;
-            case wgpu::TextureFormat::Depth24PlusStencil8:
-                return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
             case wgpu::TextureFormat::Depth16Unorm:
                 return DXGI_FORMAT_D16_UNORM;
+            case wgpu::TextureFormat::Depth32Float:
+            case wgpu::TextureFormat::Depth24Plus:
+                return DXGI_FORMAT_D32_FLOAT;
+            case wgpu::TextureFormat::Depth24UnormStencil8:
+                return DXGI_FORMAT_D24_UNORM_S8_UINT;
+            case wgpu::TextureFormat::Depth24PlusStencil8:
+            case wgpu::TextureFormat::Depth32FloatStencil8:
+                return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
 
             case wgpu::TextureFormat::BC1RGBAUnorm:
                 return DXGI_FORMAT_BC1_UNORM;
@@ -425,10 +426,6 @@
 
             // TODO(dawn:666): implement stencil8
             case wgpu::TextureFormat::Stencil8:
-            // TODO(dawn:690): implement depth24unorm-stencil8
-            case wgpu::TextureFormat::Depth24UnormStencil8:
-            // TODO(dawn:690): implement depth32float-stencil8
-            case wgpu::TextureFormat::Depth32FloatStencil8:
             case wgpu::TextureFormat::Undefined:
                 UNREACHABLE();
         }
@@ -699,7 +696,9 @@
         ASSERT(GetFormat().aspects & aspect);
 
         switch (GetFormat().format) {
+            case wgpu::TextureFormat::Depth24UnormStencil8:
             case wgpu::TextureFormat::Depth24PlusStencil8:
+            case wgpu::TextureFormat::Depth32FloatStencil8:
                 switch (aspect) {
                     case Aspect::Depth:
                         return DXGI_FORMAT_R32_FLOAT;
@@ -1186,7 +1185,39 @@
                 case wgpu::TextureFormat::Depth16Unorm:
                     mSrvDesc.Format = DXGI_FORMAT_R16_UNORM;
                     break;
+                case wgpu::TextureFormat::Depth24UnormStencil8:
+                    switch (descriptor->aspect) {
+                        case wgpu::TextureAspect::DepthOnly:
+                            planeSlice = 0;
+                            mSrvDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
+                            break;
+                        case wgpu::TextureAspect::StencilOnly:
+                            planeSlice = 1;
+                            mSrvDesc.Format = DXGI_FORMAT_X24_TYPELESS_G8_UINT;
+                            // Stencil is accessed using the .g component in the shader.
+                            // Map it to the zeroth component to match other APIs.
+                            mSrvDesc.Shader4ComponentMapping =
+                                D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(
+                                    D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1,
+                                    D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0,
+                                    D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0,
+                                    D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1);
+                            break;
+                        case wgpu::TextureAspect::All:
+                            // A single aspect is not selected. The texture view must not be
+                            // sampled.
+                            mSrvDesc.Format = DXGI_FORMAT_UNKNOWN;
+                            break;
+
+                        // Depth formats cannot use plane aspects.
+                        case wgpu::TextureAspect::Plane0Only:
+                        case wgpu::TextureAspect::Plane1Only:
+                            UNREACHABLE();
+                            break;
+                    }
+                    break;
                 case wgpu::TextureFormat::Depth24PlusStencil8:
+                case wgpu::TextureFormat::Depth32FloatStencil8:
                     switch (descriptor->aspect) {
                         case wgpu::TextureAspect::DepthOnly:
                             planeSlice = 0;
diff --git a/src/dawn_native/metal/BackendMTL.mm b/src/dawn_native/metal/BackendMTL.mm
index 8b0194b..ee7e8e0 100644
--- a/src/dawn_native/metal/BackendMTL.mm
+++ b/src/dawn_native/metal/BackendMTL.mm
@@ -324,6 +324,17 @@
                 mSupportedFeatures.EnableFeature(Feature::DepthClamping);
             }
 
+            if (@available(macOS 10.11, iOS 9.0, *)) {
+                mSupportedFeatures.EnableFeature(Feature::Depth32FloatStencil8);
+            }
+
+#if defined(DAWN_PLATFORM_MACOS)
+            // MTLPixelFormatDepth24Unorm_Stencil8 is only available on macOS 10.11+
+            if ([*mDevice isDepth24Stencil8PixelFormatSupported]) {
+                mSupportedFeatures.EnableFeature(Feature::Depth24UnormStencil8);
+            }
+#endif
+
             return {};
         }
 
diff --git a/src/dawn_native/metal/TextureMTL.mm b/src/dawn_native/metal/TextureMTL.mm
index 37eb9bc..7a98886 100644
--- a/src/dawn_native/metal/TextureMTL.mm
+++ b/src/dawn_native/metal/TextureMTL.mm
@@ -222,6 +222,7 @@
             case wgpu::TextureFormat::Depth24Plus:
                 return MTLPixelFormatDepth32Float;
             case wgpu::TextureFormat::Depth24PlusStencil8:
+            case wgpu::TextureFormat::Depth32FloatStencil8:
                 return MTLPixelFormatDepth32Float_Stencil8;
             case wgpu::TextureFormat::Depth16Unorm:
                 if (@available(macOS 10.12, iOS 13.0, *)) {
@@ -232,6 +233,9 @@
                 }
 
 #if defined(DAWN_PLATFORM_MACOS)
+            case wgpu::TextureFormat::Depth24UnormStencil8:
+                return MTLPixelFormatDepth24Unorm_Stencil8;
+
             case wgpu::TextureFormat::BC1RGBAUnorm:
                 return MTLPixelFormatBC1_RGBA;
             case wgpu::TextureFormat::BC1RGBAUnormSrgb:
@@ -261,6 +265,8 @@
             case wgpu::TextureFormat::BC7RGBAUnormSrgb:
                 return MTLPixelFormatBC7_RGBAUnorm_sRGB;
 #else
+            case wgpu::TextureFormat::Depth24UnormStencil8:
+
             case wgpu::TextureFormat::BC1RGBAUnorm:
             case wgpu::TextureFormat::BC1RGBAUnormSrgb:
             case wgpu::TextureFormat::BC2RGBAUnorm:
@@ -321,10 +327,6 @@
 
             // TODO(dawn:666): implement stencil8
             case wgpu::TextureFormat::Stencil8:
-            // TODO(dawn:690): implement depth24unorm-stencil8
-            case wgpu::TextureFormat::Depth24UnormStencil8:
-            // TODO(dawn:690): implement depth32float-stencil8
-            case wgpu::TextureFormat::Depth32FloatStencil8:
             case wgpu::TextureFormat::Undefined:
                 UNREACHABLE();
         }
@@ -746,8 +748,17 @@
             MTLPixelFormat format = MetalPixelFormat(descriptor->format);
             if (descriptor->aspect == wgpu::TextureAspect::StencilOnly) {
                 if (@available(macOS 10.12, iOS 10.0, *)) {
-                    ASSERT(format == MTLPixelFormatDepth32Float_Stencil8);
-                    format = MTLPixelFormatX32_Stencil8;
+                    if (format == MTLPixelFormatDepth32Float_Stencil8) {
+                        format = MTLPixelFormatX32_Stencil8;
+                    }
+#if defined(DAWN_PLATFORM_MACOS)
+                    else if (format == MTLPixelFormatDepth24Unorm_Stencil8) {
+                        format = MTLPixelFormatX24_Stencil8;
+                    }
+#endif
+                    else {
+                        UNREACHABLE();
+                    }
                 } else {
                     // TODO(enga): Add a workaround to back combined depth/stencil textures
                     // with Sampled usage using two separate textures.
diff --git a/src/dawn_native/vulkan/AdapterVk.cpp b/src/dawn_native/vulkan/AdapterVk.cpp
index 4f8b1c9..4eea820 100644
--- a/src/dawn_native/vulkan/AdapterVk.cpp
+++ b/src/dawn_native/vulkan/AdapterVk.cpp
@@ -151,6 +151,14 @@
             mSupportedFeatures.EnableFeature(Feature::TimestampQuery);
         }
 
+        if (IsDepthStencilFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT)) {
+            mSupportedFeatures.EnableFeature(Feature::Depth24UnormStencil8);
+        }
+
+        if (IsDepthStencilFormatSupported(VK_FORMAT_D32_SFLOAT_S8_UINT)) {
+            mSupportedFeatures.EnableFeature(Feature::Depth32FloatStencil8);
+        }
+
 #if defined(DAWN_USE_SYNC_FDS)
         // TODO(chromium:1258986): Precisely enable the feature by querying the device's format
         // features.
diff --git a/src/dawn_native/vulkan/TextureVk.cpp b/src/dawn_native/vulkan/TextureVk.cpp
index 1b4c7d3..ab89859 100644
--- a/src/dawn_native/vulkan/TextureVk.cpp
+++ b/src/dawn_native/vulkan/TextureVk.cpp
@@ -311,6 +311,10 @@
                 } else {
                     return VK_FORMAT_D24_UNORM_S8_UINT;
                 }
+            case wgpu::TextureFormat::Depth24UnormStencil8:
+                return VK_FORMAT_D24_UNORM_S8_UINT;
+            case wgpu::TextureFormat::Depth32FloatStencil8:
+                return VK_FORMAT_D32_SFLOAT_S8_UINT;
 
             case wgpu::TextureFormat::BC1RGBAUnorm:
                 return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
@@ -424,10 +428,6 @@
 
             // TODO(dawn:666): implement stencil8
             case wgpu::TextureFormat::Stencil8:
-            // TODO(dawn:690): implement depth24unorm-stencil8
-            case wgpu::TextureFormat::Depth24UnormStencil8:
-            // TODO(dawn:690): implement depth32float-stencil8
-            case wgpu::TextureFormat::Depth32FloatStencil8:
             case wgpu::TextureFormat::Undefined:
                 break;
         }
diff --git a/src/tests/end2end/DepthStencilCopyTests.cpp b/src/tests/end2end/DepthStencilCopyTests.cpp
index 8b875ce..2edd3ee 100644
--- a/src/tests/end2end/DepthStencilCopyTests.cpp
+++ b/src/tests/end2end/DepthStencilCopyTests.cpp
@@ -22,10 +22,23 @@
 #include "utils/TextureUtils.h"
 #include "utils/WGPUHelpers.h"
 
-class DepthStencilCopyTests : public DawnTest {
+namespace {
+    using TextureFormat = wgpu::TextureFormat;
+    DAWN_TEST_PARAM_STRUCT(DepthStencilCopyTestParams, TextureFormat);
+
+    constexpr std::array<wgpu::TextureFormat, 3> kValidDepthCopyTextureFormats = {
+        wgpu::TextureFormat::Depth16Unorm,
+        wgpu::TextureFormat::Depth32Float,
+        wgpu::TextureFormat::Depth32FloatStencil8,
+    };
+}  // namespace
+
+class DepthStencilCopyTests : public DawnTestWithParams<DepthStencilCopyTestParams> {
   protected:
     void SetUp() override {
-        DawnTest::SetUp();
+        DawnTestWithParams<DepthStencilCopyTestParams>::SetUp();
+
+        DAWN_TEST_UNSUPPORTED_IF(!mIsFormatSupported);
 
         // Draw a square in the bottom left quarter of the screen.
         mVertexModule = utils::CreateShaderModule(device, R"(
@@ -42,13 +55,56 @@
             })");
     }
 
+    std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
+        switch (GetParam().mTextureFormat) {
+            case wgpu::TextureFormat::Depth24UnormStencil8:
+                if (SupportsFeatures({wgpu::FeatureName::Depth24UnormStencil8})) {
+                    mIsFormatSupported = true;
+                    return {wgpu::FeatureName::Depth24UnormStencil8};
+                }
+                return {};
+            case wgpu::TextureFormat::Depth32FloatStencil8:
+                if (SupportsFeatures({wgpu::FeatureName::Depth32FloatStencil8})) {
+                    mIsFormatSupported = true;
+                    return {wgpu::FeatureName::Depth32FloatStencil8};
+                }
+                return {};
+            default:
+                mIsFormatSupported = true;
+                return {};
+        }
+    }
+
+    bool IsValidDepthCopyTextureFormat() {
+        switch (GetParam().mTextureFormat) {
+            case wgpu::TextureFormat::Depth16Unorm:
+            case wgpu::TextureFormat::Depth32Float:
+            case wgpu::TextureFormat::Depth32FloatStencil8:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    wgpu::Texture CreateTexture(uint32_t width,
+                                uint32_t height,
+                                wgpu::TextureUsage usage,
+                                uint32_t mipLevelCount = 1) {
+        wgpu::TextureDescriptor texDescriptor = {};
+        texDescriptor.size = {width, height, 1};
+        texDescriptor.format = GetParam().mTextureFormat;
+        texDescriptor.usage = usage;
+        texDescriptor.mipLevelCount = mipLevelCount;
+        return device.CreateTexture(&texDescriptor);
+    }
+
     wgpu::Texture CreateDepthStencilTexture(uint32_t width,
                                             uint32_t height,
                                             wgpu::TextureUsage usage,
                                             uint32_t mipLevelCount = 1) {
         wgpu::TextureDescriptor texDescriptor = {};
         texDescriptor.size = {width, height, 1};
-        texDescriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
+        texDescriptor.format = GetParam().mTextureFormat;
         texDescriptor.usage = usage;
         texDescriptor.mipLevelCount = mipLevelCount;
         return device.CreateTexture(&texDescriptor);
@@ -60,7 +116,7 @@
                                      uint32_t mipLevelCount = 1) {
         wgpu::TextureDescriptor texDescriptor = {};
         texDescriptor.size = {width, height, 1};
-        texDescriptor.format = wgpu::TextureFormat::Depth32Float;
+        texDescriptor.format = GetParam().mTextureFormat;
         texDescriptor.usage = usage;
         texDescriptor.mipLevelCount = mipLevelCount;
         return device.CreateTexture(&texDescriptor);
@@ -97,7 +153,7 @@
         renderPassDesc.cDepthStencilAttachmentInfo.clearDepth = clearDepth;
 
         utils::ComboRenderPipelineDescriptor renderPipelineDesc;
-        PopulatePipelineDescriptorWriteDepth(&renderPipelineDesc, wgpu::TextureFormat::Depth32Float,
+        PopulatePipelineDescriptorWriteDepth(&renderPipelineDesc, GetParam().mTextureFormat,
                                              regionDepth);
 
         wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc);
@@ -129,8 +185,8 @@
         renderPassDesc.cDepthStencilAttachmentInfo.clearStencil = clearStencil;
 
         utils::ComboRenderPipelineDescriptor renderPipelineDesc;
-        PopulatePipelineDescriptorWriteDepth(&renderPipelineDesc,
-                                             wgpu::TextureFormat::Depth24PlusStencil8, regionDepth);
+        PopulatePipelineDescriptorWriteDepth(&renderPipelineDesc, GetParam().mTextureFormat,
+                                             regionDepth);
         renderPipelineDesc.cDepthStencil.stencilFront.passOp = wgpu::StencilOperation::Replace;
 
         wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc);
@@ -183,97 +239,11 @@
     }
 
     wgpu::ShaderModule mVertexModule;
+
+  private:
+    bool mIsFormatSupported = false;
 };
 
-// Test copying the depth-only aspect into a buffer.
-TEST_P(DepthStencilCopyTests, FromDepthAspect) {
-    constexpr uint32_t kWidth = 4;
-    constexpr uint32_t kHeight = 4;
-
-    wgpu::Texture depthTexture = CreateDepthTexture(
-        kWidth, kHeight, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc);
-
-    InitializeDepthTextureRegion(depthTexture, 0.f, 0.3f);
-
-    // This expectation is the test as it performs the CopyTextureToBuffer.
-    std::vector<float> expectedData = {
-        0.0, 0.0, 0.0, 0.0,  //
-        0.0, 0.0, 0.0, 0.0,  //
-        0.3, 0.3, 0.0, 0.0,  //
-        0.3, 0.3, 0.0, 0.0,  //
-    };
-    EXPECT_TEXTURE_EQ(expectedData.data(), depthTexture, {0, 0}, {kWidth, kHeight}, 0,
-                      wgpu::TextureAspect::DepthOnly);
-}
-
-// Test copying the stencil-only aspect into a buffer.
-TEST_P(DepthStencilCopyTests, FromStencilAspect) {
-    // TODO(crbug.com/dawn/667): Work around the fact that some platforms are unable to read
-    // stencil.
-    DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("disable_depth_stencil_read"));
-
-    constexpr uint32_t kWidth = 4;
-    constexpr uint32_t kHeight = 4;
-
-    wgpu::Texture depthStencilTexture = CreateDepthStencilTexture(
-        kWidth, kHeight, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc);
-
-    InitializeDepthStencilTextureRegion(depthStencilTexture, 0.f, 0.3f, 0u, 1u);
-
-    // This expectation is the test as it performs the CopyTextureToBuffer.
-    std::vector<uint8_t> expectedData = {
-        0u, 0u, 0u, 0u,  //
-        0u, 0u, 0u, 0u,  //
-        1u, 1u, 0u, 0u,  //
-        1u, 1u, 0u, 0u,  //
-    };
-    EXPECT_TEXTURE_EQ(expectedData.data(), depthStencilTexture, {0, 0}, {kWidth, kHeight}, 0,
-                      wgpu::TextureAspect::StencilOnly);
-}
-
-// Test copying the non-zero mip, stencil-only aspect into a buffer.
-TEST_P(DepthStencilCopyTests, FromNonZeroMipStencilAspect) {
-    // TODO(crbug.com/dawn/704): Readback after clear via stencil copy does not work
-    // on some Intel drivers.
-    DAWN_SUPPRESS_TEST_IF(IsMetal() && IsIntel());
-
-    // TODO(crbug.com/dawn/667): Work around some platforms' inability to read back stencil.
-    DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("disable_depth_stencil_read"));
-
-    wgpu::Texture depthStencilTexture = CreateDepthStencilTexture(
-        9, 9, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc, 2);
-
-    InitializeDepthStencilTextureRegion(depthStencilTexture, 0.f, 0.3f, 0u, 1u, 1u);
-
-    // This expectation is the test as it performs the CopyTextureToBuffer.
-    std::vector<uint8_t> expectedData = {
-        0u, 0u, 0u, 0u,  //
-        0u, 0u, 0u, 0u,  //
-        1u, 1u, 0u, 0u,  //
-        1u, 1u, 0u, 0u,  //
-    };
-    EXPECT_TEXTURE_EQ(expectedData.data(), depthStencilTexture, {0, 0}, {4, 4}, 1,
-                      wgpu::TextureAspect::StencilOnly);
-}
-
-// Test copying the non-zero mip, depth-only aspect into a buffer.
-TEST_P(DepthStencilCopyTests, FromNonZeroMipDepthAspect) {
-    wgpu::Texture depthTexture = CreateDepthTexture(
-        9, 9, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc, 2);
-
-    InitializeDepthTextureRegion(depthTexture, 0.f, 0.4f, 1);
-
-    // This expectation is the test as it performs the CopyTextureToBuffer.
-    std::vector<float> expectedData = {
-        0.0, 0.0, 0.0, 0.0,  //
-        0.0, 0.0, 0.0, 0.0,  //
-        0.4, 0.4, 0.0, 0.0,  //
-        0.4, 0.4, 0.0, 0.0,  //
-    };
-    EXPECT_TEXTURE_EQ(expectedData.data(), depthTexture, {0, 0}, {4, 4}, 1,
-                      wgpu::TextureAspect::DepthOnly);
-}
-
 // Test copying both aspects in a T2T copy, then copying only stencil.
 TEST_P(DepthStencilCopyTests, T2TBothAspectsThenCopyStencil) {
     // TODO(crbug.com/dawn/704): Readback after clear via stencil copy does not work
@@ -354,6 +324,8 @@
 
 // Test copying both aspects in a T2T copy, then copying only depth.
 TEST_P(DepthStencilCopyTests, T2TBothAspectsThenCopyDepth) {
+    DAWN_TEST_UNSUPPORTED_IF(!IsValidDepthCopyTextureFormat());
+
     constexpr uint32_t kWidth = 4;
     constexpr uint32_t kHeight = 4;
 
@@ -361,8 +333,7 @@
         0.1f, 0.3f, 1u, 3u, kWidth, kHeight, wgpu::TextureUsage::RenderAttachment);
 
     // Check the depth
-    ExpectAttachmentDepthTestData(texture, wgpu::TextureFormat::Depth24PlusStencil8, kWidth,
-                                  kHeight, 0, 0,
+    ExpectAttachmentDepthTestData(texture, GetParam().mTextureFormat, kWidth, kHeight, 0, 0,
                                   {
                                       0.1, 0.1, 0.1, 0.1,  //
                                       0.1, 0.1, 0.1, 0.1,  //
@@ -373,11 +344,13 @@
 
 // Test copying both aspects in a T2T copy, then copying only depth at a nonzero mip.
 TEST_P(DepthStencilCopyTests, T2TBothAspectsThenCopyNonZeroMipDepth) {
+    DAWN_TEST_UNSUPPORTED_IF(!IsValidDepthCopyTextureFormat());
+
     wgpu::Texture texture = CreateInitializeDepthStencilTextureAndCopyT2T(
         0.1f, 0.3f, 1u, 3u, 8, 8, wgpu::TextureUsage::RenderAttachment, 1);
 
     // Check the depth
-    ExpectAttachmentDepthTestData(texture, wgpu::TextureFormat::Depth24PlusStencil8, 4, 4, 0, 1,
+    ExpectAttachmentDepthTestData(texture, GetParam().mTextureFormat, 4, 4, 0, 1,
                                   {
                                       0.1, 0.1, 0.1, 0.1,  //
                                       0.1, 0.1, 0.1, 0.1,  //
@@ -388,6 +361,8 @@
 
 // Test copying both aspects in a T2T copy, then copying stencil, then copying depth
 TEST_P(DepthStencilCopyTests, T2TBothAspectsThenCopyStencilThenDepth) {
+    DAWN_TEST_UNSUPPORTED_IF(!IsValidDepthCopyTextureFormat());
+
     // TODO(crbug.com/dawn/667): Work around some platforms' inability to read back stencil.
     DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("disable_depth_stencil_read"));
 
@@ -409,8 +384,7 @@
                       wgpu::TextureAspect::StencilOnly);
 
     // Check the depth
-    ExpectAttachmentDepthTestData(texture, wgpu::TextureFormat::Depth24PlusStencil8, kWidth,
-                                  kHeight, 0, 0,
+    ExpectAttachmentDepthTestData(texture, GetParam().mTextureFormat, kWidth, kHeight, 0, 0,
                                   {
                                       0.1, 0.1, 0.1, 0.1,  //
                                       0.1, 0.1, 0.1, 0.1,  //
@@ -421,6 +395,8 @@
 
 // Test copying both aspects in a T2T copy, then copying depth, then copying stencil
 TEST_P(DepthStencilCopyTests, T2TBothAspectsThenCopyDepthThenStencil) {
+    DAWN_TEST_UNSUPPORTED_IF(!IsValidDepthCopyTextureFormat());
+
     // TODO(crbug.com/dawn/704): Readback after clear via stencil copy does not work
     // on some Intel drivers.
     // It seems like the depth readback copy mutates the stencil because the previous
@@ -440,8 +416,7 @@
         wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::RenderAttachment);
 
     // Check the depth
-    ExpectAttachmentDepthTestData(texture, wgpu::TextureFormat::Depth24PlusStencil8, kWidth,
-                                  kHeight, 0, 0,
+    ExpectAttachmentDepthTestData(texture, GetParam().mTextureFormat, kWidth, kHeight, 0, 0,
                                   {
                                       0.1, 0.1, 0.1, 0.1,  //
                                       0.1, 0.1, 0.1, 0.1,  //
@@ -460,8 +435,137 @@
                       wgpu::TextureAspect::StencilOnly);
 }
 
+class DepthCopyTests : public DepthStencilCopyTests {};
+
+// Test copying the depth-only aspect into a buffer.
+TEST_P(DepthCopyTests, FromDepthAspect) {
+    // TODO(crbug.com/dawn/1237): Depth16Unorm test failed on OpenGL and OpenGLES which says
+    // Invalid format and type combination in glReadPixels
+    DAWN_TEST_UNSUPPORTED_IF(GetParam().mTextureFormat == wgpu::TextureFormat::Depth16Unorm &&
+                             (IsOpenGL() || IsOpenGLES()));
+
+    constexpr uint32_t kWidth = 4;
+    constexpr uint32_t kHeight = 4;
+
+    wgpu::Texture texture = CreateTexture(
+        kWidth, kHeight, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc);
+
+    constexpr float kInitDepth = 0.2f;
+    InitializeDepthTextureRegion(texture, 0.f, kInitDepth);
+
+    // This expectation is the test as it performs the CopyTextureToBuffer.
+    if (GetParam().mTextureFormat == wgpu::TextureFormat::Depth16Unorm) {
+        uint16_t expected = FloatToUnorm<uint16_t>(kInitDepth);
+        std::vector<uint16_t> expectedData = {
+            0,        0,        0, 0,  //
+            0,        0,        0, 0,  //
+            expected, expected, 0, 0,  //
+            expected, expected, 0, 0,  //
+        };
+        EXPECT_TEXTURE_EQ(expectedData.data(), texture, {0, 0}, {kWidth, kHeight}, 0,
+                          wgpu::TextureAspect::DepthOnly);
+    } else {
+        std::vector<float> expectedData = {
+            0.0,        0.0,        0.0, 0.0,  //
+            0.0,        0.0,        0.0, 0.0,  //
+            kInitDepth, kInitDepth, 0.0, 0.0,  //
+            kInitDepth, kInitDepth, 0.0, 0.0,  //
+        };
+        EXPECT_TEXTURE_EQ(expectedData.data(), texture, {0, 0}, {kWidth, kHeight}, 0,
+                          wgpu::TextureAspect::DepthOnly);
+    }
+}
+
+// Test copying the non-zero mip, depth-only aspect into a buffer.
+TEST_P(DepthCopyTests, FromNonZeroMipDepthAspect) {
+    // TODO(crbug.com/dawn/1237): Depth16Unorm test failed on OpenGL and OpenGLES which says
+    // Invalid format and type combination in glReadPixels
+    DAWN_TEST_UNSUPPORTED_IF(GetParam().mTextureFormat == wgpu::TextureFormat::Depth16Unorm &&
+                             (IsOpenGL() || IsOpenGLES()));
+
+    wgpu::Texture depthTexture = CreateDepthTexture(
+        9, 9, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc, 2);
+
+    constexpr float kInitDepth = 0.4f;
+    InitializeDepthTextureRegion(depthTexture, 0.f, kInitDepth, 1);
+
+    // This expectation is the test as it performs the CopyTextureToBuffer.
+    if (GetParam().mTextureFormat == wgpu::TextureFormat::Depth16Unorm) {
+        uint16_t expected = FloatToUnorm<uint16_t>(kInitDepth);
+        std::vector<uint16_t> expectedData = {
+            0,        0,        0, 0,  //
+            0,        0,        0, 0,  //
+            expected, expected, 0, 0,  //
+            expected, expected, 0, 0,  //
+        };
+        EXPECT_TEXTURE_EQ(expectedData.data(), depthTexture, {0, 0}, {4, 4}, 1,
+                          wgpu::TextureAspect::DepthOnly);
+    } else {
+        std::vector<float> expectedData = {
+            0.0,        0.0,        0.0, 0.0,  //
+            0.0,        0.0,        0.0, 0.0,  //
+            kInitDepth, kInitDepth, 0.0, 0.0,  //
+            kInitDepth, kInitDepth, 0.0, 0.0,  //
+        };
+        EXPECT_TEXTURE_EQ(expectedData.data(), depthTexture, {0, 0}, {4, 4}, 1,
+                          wgpu::TextureAspect::DepthOnly);
+    }
+}
+
+class StencilCopyTests : public DepthStencilCopyTests {};
+
+// Test copying the stencil-only aspect into a buffer.
+TEST_P(StencilCopyTests, FromStencilAspect) {
+    // TODO(crbug.com/dawn/667): Work around the fact that some platforms are unable to read
+    // stencil.
+    DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("disable_depth_stencil_read"));
+
+    constexpr uint32_t kWidth = 4;
+    constexpr uint32_t kHeight = 4;
+
+    wgpu::Texture depthStencilTexture = CreateDepthStencilTexture(
+        kWidth, kHeight, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc);
+
+    InitializeDepthStencilTextureRegion(depthStencilTexture, 0.f, 0.3f, 0u, 1u);
+
+    // This expectation is the test as it performs the CopyTextureToBuffer.
+    std::vector<uint8_t> expectedData = {
+        0u, 0u, 0u, 0u,  //
+        0u, 0u, 0u, 0u,  //
+        1u, 1u, 0u, 0u,  //
+        1u, 1u, 0u, 0u,  //
+    };
+    EXPECT_TEXTURE_EQ(expectedData.data(), depthStencilTexture, {0, 0}, {kWidth, kHeight}, 0,
+                      wgpu::TextureAspect::StencilOnly);
+}
+
+// Test copying the non-zero mip, stencil-only aspect into a buffer.
+TEST_P(StencilCopyTests, FromNonZeroMipStencilAspect) {
+    // TODO(crbug.com/dawn/704): Readback after clear via stencil copy does not work
+    // on some Intel drivers.
+    DAWN_SUPPRESS_TEST_IF(IsMetal() && IsIntel());
+
+    // TODO(crbug.com/dawn/667): Work around some platforms' inability to read back stencil.
+    DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("disable_depth_stencil_read"));
+
+    wgpu::Texture depthStencilTexture = CreateDepthStencilTexture(
+        9, 9, wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc, 2);
+
+    InitializeDepthStencilTextureRegion(depthStencilTexture, 0.f, 0.3f, 0u, 1u, 1u);
+
+    // This expectation is the test as it performs the CopyTextureToBuffer.
+    std::vector<uint8_t> expectedData = {
+        0u, 0u, 0u, 0u,  //
+        0u, 0u, 0u, 0u,  //
+        1u, 1u, 0u, 0u,  //
+        1u, 1u, 0u, 0u,  //
+    };
+    EXPECT_TEXTURE_EQ(expectedData.data(), depthStencilTexture, {0, 0}, {4, 4}, 1,
+                      wgpu::TextureAspect::StencilOnly);
+}
+
 // Test copying to the stencil-aspect of a buffer
-TEST_P(DepthStencilCopyTests, ToStencilAspect) {
+TEST_P(StencilCopyTests, ToStencilAspect) {
     // Copies to a single aspect are unsupported on OpenGL.
     DAWN_TEST_UNSUPPORTED_IF(IsOpenGL());
     DAWN_TEST_UNSUPPORTED_IF(IsOpenGLES());
@@ -531,7 +635,7 @@
             [[stage(fragment)]] fn main() {
             })");
         wgpu::DepthStencilState* depthStencil =
-            renderPipelineDesc.EnableDepthStencil(wgpu::TextureFormat::Depth24PlusStencil8);
+            renderPipelineDesc.EnableDepthStencil(GetParam().mTextureFormat);
         depthStencil->stencilFront.passOp = wgpu::StencilOperation::DecrementClamp;
         renderPipelineDesc.cFragment.targetCount = 0;
 
@@ -557,8 +661,8 @@
     EXPECT_TEXTURE_EQ(expectedStencilData.data(), depthStencilTexture, {0, 0}, {kWidth, kHeight}, 0,
                       wgpu::TextureAspect::StencilOnly);
 
-    ExpectAttachmentDepthTestData(depthStencilTexture, wgpu::TextureFormat::Depth24PlusStencil8,
-                                  kWidth, kHeight, 0, 0,
+    ExpectAttachmentDepthTestData(depthStencilTexture, GetParam().mTextureFormat, kWidth, kHeight,
+                                  0, 0,
                                   {
                                       0.7, 0.7, 0.7, 0.7,  //
                                       0.7, 0.7, 0.7, 0.7,  //
@@ -567,9 +671,20 @@
                                   });
 }
 
-DAWN_INSTANTIATE_TEST(DepthStencilCopyTests,
-                      D3D12Backend(),
-                      MetalBackend(),
-                      OpenGLBackend(),
-                      OpenGLESBackend(),
-                      VulkanBackend());
+DAWN_INSTANTIATE_TEST_P(DepthStencilCopyTests,
+                        {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
+                         VulkanBackend()},
+                        std::vector<wgpu::TextureFormat>(utils::kDepthAndStencilFormats.begin(),
+                                                         utils::kDepthAndStencilFormats.end()));
+
+DAWN_INSTANTIATE_TEST_P(DepthCopyTests,
+                        {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
+                         VulkanBackend()},
+                        std::vector<wgpu::TextureFormat>(kValidDepthCopyTextureFormats.begin(),
+                                                         kValidDepthCopyTextureFormats.end()));
+
+DAWN_INSTANTIATE_TEST_P(StencilCopyTests,
+                        {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
+                         VulkanBackend()},
+                        std::vector<wgpu::TextureFormat>(utils::kStencilFormats.begin(),
+                                                         utils::kStencilFormats.end()));
diff --git a/src/tests/end2end/DepthStencilLoadOpTests.cpp b/src/tests/end2end/DepthStencilLoadOpTests.cpp
index 8990408..e9b0796 100644
--- a/src/tests/end2end/DepthStencilLoadOpTests.cpp
+++ b/src/tests/end2end/DepthStencilLoadOpTests.cpp
@@ -62,6 +62,8 @@
         void SetUp() override {
             DawnTestWithParams<DepthStencilLoadOpTestParams>::SetUp();
 
+            DAWN_TEST_UNSUPPORTED_IF(!mIsFormatSupported);
+
             // Readback of Depth/Stencil textures not fully supported on GL right now.
             // Also depends on glTextureView which is not supported on ES.
             DAWN_SUPPRESS_TEST_IF(IsOpenGL() || IsOpenGLES());
@@ -91,6 +93,26 @@
             }
         }
 
+        std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
+            switch (GetParam().mFormat) {
+                case wgpu::TextureFormat::Depth24UnormStencil8:
+                    if (SupportsFeatures({wgpu::FeatureName::Depth24UnormStencil8})) {
+                        mIsFormatSupported = true;
+                        return {wgpu::FeatureName::Depth24UnormStencil8};
+                    }
+                    return {};
+                case wgpu::TextureFormat::Depth32FloatStencil8:
+                    if (SupportsFeatures({wgpu::FeatureName::Depth32FloatStencil8})) {
+                        mIsFormatSupported = true;
+                        return {wgpu::FeatureName::Depth32FloatStencil8};
+                    }
+                    return {};
+                default:
+                    mIsFormatSupported = true;
+                    return {};
+            }
+        }
+
         void CheckMipLevel(uint32_t mipLevel) {
             uint32_t mipSize = std::max(kRTSize >> mipLevel, 1u);
 
@@ -151,6 +173,9 @@
         std::array<wgpu::TextureView, kMipLevelCount> textureViews;
         // Vector instead of array because there is no default constructor.
         std::vector<utils::ComboRenderPassDescriptor> renderPassDescriptors;
+
+      private:
+        bool mIsFormatSupported = false;
     };
 
 }  // anonymous namespace
@@ -240,7 +265,8 @@
         auto params2 = MakeParamGenerator<DepthStencilLoadOpTestParams>(
             {D3D12Backend(), D3D12Backend({}, {"use_d3d12_render_pass"}), MetalBackend(),
              OpenGLBackend(), OpenGLESBackend(), VulkanBackend()},
-            {wgpu::TextureFormat::Depth24PlusStencil8},
+            {wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureFormat::Depth24UnormStencil8,
+             wgpu::TextureFormat::Depth32FloatStencil8},
             {Check::CopyStencil, Check::StencilTest, Check::DepthTest, Check::SampleDepth});
 
         std::vector<DepthStencilLoadOpTestParams> allParams;
diff --git a/src/tests/end2end/DepthStencilSamplingTests.cpp b/src/tests/end2end/DepthStencilSamplingTests.cpp
index 7ac870a..872e6d7 100644
--- a/src/tests/end2end/DepthStencilSamplingTests.cpp
+++ b/src/tests/end2end/DepthStencilSamplingTests.cpp
@@ -18,17 +18,8 @@
 #include "utils/WGPUHelpers.h"
 
 namespace {
-
-    constexpr wgpu::TextureFormat kDepthFormats[] = {
-        wgpu::TextureFormat::Depth32Float,
-        wgpu::TextureFormat::Depth24Plus,
-        wgpu::TextureFormat::Depth24PlusStencil8,
-        wgpu::TextureFormat::Depth16Unorm,
-    };
-
-    constexpr wgpu::TextureFormat kStencilFormats[] = {
-        wgpu::TextureFormat::Depth24PlusStencil8,
-    };
+    using TextureFormat = wgpu::TextureFormat;
+    DAWN_TEST_PARAM_STRUCT(DepthStencilSamplingTestParams, TextureFormat);
 
     constexpr wgpu::CompareFunction kCompareFunctions[] = {
         wgpu::CompareFunction::Never,        wgpu::CompareFunction::Less,
@@ -48,7 +39,7 @@
 
 }  // anonymous namespace
 
-class DepthStencilSamplingTest : public DawnTest {
+class DepthStencilSamplingTest : public DawnTestWithParams<DepthStencilSamplingTestParams> {
   protected:
     enum class TestAspect {
         Depth,
@@ -56,7 +47,9 @@
     };
 
     void SetUp() override {
-        DawnTest::SetUp();
+        DawnTestWithParams<DepthStencilSamplingTestParams>::SetUp();
+
+        DAWN_TEST_UNSUPPORTED_IF(!mIsFormatSupported);
 
         wgpu::BufferDescriptor uniformBufferDesc;
         uniformBufferDesc.usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst;
@@ -64,6 +57,26 @@
         mUniformBuffer = device.CreateBuffer(&uniformBufferDesc);
     }
 
+    std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
+        switch (GetParam().mTextureFormat) {
+            case wgpu::TextureFormat::Depth24UnormStencil8:
+                if (SupportsFeatures({wgpu::FeatureName::Depth24UnormStencil8})) {
+                    mIsFormatSupported = true;
+                    return {wgpu::FeatureName::Depth24UnormStencil8};
+                }
+                return {};
+            case wgpu::TextureFormat::Depth32FloatStencil8:
+                if (SupportsFeatures({wgpu::FeatureName::Depth32FloatStencil8})) {
+                    mIsFormatSupported = true;
+                    return {wgpu::FeatureName::Depth32FloatStencil8};
+                }
+                return {};
+            default:
+                mIsFormatSupported = true;
+                return {};
+        }
+    }
+
     void GenerateSamplingShader(const std::vector<TestAspect>& aspects,
                                 const std::vector<uint32_t> components,
                                 std::ostringstream& shaderSource,
@@ -581,58 +594,39 @@
 
   private:
     wgpu::Buffer mUniformBuffer;
+    bool mIsFormatSupported = false;
 };
 
-// Test that sampling a depth texture with a render/compute pipeline works
-TEST_P(DepthStencilSamplingTest, SampleDepth) {
-    for (wgpu::TextureFormat format : kDepthFormats) {
-        float tolerance = 0.0f;
-        if (format == wgpu::TextureFormat::Depth16Unorm) {
-            tolerance = 0.001f;
-        }
-        // Test 0, between [0, 1], and 1.
-        DoSamplingTest(TestAspect::Depth, CreateSamplingRenderPipeline({TestAspect::Depth}, 0),
-                       format, kNormalizedTextureValues, tolerance);
-
-        DoSamplingTest(TestAspect::Depth, CreateSamplingComputePipeline({TestAspect::Depth}, 0),
-                       format, kNormalizedTextureValues, tolerance);
-    }
-}
-
-// Test that sampling a stencil texture with a render/compute pipeline works
-TEST_P(DepthStencilSamplingTest, SampleStencil) {
-    // TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
-    DAWN_TEST_UNSUPPORTED_IF(IsOpenGLES());
-    for (wgpu::TextureFormat format : kStencilFormats) {
-        DoSamplingTest(TestAspect::Stencil, CreateSamplingRenderPipeline({TestAspect::Stencil}, 0),
-                       format, kStencilValues);
-
-        DoSamplingTest(TestAspect::Stencil, CreateSamplingComputePipeline({TestAspect::Stencil}, 0),
-                       format, kStencilValues);
-    }
-}
-
 // Test that sampling a depth/stencil texture at components 1, 2, and 3 yield 0, 0, and 1
 // respectively
 TEST_P(DepthStencilSamplingTest, SampleExtraComponents) {
     // TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
     DAWN_TEST_UNSUPPORTED_IF(IsOpenGLES());
 
-    DoSamplingExtraStencilComponentsRenderTest(
-        TestAspect::Stencil, wgpu::TextureFormat::Depth24PlusStencil8, {uint8_t(42), uint8_t(37)});
+    wgpu::TextureFormat format = GetParam().mTextureFormat;
 
-    DoSamplingExtraStencilComponentsComputeTest(
-        TestAspect::Stencil, wgpu::TextureFormat::Depth24PlusStencil8, {uint8_t(42), uint8_t(37)});
+    // TODO(crbug.com/dawn/1239): depth24unorm-stencil8 fails on D3D12 Nvidia old driver version.
+    DAWN_SUPPRESS_TEST_IF(format == wgpu::TextureFormat::Depth24UnormStencil8 && IsD3D12() &&
+                          IsNvidia());
+
+    DoSamplingExtraStencilComponentsRenderTest(TestAspect::Stencil, format,
+                                               {uint8_t(42), uint8_t(37)});
+
+    DoSamplingExtraStencilComponentsComputeTest(TestAspect::Stencil, format,
+                                                {uint8_t(42), uint8_t(37)});
 }
 
 // Test sampling both depth and stencil with a render/compute pipeline works.
 TEST_P(DepthStencilSamplingTest, SampleDepthAndStencilRender) {
     // TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
     DAWN_TEST_UNSUPPORTED_IF(IsOpenGLES());
+
+    wgpu::TextureFormat format = GetParam().mTextureFormat;
+
     wgpu::SamplerDescriptor samplerDesc;
     wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
 
-    wgpu::Texture inputTexture = CreateInputTexture(wgpu::TextureFormat::Depth24PlusStencil8);
+    wgpu::Texture inputTexture = CreateInputTexture(format);
 
     wgpu::TextureViewDescriptor depthViewDesc = {};
     depthViewDesc.aspect = wgpu::TextureAspect::DepthOnly;
@@ -640,6 +634,8 @@
     wgpu::TextureViewDescriptor stencilViewDesc = {};
     stencilViewDesc.aspect = wgpu::TextureAspect::StencilOnly;
 
+    float tolerance = format == wgpu::TextureFormat::Depth24UnormStencil8 ? 0.001f : 0.0f;
+
     // With render pipeline
     {
         wgpu::RenderPipeline pipeline =
@@ -682,15 +678,16 @@
         wgpu::CommandBuffer commands = commandEncoder.Finish();
         queue.Submit(1, &commands);
 
-        uint32_t expectedValueU32 = 0;
-        memcpy(&expectedValueU32, &passDescriptor.cDepthStencilAttachmentInfo.clearDepth,
+        float expectedDepth = 0.0f;
+        memcpy(&expectedDepth, &passDescriptor.cDepthStencilAttachmentInfo.clearDepth,
                sizeof(float));
-        EXPECT_BUFFER_U32_EQ(expectedValueU32, depthOutput, 0);
+        EXPECT_BUFFER(depthOutput, 0, sizeof(float),
+                      new ::detail::ExpectEq<float>(expectedDepth, tolerance));
 
-        expectedValueU32 = 0;
-        memcpy(&expectedValueU32, &passDescriptor.cDepthStencilAttachmentInfo.clearStencil,
+        uint8_t expectedStencil = 0;
+        memcpy(&expectedStencil, &passDescriptor.cDepthStencilAttachmentInfo.clearStencil,
                sizeof(uint8_t));
-        EXPECT_BUFFER_U32_EQ(expectedValueU32, stencilOutput, 0);
+        EXPECT_BUFFER_U32_EQ(expectedStencil, stencilOutput, 0);
     }
 
     // With compute pipeline
@@ -729,44 +726,89 @@
         wgpu::CommandBuffer commands = commandEncoder.Finish();
         queue.Submit(1, &commands);
 
-        uint32_t expectedValueU32 = 0;
-        memcpy(&expectedValueU32, &passDescriptor.cDepthStencilAttachmentInfo.clearDepth,
+        float expectedDepth = 0.0f;
+        memcpy(&expectedDepth, &passDescriptor.cDepthStencilAttachmentInfo.clearDepth,
                sizeof(float));
-        EXPECT_BUFFER_U32_EQ(expectedValueU32, depthOutput, 0);
+        EXPECT_BUFFER(depthOutput, 0, sizeof(float),
+                      new ::detail::ExpectEq<float>(expectedDepth, tolerance));
 
-        expectedValueU32 = 0;
-        memcpy(&expectedValueU32, &passDescriptor.cDepthStencilAttachmentInfo.clearStencil,
+        uint8_t expectedStencil = 0;
+        memcpy(&expectedStencil, &passDescriptor.cDepthStencilAttachmentInfo.clearStencil,
                sizeof(uint8_t));
-        EXPECT_BUFFER_U32_EQ(expectedValueU32, stencilOutput, 0);
+        EXPECT_BUFFER_U32_EQ(expectedStencil, stencilOutput, 0);
     }
 }
 
+class DepthSamplingTest : public DepthStencilSamplingTest {};
+
+// Test that sampling a depth texture with a render/compute pipeline works
+TEST_P(DepthSamplingTest, SampleDepthOnly) {
+    wgpu::TextureFormat format = GetParam().mTextureFormat;
+    float tolerance = format == wgpu::TextureFormat::Depth16Unorm ||
+                              format == wgpu::TextureFormat::Depth24UnormStencil8
+                          ? 0.001f
+                          : 0.0f;
+
+    // Test 0, between [0, 1], and 1.
+    DoSamplingTest(TestAspect::Depth, CreateSamplingRenderPipeline({TestAspect::Depth}, 0), format,
+                   kNormalizedTextureValues, tolerance);
+
+    DoSamplingTest(TestAspect::Depth, CreateSamplingComputePipeline({TestAspect::Depth}, 0), format,
+                   kNormalizedTextureValues, tolerance);
+}
+
 // Test that sampling in a render pipeline with all of the compare functions works.
-TEST_P(DepthStencilSamplingTest, CompareFunctionsRender) {
+TEST_P(DepthSamplingTest, CompareFunctionsRender) {
     // Initialization via renderPass loadOp doesn't work on Mac Intel.
     DAWN_SUPPRESS_TEST_IF(IsMetal() && IsIntel());
 
+    wgpu::TextureFormat format = GetParam().mTextureFormat;
+    // Test does not account for precision issues when comparison testing Depth16Unorm and
+    // Depth24UnormStencil8.
+    DAWN_TEST_UNSUPPORTED_IF(format == wgpu::TextureFormat::Depth16Unorm ||
+                             format == wgpu::TextureFormat::Depth24UnormStencil8);
+
     wgpu::RenderPipeline pipeline = CreateComparisonRenderPipeline();
 
-    for (wgpu::TextureFormat format : kDepthFormats) {
-        // Test does not account for precision issues when comparison testing Depth16Unorm.
-        if (format == wgpu::TextureFormat::Depth16Unorm) {
-            continue;
-        }
-
-        // Test a "normal" ref value between 0 and 1; as well as negative and > 1 refs.
-        for (float compareRef : kCompareRefs) {
-            // Test 0, below the ref, equal to, above the ref, and 1.
-            for (wgpu::CompareFunction f : kCompareFunctions) {
-                DoDepthCompareRefTest(pipeline, format, compareRef, f, kNormalizedTextureValues);
-            }
+    // Test a "normal" ref value between 0 and 1; as well as negative and > 1 refs.
+    for (float compareRef : kCompareRefs) {
+        // Test 0, below the ref, equal to, above the ref, and 1.
+        for (wgpu::CompareFunction f : kCompareFunctions) {
+            DoDepthCompareRefTest(pipeline, format, compareRef, f, kNormalizedTextureValues);
         }
     }
 }
 
-DAWN_INSTANTIATE_TEST(DepthStencilSamplingTest,
-                      D3D12Backend(),
-                      MetalBackend(),
-                      OpenGLBackend(),
-                      OpenGLESBackend(),
-                      VulkanBackend());
+class StencilSamplingTest : public DepthStencilSamplingTest {};
+
+// Test that sampling a stencil texture with a render/compute pipeline works
+TEST_P(StencilSamplingTest, SampleStencilOnly) {
+    // TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
+    DAWN_TEST_UNSUPPORTED_IF(IsOpenGLES());
+
+    wgpu::TextureFormat format = GetParam().mTextureFormat;
+
+    DoSamplingTest(TestAspect::Stencil, CreateSamplingRenderPipeline({TestAspect::Stencil}, 0),
+                   format, kStencilValues);
+
+    DoSamplingTest(TestAspect::Stencil, CreateSamplingComputePipeline({TestAspect::Stencil}, 0),
+                   format, kStencilValues);
+}
+
+DAWN_INSTANTIATE_TEST_P(DepthStencilSamplingTest,
+                        {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
+                         VulkanBackend()},
+                        std::vector<wgpu::TextureFormat>(utils::kDepthAndStencilFormats.begin(),
+                                                         utils::kDepthAndStencilFormats.end()));
+
+DAWN_INSTANTIATE_TEST_P(DepthSamplingTest,
+                        {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
+                         VulkanBackend()},
+                        std::vector<wgpu::TextureFormat>(utils::kDepthFormats.begin(),
+                                                         utils::kDepthFormats.end()));
+
+DAWN_INSTANTIATE_TEST_P(StencilSamplingTest,
+                        {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
+                         VulkanBackend()},
+                        std::vector<wgpu::TextureFormat>(utils::kStencilFormats.begin(),
+                                                         utils::kStencilFormats.end()));
diff --git a/src/tests/unittests/MathTests.cpp b/src/tests/unittests/MathTests.cpp
index 031c716..6517d06 100644
--- a/src/tests/unittests/MathTests.cpp
+++ b/src/tests/unittests/MathTests.cpp
@@ -249,6 +249,19 @@
     ASSERT_TRUE(IsFloat16NaN(0xFFFF));
 }
 
+// Tests for FloatToUnorm
+TEST(Math, FloatToUnorm) {
+    std::vector<float> kTestFloatValues = {0.0f, 0.4f, 0.5f, 1.0f};
+    std::vector<unsigned char> kExpectedCharValues = {0, 102, 127, 255};
+    std::vector<uint8_t> kExpectedUint8Values = {0, 102, 127, 255};
+    std::vector<uint16_t> kExpectedUint16Values = {0, 26214, 32767, 65535};
+    for (size_t i = 0; i < kTestFloatValues.size(); i++) {
+        ASSERT_EQ(FloatToUnorm<unsigned char>(kTestFloatValues[i]), kExpectedCharValues[i]);
+        ASSERT_EQ(FloatToUnorm<uint8_t>(kTestFloatValues[i]), kExpectedUint8Values[i]);
+        ASSERT_EQ(FloatToUnorm<uint16_t>(kTestFloatValues[i]), kExpectedUint16Values[i]);
+    }
+}
+
 // Tests for SRGBToLinear
 TEST(Math, SRGBToLinear) {
     ASSERT_EQ(SRGBToLinear(0.0f), 0.0f);