diff --git a/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state-expected.txt b/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state-expected.txt
index d57df051867ad..a1f1007400b61 100644
--- a/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state-expected.txt
+++ b/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state-expected.txt
@@ -1 +1,1214 @@
-(Populate me when we're ready to investigate this test)
+
+PASS :format:isAsync=false;format="r8unorm"
+PASS :format:isAsync=false;format="r8snorm"
+PASS :format:isAsync=false;format="r8uint"
+PASS :format:isAsync=false;format="r8sint"
+PASS :format:isAsync=false;format="rg8unorm"
+PASS :format:isAsync=false;format="rg8snorm"
+PASS :format:isAsync=false;format="rg8uint"
+PASS :format:isAsync=false;format="rg8sint"
+PASS :format:isAsync=false;format="rgba8unorm"
+PASS :format:isAsync=false;format="rgba8unorm-srgb"
+PASS :format:isAsync=false;format="rgba8snorm"
+PASS :format:isAsync=false;format="rgba8uint"
+PASS :format:isAsync=false;format="rgba8sint"
+PASS :format:isAsync=false;format="bgra8unorm"
+PASS :format:isAsync=false;format="bgra8unorm-srgb"
+PASS :format:isAsync=false;format="r16uint"
+PASS :format:isAsync=false;format="r16sint"
+PASS :format:isAsync=false;format="r16float"
+PASS :format:isAsync=false;format="rg16uint"
+PASS :format:isAsync=false;format="rg16sint"
+PASS :format:isAsync=false;format="rg16float"
+PASS :format:isAsync=false;format="rgba16uint"
+PASS :format:isAsync=false;format="rgba16sint"
+PASS :format:isAsync=false;format="rgba16float"
+PASS :format:isAsync=false;format="r32uint"
+PASS :format:isAsync=false;format="r32sint"
+PASS :format:isAsync=false;format="r32float"
+PASS :format:isAsync=false;format="rg32uint"
+PASS :format:isAsync=false;format="rg32sint"
+PASS :format:isAsync=false;format="rg32float"
+PASS :format:isAsync=false;format="rgba32uint"
+PASS :format:isAsync=false;format="rgba32sint"
+PASS :format:isAsync=false;format="rgba32float"
+PASS :format:isAsync=false;format="rgb10a2uint"
+PASS :format:isAsync=false;format="rgb10a2unorm"
+PASS :format:isAsync=false;format="rg11b10ufloat"
+PASS :format:isAsync=false;format="rgb9e5ufloat"
+PASS :format:isAsync=false;format="stencil8"
+PASS :format:isAsync=false;format="depth16unorm"
+PASS :format:isAsync=false;format="depth32float"
+PASS :format:isAsync=false;format="depth24plus"
+PASS :format:isAsync=false;format="depth24plus-stencil8"
+PASS :format:isAsync=false;format="depth32float-stencil8"
+PASS :format:isAsync=false;format="bc1-rgba-unorm"
+PASS :format:isAsync=false;format="bc1-rgba-unorm-srgb"
+PASS :format:isAsync=false;format="bc2-rgba-unorm"
+PASS :format:isAsync=false;format="bc2-rgba-unorm-srgb"
+PASS :format:isAsync=false;format="bc3-rgba-unorm"
+PASS :format:isAsync=false;format="bc3-rgba-unorm-srgb"
+PASS :format:isAsync=false;format="bc4-r-unorm"
+PASS :format:isAsync=false;format="bc4-r-snorm"
+PASS :format:isAsync=false;format="bc5-rg-unorm"
+PASS :format:isAsync=false;format="bc5-rg-snorm"
+PASS :format:isAsync=false;format="bc6h-rgb-ufloat"
+PASS :format:isAsync=false;format="bc6h-rgb-float"
+PASS :format:isAsync=false;format="bc7-rgba-unorm"
+PASS :format:isAsync=false;format="bc7-rgba-unorm-srgb"
+PASS :format:isAsync=false;format="etc2-rgb8unorm"
+PASS :format:isAsync=false;format="etc2-rgb8unorm-srgb"
+PASS :format:isAsync=false;format="etc2-rgb8a1unorm"
+PASS :format:isAsync=false;format="etc2-rgb8a1unorm-srgb"
+PASS :format:isAsync=false;format="etc2-rgba8unorm"
+PASS :format:isAsync=false;format="etc2-rgba8unorm-srgb"
+PASS :format:isAsync=false;format="eac-r11unorm"
+PASS :format:isAsync=false;format="eac-r11snorm"
+PASS :format:isAsync=false;format="eac-rg11unorm"
+PASS :format:isAsync=false;format="eac-rg11snorm"
+PASS :format:isAsync=false;format="astc-4x4-unorm"
+PASS :format:isAsync=false;format="astc-4x4-unorm-srgb"
+PASS :format:isAsync=false;format="astc-5x4-unorm"
+PASS :format:isAsync=false;format="astc-5x4-unorm-srgb"
+PASS :format:isAsync=false;format="astc-5x5-unorm"
+PASS :format:isAsync=false;format="astc-5x5-unorm-srgb"
+PASS :format:isAsync=false;format="astc-6x5-unorm"
+PASS :format:isAsync=false;format="astc-6x5-unorm-srgb"
+PASS :format:isAsync=false;format="astc-6x6-unorm"
+PASS :format:isAsync=false;format="astc-6x6-unorm-srgb"
+PASS :format:isAsync=false;format="astc-8x5-unorm"
+PASS :format:isAsync=false;format="astc-8x5-unorm-srgb"
+PASS :format:isAsync=false;format="astc-8x6-unorm"
+PASS :format:isAsync=false;format="astc-8x6-unorm-srgb"
+PASS :format:isAsync=false;format="astc-8x8-unorm"
+PASS :format:isAsync=false;format="astc-8x8-unorm-srgb"
+PASS :format:isAsync=false;format="astc-10x5-unorm"
+PASS :format:isAsync=false;format="astc-10x5-unorm-srgb"
+PASS :format:isAsync=false;format="astc-10x6-unorm"
+PASS :format:isAsync=false;format="astc-10x6-unorm-srgb"
+PASS :format:isAsync=false;format="astc-10x8-unorm"
+PASS :format:isAsync=false;format="astc-10x8-unorm-srgb"
+PASS :format:isAsync=false;format="astc-10x10-unorm"
+PASS :format:isAsync=false;format="astc-10x10-unorm-srgb"
+PASS :format:isAsync=false;format="astc-12x10-unorm"
+PASS :format:isAsync=false;format="astc-12x10-unorm-srgb"
+PASS :format:isAsync=false;format="astc-12x12-unorm"
+PASS :format:isAsync=false;format="astc-12x12-unorm-srgb"
+PASS :format:isAsync=true;format="r8unorm"
+PASS :format:isAsync=true;format="r8snorm"
+PASS :format:isAsync=true;format="r8uint"
+PASS :format:isAsync=true;format="r8sint"
+PASS :format:isAsync=true;format="rg8unorm"
+PASS :format:isAsync=true;format="rg8snorm"
+PASS :format:isAsync=true;format="rg8uint"
+PASS :format:isAsync=true;format="rg8sint"
+PASS :format:isAsync=true;format="rgba8unorm"
+PASS :format:isAsync=true;format="rgba8unorm-srgb"
+PASS :format:isAsync=true;format="rgba8snorm"
+PASS :format:isAsync=true;format="rgba8uint"
+PASS :format:isAsync=true;format="rgba8sint"
+PASS :format:isAsync=true;format="bgra8unorm"
+PASS :format:isAsync=true;format="bgra8unorm-srgb"
+PASS :format:isAsync=true;format="r16uint"
+PASS :format:isAsync=true;format="r16sint"
+PASS :format:isAsync=true;format="r16float"
+PASS :format:isAsync=true;format="rg16uint"
+PASS :format:isAsync=true;format="rg16sint"
+PASS :format:isAsync=true;format="rg16float"
+PASS :format:isAsync=true;format="rgba16uint"
+PASS :format:isAsync=true;format="rgba16sint"
+PASS :format:isAsync=true;format="rgba16float"
+PASS :format:isAsync=true;format="r32uint"
+PASS :format:isAsync=true;format="r32sint"
+PASS :format:isAsync=true;format="r32float"
+PASS :format:isAsync=true;format="rg32uint"
+PASS :format:isAsync=true;format="rg32sint"
+PASS :format:isAsync=true;format="rg32float"
+PASS :format:isAsync=true;format="rgba32uint"
+PASS :format:isAsync=true;format="rgba32sint"
+PASS :format:isAsync=true;format="rgba32float"
+PASS :format:isAsync=true;format="rgb10a2uint"
+PASS :format:isAsync=true;format="rgb10a2unorm"
+PASS :format:isAsync=true;format="rg11b10ufloat"
+PASS :format:isAsync=true;format="rgb9e5ufloat"
+PASS :format:isAsync=true;format="stencil8"
+PASS :format:isAsync=true;format="depth16unorm"
+PASS :format:isAsync=true;format="depth32float"
+PASS :format:isAsync=true;format="depth24plus"
+PASS :format:isAsync=true;format="depth24plus-stencil8"
+PASS :format:isAsync=true;format="depth32float-stencil8"
+PASS :format:isAsync=true;format="bc1-rgba-unorm"
+PASS :format:isAsync=true;format="bc1-rgba-unorm-srgb"
+PASS :format:isAsync=true;format="bc2-rgba-unorm"
+PASS :format:isAsync=true;format="bc2-rgba-unorm-srgb"
+PASS :format:isAsync=true;format="bc3-rgba-unorm"
+PASS :format:isAsync=true;format="bc3-rgba-unorm-srgb"
+PASS :format:isAsync=true;format="bc4-r-unorm"
+PASS :format:isAsync=true;format="bc4-r-snorm"
+PASS :format:isAsync=true;format="bc5-rg-unorm"
+PASS :format:isAsync=true;format="bc5-rg-snorm"
+PASS :format:isAsync=true;format="bc6h-rgb-ufloat"
+PASS :format:isAsync=true;format="bc6h-rgb-float"
+PASS :format:isAsync=true;format="bc7-rgba-unorm"
+PASS :format:isAsync=true;format="bc7-rgba-unorm-srgb"
+PASS :format:isAsync=true;format="etc2-rgb8unorm"
+PASS :format:isAsync=true;format="etc2-rgb8unorm-srgb"
+PASS :format:isAsync=true;format="etc2-rgb8a1unorm"
+PASS :format:isAsync=true;format="etc2-rgb8a1unorm-srgb"
+PASS :format:isAsync=true;format="etc2-rgba8unorm"
+PASS :format:isAsync=true;format="etc2-rgba8unorm-srgb"
+PASS :format:isAsync=true;format="eac-r11unorm"
+PASS :format:isAsync=true;format="eac-r11snorm"
+PASS :format:isAsync=true;format="eac-rg11unorm"
+PASS :format:isAsync=true;format="eac-rg11snorm"
+PASS :format:isAsync=true;format="astc-4x4-unorm"
+PASS :format:isAsync=true;format="astc-4x4-unorm-srgb"
+PASS :format:isAsync=true;format="astc-5x4-unorm"
+PASS :format:isAsync=true;format="astc-5x4-unorm-srgb"
+PASS :format:isAsync=true;format="astc-5x5-unorm"
+PASS :format:isAsync=true;format="astc-5x5-unorm-srgb"
+PASS :format:isAsync=true;format="astc-6x5-unorm"
+PASS :format:isAsync=true;format="astc-6x5-unorm-srgb"
+PASS :format:isAsync=true;format="astc-6x6-unorm"
+PASS :format:isAsync=true;format="astc-6x6-unorm-srgb"
+PASS :format:isAsync=true;format="astc-8x5-unorm"
+PASS :format:isAsync=true;format="astc-8x5-unorm-srgb"
+PASS :format:isAsync=true;format="astc-8x6-unorm"
+PASS :format:isAsync=true;format="astc-8x6-unorm-srgb"
+PASS :format:isAsync=true;format="astc-8x8-unorm"
+PASS :format:isAsync=true;format="astc-8x8-unorm-srgb"
+PASS :format:isAsync=true;format="astc-10x5-unorm"
+PASS :format:isAsync=true;format="astc-10x5-unorm-srgb"
+PASS :format:isAsync=true;format="astc-10x6-unorm"
+PASS :format:isAsync=true;format="astc-10x6-unorm-srgb"
+PASS :format:isAsync=true;format="astc-10x8-unorm"
+PASS :format:isAsync=true;format="astc-10x8-unorm-srgb"
+PASS :format:isAsync=true;format="astc-10x10-unorm"
+PASS :format:isAsync=true;format="astc-10x10-unorm-srgb"
+PASS :format:isAsync=true;format="astc-12x10-unorm"
+PASS :format:isAsync=true;format="astc-12x10-unorm-srgb"
+PASS :format:isAsync=true;format="astc-12x12-unorm"
+PASS :format:isAsync=true;format="astc-12x12-unorm-srgb"
+PASS :depthCompare_optional:isAsync=false;format="stencil8"
+PASS :depthCompare_optional:isAsync=false;format="depth16unorm"
+PASS :depthCompare_optional:isAsync=false;format="depth32float"
+PASS :depthCompare_optional:isAsync=false;format="depth24plus"
+PASS :depthCompare_optional:isAsync=false;format="depth24plus-stencil8"
+PASS :depthCompare_optional:isAsync=false;format="depth32float-stencil8"
+PASS :depthCompare_optional:isAsync=true;format="stencil8"
+PASS :depthCompare_optional:isAsync=true;format="depth16unorm"
+PASS :depthCompare_optional:isAsync=true;format="depth32float"
+PASS :depthCompare_optional:isAsync=true;format="depth24plus"
+PASS :depthCompare_optional:isAsync=true;format="depth24plus-stencil8"
+PASS :depthCompare_optional:isAsync=true;format="depth32float-stencil8"
+PASS :depthWriteEnabled_optional:isAsync=false;format="stencil8"
+PASS :depthWriteEnabled_optional:isAsync=false;format="depth16unorm"
+PASS :depthWriteEnabled_optional:isAsync=false;format="depth32float"
+PASS :depthWriteEnabled_optional:isAsync=false;format="depth24plus"
+PASS :depthWriteEnabled_optional:isAsync=false;format="depth24plus-stencil8"
+PASS :depthWriteEnabled_optional:isAsync=false;format="depth32float-stencil8"
+PASS :depthWriteEnabled_optional:isAsync=true;format="stencil8"
+PASS :depthWriteEnabled_optional:isAsync=true;format="depth16unorm"
+PASS :depthWriteEnabled_optional:isAsync=true;format="depth32float"
+PASS :depthWriteEnabled_optional:isAsync=true;format="depth24plus"
+PASS :depthWriteEnabled_optional:isAsync=true;format="depth24plus-stencil8"
+PASS :depthWriteEnabled_optional:isAsync=true;format="depth32float-stencil8"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="never"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="less"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="equal"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="less-equal"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="greater"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="not-equal"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="greater-equal"
+PASS :depth_test:isAsync=false;format="stencil8";depthCompare="always"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="never"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="less"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="equal"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="less-equal"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="greater"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="not-equal"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="greater-equal"
+PASS :depth_test:isAsync=false;format="depth16unorm";depthCompare="always"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="never"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="less"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="equal"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="less-equal"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="greater"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="not-equal"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="greater-equal"
+PASS :depth_test:isAsync=false;format="depth32float";depthCompare="always"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="never"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="less"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="equal"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="less-equal"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="greater"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="not-equal"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="greater-equal"
+PASS :depth_test:isAsync=false;format="depth24plus";depthCompare="always"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="never"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="less"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="equal"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="less-equal"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="greater"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="not-equal"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="greater-equal"
+PASS :depth_test:isAsync=false;format="depth24plus-stencil8";depthCompare="always"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="never"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="less"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="equal"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="less-equal"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="greater"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="not-equal"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="greater-equal"
+PASS :depth_test:isAsync=false;format="depth32float-stencil8";depthCompare="always"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="never"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="less"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="equal"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="less-equal"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="greater"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="not-equal"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="greater-equal"
+PASS :depth_test:isAsync=true;format="stencil8";depthCompare="always"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="never"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="less"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="equal"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="less-equal"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="greater"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="not-equal"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="greater-equal"
+PASS :depth_test:isAsync=true;format="depth16unorm";depthCompare="always"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="never"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="less"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="equal"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="less-equal"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="greater"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="not-equal"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="greater-equal"
+PASS :depth_test:isAsync=true;format="depth32float";depthCompare="always"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="never"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="less"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="equal"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="less-equal"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="greater"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="not-equal"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="greater-equal"
+PASS :depth_test:isAsync=true;format="depth24plus";depthCompare="always"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="never"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="less"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="equal"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="less-equal"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="greater"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="not-equal"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="greater-equal"
+PASS :depth_test:isAsync=true;format="depth24plus-stencil8";depthCompare="always"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="never"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="less"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="equal"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="less-equal"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="greater"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="not-equal"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="greater-equal"
+PASS :depth_test:isAsync=true;format="depth32float-stencil8";depthCompare="always"
+PASS :depth_write:isAsync=false;format="stencil8";depthWriteEnabled=false
+PASS :depth_write:isAsync=false;format="stencil8";depthWriteEnabled=true
+PASS :depth_write:isAsync=false;format="depth16unorm";depthWriteEnabled=false
+PASS :depth_write:isAsync=false;format="depth16unorm";depthWriteEnabled=true
+PASS :depth_write:isAsync=false;format="depth32float";depthWriteEnabled=false
+PASS :depth_write:isAsync=false;format="depth32float";depthWriteEnabled=true
+PASS :depth_write:isAsync=false;format="depth24plus";depthWriteEnabled=false
+PASS :depth_write:isAsync=false;format="depth24plus";depthWriteEnabled=true
+PASS :depth_write:isAsync=false;format="depth24plus-stencil8";depthWriteEnabled=false
+PASS :depth_write:isAsync=false;format="depth24plus-stencil8";depthWriteEnabled=true
+PASS :depth_write:isAsync=false;format="depth32float-stencil8";depthWriteEnabled=false
+PASS :depth_write:isAsync=false;format="depth32float-stencil8";depthWriteEnabled=true
+PASS :depth_write:isAsync=true;format="stencil8";depthWriteEnabled=false
+PASS :depth_write:isAsync=true;format="stencil8";depthWriteEnabled=true
+PASS :depth_write:isAsync=true;format="depth16unorm";depthWriteEnabled=false
+PASS :depth_write:isAsync=true;format="depth16unorm";depthWriteEnabled=true
+PASS :depth_write:isAsync=true;format="depth32float";depthWriteEnabled=false
+PASS :depth_write:isAsync=true;format="depth32float";depthWriteEnabled=true
+PASS :depth_write:isAsync=true;format="depth24plus";depthWriteEnabled=false
+PASS :depth_write:isAsync=true;format="depth24plus";depthWriteEnabled=true
+PASS :depth_write:isAsync=true;format="depth24plus-stencil8";depthWriteEnabled=false
+PASS :depth_write:isAsync=true;format="depth24plus-stencil8";depthWriteEnabled=true
+PASS :depth_write:isAsync=true;format="depth32float-stencil8";depthWriteEnabled=false
+PASS :depth_write:isAsync=true;format="depth32float-stencil8";depthWriteEnabled=true
+PASS :depth_write,frag_depth:isAsync=false;format="_undef_"
+PASS :depth_write,frag_depth:isAsync=false;format="stencil8"
+PASS :depth_write,frag_depth:isAsync=false;format="depth16unorm"
+PASS :depth_write,frag_depth:isAsync=false;format="depth32float"
+PASS :depth_write,frag_depth:isAsync=false;format="depth24plus"
+PASS :depth_write,frag_depth:isAsync=false;format="depth24plus-stencil8"
+PASS :depth_write,frag_depth:isAsync=false;format="depth32float-stencil8"
+PASS :depth_write,frag_depth:isAsync=true;format="_undef_"
+PASS :depth_write,frag_depth:isAsync=true;format="stencil8"
+PASS :depth_write,frag_depth:isAsync=true;format="depth16unorm"
+PASS :depth_write,frag_depth:isAsync=true;format="depth32float"
+PASS :depth_write,frag_depth:isAsync=true;format="depth24plus"
+PASS :depth_write,frag_depth:isAsync=true;format="depth24plus-stencil8"
+PASS :depth_write,frag_depth:isAsync=true;format="depth32float-stencil8"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="never"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="less"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="greater"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="front";compare="always"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="never"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="less"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="greater"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="stencil8";face="back";compare="always"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="never"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="less"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="front";compare="always"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="never"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="less"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth16unorm";face="back";compare="always"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="never"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="less"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="front";compare="always"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="never"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="less"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth32float";face="back";compare="always"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="never"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="less"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="front";compare="always"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="never"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="less"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus";face="back";compare="always"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="never"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="less"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="front";compare="always"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="never"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="less"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth24plus-stencil8";face="back";compare="always"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="never"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="less"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="front";compare="always"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="never"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="less"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="greater"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=false;format="depth32float-stencil8";face="back";compare="always"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="never"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="less"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="greater"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="front";compare="always"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="never"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="less"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="greater"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="stencil8";face="back";compare="always"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="never"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="less"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="front";compare="always"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="never"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="less"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth16unorm";face="back";compare="always"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="never"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="less"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="front";compare="always"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="never"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="less"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth32float";face="back";compare="always"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="never"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="less"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="front";compare="always"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="never"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="less"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus";face="back";compare="always"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="never"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="less"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="front";compare="always"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="never"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="less"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth24plus-stencil8";face="back";compare="always"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="never"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="less"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="front";compare="always"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="_undef_"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="never"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="less"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="less-equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="greater"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="not-equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="greater-equal"
+PASS :stencil_test:isAsync=true;format="depth32float-stencil8";face="back";compare="always"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="stencil8";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth16unorm";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=false;format="depth32float-stencil8";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="stencil8";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth16unorm";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth24plus-stencil8";faceAndOpType="backPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="frontPassOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backDepthFailOp";op="decrement-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="_undef_"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="keep"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="zero"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="replace"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="invert"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="increment-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="decrement-clamp"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="increment-wrap"
+PASS :stencil_write:isAsync=true;format="depth32float-stencil8";faceAndOpType="backPassOp";op="decrement-wrap"
+
diff --git a/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.js b/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.js
index 52dd133ebb31c..be0b0ab674cdf 100644
--- a/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.js
+++ b/LayoutTests/http/tests/webgpu/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.js
@@ -1,9 +1,8 @@
 /**
- * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts
- **/ export const description = `
+* AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts
+**/export const description = `
 This test dedicatedly tests validation of GPUDepthStencilState of createRenderPipeline.
-`;
-import { makeTestGroup } from '../../../../common/framework/test_group.js';
+`;import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import { unreachable } from '../../../../common/util/util.js';
 import { kCompareFunctions, kStencilOperations } from '../../../capability_info.js';
 import { kTextureFormats, kTextureFormatInfo, kDepthStencilFormats } from '../../../format_info.js';
@@ -13,260 +12,294 @@ import { CreateRenderPipelineValidationTest } from './common.js';
 
 export const g = makeTestGroup(CreateRenderPipelineValidationTest);
 
-g.test('format')
-  .desc(`The texture format in depthStencilState must be a depth/stencil format.`)
-  .params(u => u.combine('isAsync', [false, true]).combine('format', kTextureFormats))
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    const info = kTextureFormatInfo[format];
-    t.skipIfTextureFormatNotSupported(format);
-    t.selectDeviceOrSkipTestCase(info.feature);
-  })
-  .fn(t => {
-    const { isAsync, format } = t.params;
-    const info = kTextureFormatInfo[format];
-
-    const descriptor = t.getDescriptor({
-      depthStencil: { format, depthWriteEnabled: false, depthCompare: 'always' },
-    });
-
-    t.doCreateRenderPipelineTest(isAsync, !!info.depth || !!info.stencil, descriptor);
-  });
-
-g.test('depthCompare_optional')
-  .desc(
-    `The depthCompare in depthStencilState is optional for stencil-only formats but required for formats with a depth.`
-  )
-  .params(u =>
-    u
-      .combine('isAsync', [false, true])
-      .combine('format', kDepthStencilFormats)
-      .beginSubcases()
-      .combine('depthCompare', ['always', undefined])
-  )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    const info = kTextureFormatInfo[format];
-    t.skipIfTextureFormatNotSupported(format);
-    t.selectDeviceOrSkipTestCase(info.feature);
-  })
-  .fn(t => {
-    const { isAsync, format, depthCompare } = t.params;
-    const info = kTextureFormatInfo[format];
-    const descriptor = t.getDescriptor({
-      depthStencil: { format, depthCompare, depthWriteEnabled: false },
-    });
+g.test('format').
+desc(`The texture format in depthStencilState must be a depth/stencil format.`).
+params((u) => u.combine('isAsync', [false, true]).combine('format', kTextureFormats)).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  const info = kTextureFormatInfo[format];
+  t.skipIfTextureFormatNotSupported(format);
+  t.selectDeviceOrSkipTestCase(info.feature);
+}).
+fn((t) => {
+  const { isAsync, format } = t.params;
+  const info = kTextureFormatInfo[format];
 
-    t.doCreateRenderPipelineTest(isAsync, !(info.depth && depthCompare === undefined), descriptor);
+  const descriptor = t.getDescriptor({
+    depthStencil: { format, depthWriteEnabled: false, depthCompare: 'always' }
   });
 
-g.test('depthWriteEnabled_optional')
-  .desc(
-    `The depthWriteEnabled in depthStencilState is optional for stencil-only formats but required for formats with a depth.`
-  )
-  .params(u => u.combine('isAsync', [false, true]).combine('format', kDepthStencilFormats))
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    const info = kTextureFormatInfo[format];
-    t.skipIfTextureFormatNotSupported(format);
-    t.selectDeviceOrSkipTestCase(info.feature);
-  })
-  .fn(t => {
-    const { isAsync, format } = t.params;
-    const info = kTextureFormatInfo[format];
-    const descriptor = t.getDescriptor({
-      depthStencil: { format, depthCompare: 'always', depthWriteEnabled: undefined },
-    });
+  t.doCreateRenderPipelineTest(isAsync, !!info.depth || !!info.stencil, descriptor);
+});
 
-    t.doCreateRenderPipelineTest(isAsync, !info.depth, descriptor);
+g.test('depthCompare_optional').
+desc(
+  `The depthCompare in depthStencilState is optional for stencil-only formats but
+    required for formats with a depth if depthCompare is not used for anything.`
+).
+params((u) =>
+u.
+combine('isAsync', [false, true]).
+combine('format', kDepthStencilFormats).
+beginSubcases().
+combine('depthCompare', ['always', undefined]).
+combine('depthWriteEnabled', [false, true, undefined]).
+combine('stencilFrontDepthFailOp', ['keep', 'zero']).
+combine('stencilBackDepthFailOp', ['keep', 'zero'])
+).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  const info = kTextureFormatInfo[format];
+  t.skipIfTextureFormatNotSupported(format);
+  t.selectDeviceOrSkipTestCase(info.feature);
+}).
+fn((t) => {
+  const {
+    isAsync,
+    format,
+    depthCompare,
+    depthWriteEnabled,
+    stencilFrontDepthFailOp,
+    stencilBackDepthFailOp
+  } = t.params;
+  const info = kTextureFormatInfo[format];
+  const descriptor = t.getDescriptor({
+    depthStencil: {
+      format,
+      depthCompare,
+      depthWriteEnabled,
+      stencilFront: { depthFailOp: stencilFrontDepthFailOp },
+      stencilBack: { depthFailOp: stencilBackDepthFailOp }
+    }
   });
 
-g.test('depth_test')
-  .desc(
-    `Depth aspect must be contained in the format if depth test is enabled in depthStencilState.`
-  )
-  .params(u =>
-    u
-      .combine('isAsync', [false, true])
-      .combine('format', kDepthStencilFormats)
-      .combine('depthCompare', kCompareFunctions)
-  )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    const info = kTextureFormatInfo[format];
-    t.selectDeviceOrSkipTestCase(info.feature);
-  })
-  .fn(t => {
-    const { isAsync, format, depthCompare } = t.params;
-    const info = kTextureFormatInfo[format];
+  const depthFailOpsAreKeep =
+  stencilFrontDepthFailOp === 'keep' && stencilBackDepthFailOp === 'keep';
+  const stencilStateIsDefault = depthFailOpsAreKeep;
+  let success = true;
+  if (depthWriteEnabled || depthCompare && depthCompare !== 'always') {
+    if (!info.depth) success = false;
+  }
+  if (!stencilStateIsDefault) {
+    if (!info.stencil) success = false;
+  }
+  if (info.depth) {
+    if (depthWriteEnabled === undefined) success = false;
+    if (depthWriteEnabled || !depthFailOpsAreKeep) {
+      if (depthCompare === undefined) success = false;
+    }
+  }
 
-    const descriptor = t.getDescriptor({
-      depthStencil: { format, depthCompare, depthWriteEnabled: false },
-    });
+  t.doCreateRenderPipelineTest(isAsync, success, descriptor);
+});
 
-    const depthTestEnabled = depthCompare !== undefined && depthCompare !== 'always';
-    t.doCreateRenderPipelineTest(isAsync, !depthTestEnabled || !!info.depth, descriptor);
+g.test('depthWriteEnabled_optional').
+desc(
+  `The depthWriteEnabled in depthStencilState is optional for stencil-only formats but required for formats with a depth.`
+).
+params((u) => u.combine('isAsync', [false, true]).combine('format', kDepthStencilFormats)).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  const info = kTextureFormatInfo[format];
+  t.skipIfTextureFormatNotSupported(format);
+  t.selectDeviceOrSkipTestCase(info.feature);
+}).
+fn((t) => {
+  const { isAsync, format } = t.params;
+  const info = kTextureFormatInfo[format];
+  const descriptor = t.getDescriptor({
+    depthStencil: { format, depthCompare: 'always', depthWriteEnabled: undefined }
   });
 
-g.test('depth_write')
-  .desc(
-    `Depth aspect must be contained in the format if depth write is enabled in depthStencilState.`
-  )
-  .params(u =>
-    u
-      .combine('isAsync', [false, true])
-      .combine('format', kDepthStencilFormats)
-      .combine('depthWriteEnabled', [false, true])
-  )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    const info = kTextureFormatInfo[format];
-    t.selectDeviceOrSkipTestCase(info.feature);
-  })
-  .fn(t => {
-    const { isAsync, format, depthWriteEnabled } = t.params;
-    const info = kTextureFormatInfo[format];
+  t.doCreateRenderPipelineTest(isAsync, !info.depth, descriptor);
+});
 
-    const descriptor = t.getDescriptor({
-      depthStencil: { format, depthWriteEnabled, depthCompare: 'always' },
-    });
-    t.doCreateRenderPipelineTest(isAsync, !depthWriteEnabled || !!info.depth, descriptor);
+g.test('depth_test').
+desc(
+  `Depth aspect must be contained in the format if depth test is enabled in depthStencilState.`
+).
+params((u) =>
+u.
+combine('isAsync', [false, true]).
+combine('format', kDepthStencilFormats).
+combine('depthCompare', kCompareFunctions)
+).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  const info = kTextureFormatInfo[format];
+  t.selectDeviceOrSkipTestCase(info.feature);
+}).
+fn((t) => {
+  const { isAsync, format, depthCompare } = t.params;
+  const info = kTextureFormatInfo[format];
+
+  const descriptor = t.getDescriptor({
+    depthStencil: { format, depthCompare, depthWriteEnabled: false }
   });
 
-g.test('depth_write,frag_depth')
-  .desc(`Depth aspect must be contained in the format if frag_depth is written in fragment stage.`)
-  .params(u =>
-    u.combine('isAsync', [false, true]).combine('format', [undefined, ...kDepthStencilFormats])
-  )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    if (format !== undefined) {
-      const info = kTextureFormatInfo[format];
-      t.selectDeviceOrSkipTestCase(info.feature);
-    }
-  })
-  .fn(t => {
-    const { isAsync, format } = t.params;
+  const depthTestEnabled = depthCompare !== undefined && depthCompare !== 'always';
+  t.doCreateRenderPipelineTest(isAsync, !depthTestEnabled || !!info.depth, descriptor);
+});
 
-    const descriptor = t.getDescriptor({
-      // Keep one color target so that the pipeline is still valid with no depth stencil target.
-      targets: [{ format: 'rgba8unorm' }],
-      depthStencil: format
-        ? { format, depthWriteEnabled: true, depthCompare: 'always' }
-        : undefined,
-      fragmentShaderCode: getFragmentShaderCodeWithOutput(
-        [{ values: [1, 1, 1, 1], plainType: 'f32', componentCount: 4 }],
-        { value: 0.5 }
-      ),
-    });
+g.test('depth_write').
+desc(
+  `Depth aspect must be contained in the format if depth write is enabled in depthStencilState.`
+).
+params((u) =>
+u.
+combine('isAsync', [false, true]).
+combine('format', kDepthStencilFormats).
+combine('depthWriteEnabled', [false, true])
+).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  const info = kTextureFormatInfo[format];
+  t.selectDeviceOrSkipTestCase(info.feature);
+}).
+fn((t) => {
+  const { isAsync, format, depthWriteEnabled } = t.params;
+  const info = kTextureFormatInfo[format];
 
-    const hasDepth = format ? !!kTextureFormatInfo[format].depth : false;
-    t.doCreateRenderPipelineTest(isAsync, hasDepth, descriptor);
+  const descriptor = t.getDescriptor({
+    depthStencil: { format, depthWriteEnabled, depthCompare: 'always' }
   });
+  t.doCreateRenderPipelineTest(isAsync, !depthWriteEnabled || !!info.depth, descriptor);
+});
 
-g.test('stencil_test')
-  .desc(
-    `Stencil aspect must be contained in the format if stencil test is enabled in depthStencilState.`
-  )
-  .params(u =>
-    u
-      .combine('isAsync', [false, true])
-      .combine('format', kDepthStencilFormats)
-      .combine('face', ['front', 'back'])
-      .combine('compare', [undefined, ...kCompareFunctions])
-  )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
+g.test('depth_write,frag_depth').
+desc(`Depth aspect must be contained in the format if frag_depth is written in fragment stage.`).
+params((u) =>
+u.combine('isAsync', [false, true]).combine('format', [undefined, ...kDepthStencilFormats])
+).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  if (format !== undefined) {
     const info = kTextureFormatInfo[format];
     t.selectDeviceOrSkipTestCase(info.feature);
-  })
-  .fn(t => {
-    const { isAsync, format, face, compare } = t.params;
-    const info = kTextureFormatInfo[format];
-
-    let descriptor;
-    if (face === 'front') {
-      descriptor = t.getDescriptor({
-        depthStencil: {
-          format,
-          depthWriteEnabled: false,
-          depthCompare: 'always',
-          stencilFront: { compare },
-        },
-      });
-    } else {
-      descriptor = t.getDescriptor({
-        depthStencil: {
-          format,
-          depthWriteEnabled: false,
-          depthCompare: 'always',
-          stencilBack: { compare },
-        },
-      });
-    }
+  }
+}).
+fn((t) => {
+  const { isAsync, format } = t.params;
 
-    const stencilTestEnabled = compare !== undefined && compare !== 'always';
-    t.doCreateRenderPipelineTest(isAsync, !stencilTestEnabled || !!info.stencil, descriptor);
+  const descriptor = t.getDescriptor({
+    // Keep one color target so that the pipeline is still valid with no depth stencil target.
+    targets: [{ format: 'rgba8unorm' }],
+    depthStencil: format ?
+    { format, depthWriteEnabled: true, depthCompare: 'always' } :
+    undefined,
+    fragmentShaderCode: getFragmentShaderCodeWithOutput(
+      [{ values: [1, 1, 1, 1], plainType: 'f32', componentCount: 4 }],
+      { value: 0.5 }
+    )
   });
 
-g.test('stencil_write')
-  .desc(
-    `Stencil aspect must be contained in the format if stencil write is enabled in depthStencilState.`
-  )
-  .params(u =>
-    u
-      .combine('isAsync', [false, true])
-      .combine('format', kDepthStencilFormats)
-      .combine('faceAndOpType', [
-        'frontFailOp',
-        'frontDepthFailOp',
-        'frontPassOp',
-        'backFailOp',
-        'backDepthFailOp',
-        'backPassOp',
-      ])
-      .combine('op', [undefined, ...kStencilOperations])
-  )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    const info = kTextureFormatInfo[format];
-    t.selectDeviceOrSkipTestCase(info.feature);
-  })
-  .fn(t => {
-    const { isAsync, format, faceAndOpType, op } = t.params;
-    const info = kTextureFormatInfo[format];
+  const hasDepth = format ? !!kTextureFormatInfo[format].depth : false;
+  t.doCreateRenderPipelineTest(isAsync, hasDepth, descriptor);
+});
 
-    const common = {
-      format,
-      depthWriteEnabled: false,
-      depthCompare: 'always',
-    };
-    let depthStencil;
-    switch (faceAndOpType) {
-      case 'frontFailOp':
-        depthStencil = { ...common, stencilFront: { failOp: op } };
-        break;
-      case 'frontDepthFailOp':
-        depthStencil = { ...common, stencilFront: { depthFailOp: op } };
-        break;
-      case 'frontPassOp':
-        depthStencil = { ...common, stencilFront: { passOp: op } };
-        break;
-      case 'backFailOp':
-        depthStencil = { ...common, stencilBack: { failOp: op } };
-        break;
-      case 'backDepthFailOp':
-        depthStencil = { ...common, stencilBack: { depthFailOp: op } };
-        break;
-      case 'backPassOp':
-        depthStencil = { ...common, stencilBack: { passOp: op } };
-        break;
-      default:
-        unreachable();
-    }
+g.test('stencil_test').
+desc(
+  `Stencil aspect must be contained in the format if stencil test is enabled in depthStencilState.`
+).
+params((u) =>
+u.
+combine('isAsync', [false, true]).
+combine('format', kDepthStencilFormats).
+combine('face', ['front', 'back']).
+combine('compare', [undefined, ...kCompareFunctions])
+).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  const info = kTextureFormatInfo[format];
+  t.selectDeviceOrSkipTestCase(info.feature);
+}).
+fn((t) => {
+  const { isAsync, format, face, compare } = t.params;
+  const info = kTextureFormatInfo[format];
 
-    const descriptor = t.getDescriptor({ depthStencil });
+  let descriptor;
+  if (face === 'front') {
+    descriptor = t.getDescriptor({
+      depthStencil: {
+        format,
+        depthWriteEnabled: false,
+        depthCompare: 'always',
+        stencilFront: { compare }
+      }
+    });
+  } else {
+    descriptor = t.getDescriptor({
+      depthStencil: {
+        format,
+        depthWriteEnabled: false,
+        depthCompare: 'always',
+        stencilBack: { compare }
+      }
+    });
+  }
 
-    const stencilWriteEnabled = op !== undefined && op !== 'keep';
-    t.doCreateRenderPipelineTest(isAsync, !stencilWriteEnabled || !!info.stencil, descriptor);
-  });
+  const stencilTestEnabled = compare !== undefined && compare !== 'always';
+  t.doCreateRenderPipelineTest(isAsync, !stencilTestEnabled || !!info.stencil, descriptor);
+});
+
+g.test('stencil_write').
+desc(
+  `Stencil aspect must be contained in the format if stencil write is enabled in depthStencilState.`
+).
+params((u) =>
+u.
+combine('isAsync', [false, true]).
+combine('format', kDepthStencilFormats).
+combine('faceAndOpType', [
+'frontFailOp',
+'frontDepthFailOp',
+'frontPassOp',
+'backFailOp',
+'backDepthFailOp',
+'backPassOp']
+).
+combine('op', [undefined, ...kStencilOperations])
+).
+beforeAllSubcases((t) => {
+  const { format } = t.params;
+  const info = kTextureFormatInfo[format];
+  t.selectDeviceOrSkipTestCase(info.feature);
+}).
+fn((t) => {
+  const { isAsync, format, faceAndOpType, op } = t.params;
+  const info = kTextureFormatInfo[format];
+
+  const common = {
+    format,
+    depthWriteEnabled: false,
+    depthCompare: 'always'
+  };
+  let depthStencil;
+  switch (faceAndOpType) {
+    case 'frontFailOp':
+      depthStencil = { ...common, stencilFront: { failOp: op } };
+      break;
+    case 'frontDepthFailOp':
+      depthStencil = { ...common, stencilFront: { depthFailOp: op } };
+      break;
+    case 'frontPassOp':
+      depthStencil = { ...common, stencilFront: { passOp: op } };
+      break;
+    case 'backFailOp':
+      depthStencil = { ...common, stencilBack: { failOp: op } };
+      break;
+    case 'backDepthFailOp':
+      depthStencil = { ...common, stencilBack: { depthFailOp: op } };
+      break;
+    case 'backPassOp':
+      depthStencil = { ...common, stencilBack: { passOp: op } };
+      break;
+    default:
+      unreachable();
+  }
+  const descriptor = t.getDescriptor({ depthStencil });
+
+  const stencilWriteEnabled = op !== undefined && op !== 'keep';
+  t.doCreateRenderPipelineTest(isAsync, !stencilWriteEnabled || !!info.stencil, descriptor);
+});
+//# sourceMappingURL=depth_stencil_state.spec.js.map
\ No newline at end of file
diff --git a/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.h b/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.h
index e3792b4765001..6aca517a46931 100644
--- a/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.h
+++ b/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.h
@@ -37,10 +37,13 @@ namespace WebCore {
 struct GPUDepthStencilState {
     WebGPU::DepthStencilState convertToBacking() const
     {
+        std::optional<WebGPU::CompareFunction> optionalDepthCompare;
+        if (depthCompare)
+            optionalDepthCompare = WebCore::convertToBacking(*depthCompare);
         return {
             .format = WebCore::convertToBacking(format),
             .depthWriteEnabled = depthWriteEnabled,
-            .depthCompare = WebCore::convertToBacking(depthCompare),
+            .depthCompare = optionalDepthCompare,
             .stencilFront = stencilFront.convertToBacking(),
             .stencilBack = stencilBack.convertToBacking(),
             .stencilReadMask = stencilReadMask ? std::optional { *stencilReadMask } : std::nullopt,
@@ -53,8 +56,8 @@ struct GPUDepthStencilState {
 
     GPUTextureFormat format { GPUTextureFormat::R8unorm };
 
-    bool depthWriteEnabled { false };
-    GPUCompareFunction depthCompare { GPUCompareFunction::Always };
+    std::optional<bool> depthWriteEnabled;
+    std::optional<GPUCompareFunction> depthCompare;
 
     GPUStencilFaceState stencilFront;
     GPUStencilFaceState stencilBack;
diff --git a/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.idl b/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.idl
index 5c9b37dc8b514..3d1ca07b8bb11 100644
--- a/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.idl
+++ b/Source/WebCore/Modules/WebGPU/GPUDepthStencilState.idl
@@ -35,8 +35,8 @@ typedef [EnforceRange] long GPUDepthBias;
 dictionary GPUDepthStencilState {
     required GPUTextureFormat format;
 
-    required boolean depthWriteEnabled;
-    required GPUCompareFunction depthCompare;
+    boolean depthWriteEnabled;
+    GPUCompareFunction depthCompare;
 
     GPUStencilFaceState stencilFront;
     GPUStencilFaceState stencilBack;
diff --git a/Source/WebCore/Modules/WebGPU/GPUInternalError.h b/Source/WebCore/Modules/WebGPU/GPUInternalError.h
index 5623526e40aac..776c4ab7cc142 100644
--- a/Source/WebCore/Modules/WebGPU/GPUInternalError.h
+++ b/Source/WebCore/Modules/WebGPU/GPUInternalError.h
@@ -48,6 +48,7 @@ class GPUInternalError : public RefCounted<GPUInternalError> {
 
     WebGPU::InternalError* backing() { return m_backing.get(); }
     const WebGPU::InternalError* backing() const { return m_backing.get(); }
+    String stack() const { return "_"_s; }
 
 private:
     GPUInternalError(String&& message)
diff --git a/Source/WebCore/Modules/WebGPU/GPUInternalError.idl b/Source/WebCore/Modules/WebGPU/GPUInternalError.idl
index effcaa84d9b9b..3daba53d2bc44 100644
--- a/Source/WebCore/Modules/WebGPU/GPUInternalError.idl
+++ b/Source/WebCore/Modules/WebGPU/GPUInternalError.idl
@@ -31,4 +31,5 @@
 interface GPUInternalError {
     constructor(DOMString message);
     readonly attribute DOMString message;
+    readonly attribute DOMString stack;
 };
diff --git a/Source/WebCore/Modules/WebGPU/GPUPipelineError.h b/Source/WebCore/Modules/WebGPU/GPUPipelineError.h
index 50a8153bbc2ed..a082ba83f88b4 100644
--- a/Source/WebCore/Modules/WebGPU/GPUPipelineError.h
+++ b/Source/WebCore/Modules/WebGPU/GPUPipelineError.h
@@ -41,6 +41,7 @@ class GPUPipelineError final : public DOMException {
     }
 
     GPUPipelineErrorReason reason() const { return m_reason.reason; }
+    String stack() const { return "_"_s; }
 
 private:
     GPUPipelineError(String&& message, GPUPipelineErrorInit);
diff --git a/Source/WebCore/Modules/WebGPU/GPUPipelineError.idl b/Source/WebCore/Modules/WebGPU/GPUPipelineError.idl
index 38167d1fba1b1..50fdea02adbd4 100644
--- a/Source/WebCore/Modules/WebGPU/GPUPipelineError.idl
+++ b/Source/WebCore/Modules/WebGPU/GPUPipelineError.idl
@@ -34,4 +34,5 @@
 interface GPUPipelineError : DOMException {
     constructor(DOMString message, GPUPipelineErrorInit options);
     readonly attribute GPUPipelineErrorReason reason;
+    readonly attribute DOMString stack;
 };
diff --git a/Source/WebCore/Modules/WebGPU/GPUValidationError.h b/Source/WebCore/Modules/WebGPU/GPUValidationError.h
index 4423048b7c2ec..432cfb28bbad6 100644
--- a/Source/WebCore/Modules/WebGPU/GPUValidationError.h
+++ b/Source/WebCore/Modules/WebGPU/GPUValidationError.h
@@ -48,6 +48,7 @@ class GPUValidationError : public RefCounted<GPUValidationError> {
 
     WebGPU::ValidationError* backing() { return m_backing.get(); }
     const WebGPU::ValidationError* backing() const { return m_backing.get(); }
+    String stack() const { return "_"_s; }
 
 private:
     GPUValidationError(String&& message)
diff --git a/Source/WebCore/Modules/WebGPU/GPUValidationError.idl b/Source/WebCore/Modules/WebGPU/GPUValidationError.idl
index 6c458355f7181..a34e26c525b37 100644
--- a/Source/WebCore/Modules/WebGPU/GPUValidationError.idl
+++ b/Source/WebCore/Modules/WebGPU/GPUValidationError.idl
@@ -31,4 +31,5 @@
 interface GPUValidationError {
     constructor(DOMString message);
     readonly attribute DOMString message;
+    readonly attribute DOMString stack;
 };
diff --git a/Source/WebCore/Modules/WebGPU/Implementation/WebGPUDeviceImpl.cpp b/Source/WebCore/Modules/WebGPU/Implementation/WebGPUDeviceImpl.cpp
index e2fc90ed31ff3..252eac3fe7664 100644
--- a/Source/WebCore/Modules/WebGPU/Implementation/WebGPUDeviceImpl.cpp
+++ b/Source/WebCore/Modules/WebGPU/Implementation/WebGPUDeviceImpl.cpp
@@ -402,18 +402,18 @@ static auto convertToBacking(const RenderPipelineDescriptor& descriptor, bool de
         .nextInChain = nullptr,
         .format = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->format) : WGPUTextureFormat_Undefined,
         .depthWriteEnabled = descriptor.depthStencil ? descriptor.depthStencil->depthWriteEnabled : false,
-        .depthCompare = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->depthCompare) : WGPUCompareFunction_Undefined,
+        .depthCompare = (descriptor.depthStencil && descriptor.depthStencil->depthCompare) ? convertToBackingContext.convertToBacking(*descriptor.depthStencil->depthCompare) : WGPUCompareFunction_Undefined,
         .stencilFront = {
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.compare) : WGPUCompareFunction_Undefined,
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.failOp) : WGPUStencilOperation_Keep,
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.depthFailOp) : WGPUStencilOperation_Keep,
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.passOp) : WGPUStencilOperation_Keep,
+            .compare = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.compare) : WGPUCompareFunction_Undefined,
+            .failOp = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.failOp) : WGPUStencilOperation_Keep,
+            .depthFailOp = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.depthFailOp) : WGPUStencilOperation_Keep,
+            .passOp = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilFront.passOp) : WGPUStencilOperation_Keep,
         },
         .stencilBack = {
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.compare) : WGPUCompareFunction_Undefined,
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.failOp) : WGPUStencilOperation_Keep,
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.depthFailOp) : WGPUStencilOperation_Keep,
-            descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.passOp) : WGPUStencilOperation_Keep,
+            .compare = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.compare) : WGPUCompareFunction_Undefined,
+            .failOp = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.failOp) : WGPUStencilOperation_Keep,
+            .depthFailOp = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.depthFailOp) : WGPUStencilOperation_Keep,
+            .passOp = descriptor.depthStencil ? convertToBackingContext.convertToBacking(descriptor.depthStencil->stencilBack.passOp) : WGPUStencilOperation_Keep,
         },
         .stencilReadMask = descriptor.depthStencil && descriptor.depthStencil->stencilReadMask ? *descriptor.depthStencil->stencilReadMask : 0,
         .stencilWriteMask = descriptor.depthStencil && descriptor.depthStencil->stencilWriteMask ? *descriptor.depthStencil->stencilWriteMask : 0,
diff --git a/Source/WebCore/Modules/WebGPU/InternalAPI/WebGPUDepthStencilState.h b/Source/WebCore/Modules/WebGPU/InternalAPI/WebGPUDepthStencilState.h
index 90d1048a7bc2c..48ddf8e2c07f7 100644
--- a/Source/WebCore/Modules/WebGPU/InternalAPI/WebGPUDepthStencilState.h
+++ b/Source/WebCore/Modules/WebGPU/InternalAPI/WebGPUDepthStencilState.h
@@ -36,8 +36,8 @@ namespace WebCore::WebGPU {
 struct DepthStencilState {
     TextureFormat format { TextureFormat::R8unorm };
 
-    bool depthWriteEnabled { false };
-    CompareFunction depthCompare { CompareFunction::Always };
+    std::optional<bool> depthWriteEnabled;
+    std::optional<CompareFunction> depthCompare;
 
     StencilFaceState stencilFront;
     StencilFaceState stencilBack;
diff --git a/Source/WebGPU/WGSL/Parser.cpp b/Source/WebGPU/WGSL/Parser.cpp
index 5d795c00562b2..33cfd662f16bb 100644
--- a/Source/WebGPU/WGSL/Parser.cpp
+++ b/Source/WebGPU/WGSL/Parser.cpp
@@ -640,6 +640,8 @@ Result<AST::Attribute::Ref> Parser<Lexer>::parseAttribute()
         auto* builtin = parseBuiltin(name);
         if (!builtin)
             FAIL("Unknown builtin value. Expected 'vertex_index', 'instance_index', 'position', 'front_facing', 'frag_depth', 'sample_index', 'sample_mask', 'local_invocation_id', 'local_invocation_index', 'global_invocation_id', 'workgroup_id' or 'num_workgroups'"_s);
+        if (*builtin == Builtin::FragDepth)
+            m_shaderModule.setUsesFragDepth();
         CONSUME_TYPE(ParenRight);
         RETURN_ARENA_NODE(BuiltinAttribute, *builtin);
     }
diff --git a/Source/WebGPU/WGSL/WGSLShaderModule.h b/Source/WebGPU/WGSL/WGSLShaderModule.h
index a8bd5874753a9..4389da5cfa9ea 100644
--- a/Source/WebGPU/WGSL/WGSLShaderModule.h
+++ b/Source/WebGPU/WGSL/WGSLShaderModule.h
@@ -93,6 +93,8 @@ class ShaderModule {
 
     bool usesAtomicCompareExchange() const { return m_usesAtomicCompareExchange; }
     void setUsesAtomicCompareExchange() { m_usesAtomicCompareExchange = true; }
+    bool usesFragDepth() const { return m_usesFragDepth; }
+    void setUsesFragDepth() { m_usesFragDepth = true; }
 
     template<typename T>
     std::enable_if_t<std::is_base_of_v<AST::Node, T>, void> replace(T* current, T&& replacement)
@@ -249,6 +251,7 @@ class ShaderModule {
     bool m_usesFrexp { false };
     bool m_usesModf { false };
     bool m_usesAtomicCompareExchange { false };
+    bool m_usesFragDepth { false };
     OptionSet<Extension> m_enabledExtensions;
     OptionSet<LanguageFeature> m_requiredFeatures;
     Configuration m_configuration;
diff --git a/Source/WebGPU/WebGPU/RenderPipeline.mm b/Source/WebGPU/WebGPU/RenderPipeline.mm
index 9cb6025ac8cdc..501aa26075216 100644
--- a/Source/WebGPU/WebGPU/RenderPipeline.mm
+++ b/Source/WebGPU/WebGPU/RenderPipeline.mm
@@ -31,6 +31,7 @@
 #import "Device.h"
 #import "Pipeline.h"
 #import "RenderBundleEncoder.h"
+#import "WGSLShaderModule.h"
 
 // FIXME: remove after radar://104903411 or after we place the mask into the last buffer
 @interface NSObject ()
@@ -604,13 +605,79 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
     return generatedPipelineLayout;
 }
 
-static Ref<RenderPipeline> returnInvalidRenderPipeline(WebGPU::Device &object, bool isAsync)
+static Ref<RenderPipeline> returnInvalidRenderPipeline(WebGPU::Device &object, bool isAsync, String&& error)
 {
     if (!isAsync)
-        object.generateAValidationError("createRenderPipeline failed"_s);
+        object.generateAValidationError(WTFMove(error));
     return RenderPipeline::createInvalid(object);
 }
 
+static constexpr const char* name(WGPUCompareFunction compare)
+{
+    switch (compare) {
+    case WGPUCompareFunction_Undefined: return "undefined";
+    case WGPUCompareFunction_Never: return "never";
+    case WGPUCompareFunction_Less: return "less";
+    case WGPUCompareFunction_LessEqual: return "less-equal";
+    case WGPUCompareFunction_Greater: return "greater";
+    case WGPUCompareFunction_GreaterEqual: return "greater-equal";
+    case WGPUCompareFunction_Equal: return "equal";
+    case WGPUCompareFunction_NotEqual: return "not-equal";
+    case WGPUCompareFunction_Always: return "always";
+    case WGPUCompareFunction_Force32: RELEASE_ASSERT_NOT_REACHED();
+    }
+}
+static constexpr const char* name(WGPUStencilOperation operation)
+{
+    switch (operation) {
+    case WGPUStencilOperation_Keep: return "keep";
+    case WGPUStencilOperation_Zero: return "zero";
+    case WGPUStencilOperation_Replace: return "replace";
+    case WGPUStencilOperation_Invert: return "invert";
+    case WGPUStencilOperation_IncrementClamp: return "increment-clamp";
+    case WGPUStencilOperation_DecrementClamp: return "decrement-clamp";
+    case WGPUStencilOperation_IncrementWrap: return "increment-wrap";
+    case WGPUStencilOperation_DecrementWrap: return "decrement-wrap";
+    case WGPUStencilOperation_Force32: RELEASE_ASSERT_NOT_REACHED();
+    }
+}
+
+static NSString* errorValidatingDepthStencilState(const WGPUDepthStencilState& depthStencil)
+{
+#define ERROR_STRING(x) ([NSString stringWithFormat:@"Invalid DepthStencilState: %@", x])
+    if (!Texture::isDepthOrStencilFormat(depthStencil.format))
+        return ERROR_STRING(@"Color format passed to depth / stencil format");
+
+    auto depthFormat = Texture::depthOnlyAspectMetalFormat(depthStencil.format);
+    if ((depthStencil.depthWriteEnabled && *depthStencil.depthWriteEnabled) || (depthStencil.depthCompare != WGPUCompareFunction_Undefined && depthStencil.depthCompare != WGPUCompareFunction_Always)) {
+        if (!depthFormat)
+            return ERROR_STRING(@"depth-stencil state missing format");
+    }
+
+    auto isDefault = ^(const WGPUStencilFaceState& s) {
+        return s.compare == WGPUCompareFunction_Always && s.failOp == WGPUStencilOperation_Keep && s.depthFailOp == WGPUStencilOperation_Keep && s.passOp == WGPUStencilOperation_Keep;
+    };
+    if (!isDefault(depthStencil.stencilFront) || !isDefault(depthStencil.stencilBack)) {
+        if (!Texture::stencilOnlyAspectMetalFormat(depthStencil.format)) {
+            NSString *error = [NSString stringWithFormat:@"missing stencil format - stencilFront: compare = %s, failOp = %s, depthFailOp = %s, passOp = %s, stencilBack: compare = %s, failOp = %s, depthFailOp = %s, passOp = %s", name(depthStencil.stencilFront.compare), name(depthStencil.stencilFront.failOp), name(depthStencil.stencilFront.depthFailOp), name(depthStencil.stencilFront.passOp), name(depthStencil.stencilBack.compare), name(depthStencil.stencilBack.failOp), name(depthStencil.stencilBack.depthFailOp), name(depthStencil.stencilBack.passOp)];
+            return ERROR_STRING(error);
+        }
+    }
+
+    if (depthFormat) {
+        if (!depthStencil.depthWriteEnabled)
+            return ERROR_STRING(@"depthWrite must be provided");
+
+        bool depthWriteEnabled = *depthStencil.depthWriteEnabled;
+        if (depthWriteEnabled || depthStencil.stencilFront.depthFailOp != WGPUStencilOperation_Keep || depthStencil.stencilBack.depthFailOp != WGPUStencilOperation_Keep) {
+            if (depthStencil.depthCompare == WGPUCompareFunction_Undefined)
+                return ERROR_STRING(@"Depth compare must be provided");
+        }
+    }
+#undef ERROR_STRING
+    return nil;
+}
+
 Ref<RenderPipeline> Device::createRenderPipeline(const WGPURenderPipelineDescriptor& descriptor, bool isAsync)
 {
     if (!validateRenderPipeline(descriptor) || !isValid())
@@ -627,23 +694,23 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
         if (auto& layout = WebGPU::fromAPI(descriptor.layout); layout.isValid() && !layout.isAutoLayout()) {
             pipelineLayout = &layout;
             if (pipelineLayout && &pipelineLayout->device() != this)
-                return returnInvalidRenderPipeline(*this, isAsync);
+                return returnInvalidRenderPipeline(*this, isAsync, "Pipeline layout is not valid"_s);
         }
     }
 
     std::optional<PipelineLayout> vertexPipelineLayout { std::nullopt };
     {
         if (descriptor.vertex.nextInChain)
-            return RenderPipeline::createInvalid(*this);
+            return returnInvalidRenderPipeline(*this, isAsync, "Vertex module has an invalid chain"_s);
 
         const auto& vertexModule = WebGPU::fromAPI(descriptor.vertex.module);
         if (!vertexModule.isValid())
-            return returnInvalidRenderPipeline(*this, isAsync);
+            return returnInvalidRenderPipeline(*this, isAsync, "Vertex module is not valid"_s);
 
         const auto& vertexFunctionName = fromAPI(descriptor.vertex.entryPoint);
         auto libraryCreationResult = createLibrary(m_device, vertexModule, pipelineLayout, vertexFunctionName.length() ? vertexFunctionName : vertexModule.defaultVertexEntryPoint(), label);
         if (!libraryCreationResult)
-            return returnInvalidRenderPipeline(*this, isAsync);
+            return returnInvalidRenderPipeline(*this, isAsync, "Vertex library failed creation"_s);
 
         const auto& entryPointInformation = libraryCreationResult->entryPointInformation;
         if (!pipelineLayout)
@@ -651,26 +718,28 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
         auto [constantValues, wgslConstantValues] = createConstantValues(descriptor.vertex.constantCount, descriptor.vertex.constants, entryPointInformation);
         auto vertexFunction = createFunction(libraryCreationResult->library, entryPointInformation, constantValues, label);
         if (!vertexFunction || vertexFunction.functionType != MTLFunctionTypeVertex || entryPointInformation.specializationConstants.size() != wgslConstantValues.size())
-            return returnInvalidRenderPipeline(*this, isAsync);
+            return returnInvalidRenderPipeline(*this, isAsync, "Vertex function could not be created"_s);
         mtlRenderPipelineDescriptor.vertexFunction = vertexFunction;
     }
 
     std::optional<PipelineLayout> fragmentPipelineLayout { std::nullopt };
+    bool usesFragDepth = false;
     if (descriptor.fragment) {
         const auto& fragmentDescriptor = *descriptor.fragment;
 
         if (fragmentDescriptor.nextInChain)
-            return RenderPipeline::createInvalid(*this);
+            return returnInvalidRenderPipeline(*this, isAsync, "Fragment has extra chain"_s);
 
         const auto& fragmentModule = WebGPU::fromAPI(fragmentDescriptor.module);
-        if (!fragmentModule.isValid())
-            return returnInvalidRenderPipeline(*this, isAsync);
+        if (!fragmentModule.isValid() || !fragmentModule.ast())
+            return returnInvalidRenderPipeline(*this, isAsync, "Fragment module is invalid"_s);
 
+        usesFragDepth = fragmentModule.ast()->usesFragDepth();
         const auto& fragmentFunctionName = fromAPI(fragmentDescriptor.entryPoint);
 
         auto libraryCreationResult = createLibrary(m_device, fragmentModule, pipelineLayout, fragmentFunctionName.length() ? fragmentFunctionName : fragmentModule.defaultFragmentEntryPoint(), label);
         if (!libraryCreationResult)
-            return returnInvalidRenderPipeline(*this, isAsync);
+            return returnInvalidRenderPipeline(*this, isAsync, "Fragment library could not be created"_s);
 
         const auto& entryPointInformation = libraryCreationResult->entryPointInformation;
         if (!pipelineLayout)
@@ -679,7 +748,7 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
         auto [constantValues, wgslConstantValues] = createConstantValues(fragmentDescriptor.constantCount, fragmentDescriptor.constants, entryPointInformation);
         auto fragmentFunction = createFunction(libraryCreationResult->library, entryPointInformation, constantValues, label);
         if (!fragmentFunction || fragmentFunction.functionType != MTLFunctionTypeFragment || entryPointInformation.specializationConstants.size() != wgslConstantValues.size())
-            return returnInvalidRenderPipeline(*this, isAsync);
+            return returnInvalidRenderPipeline(*this, isAsync, "Fragment function failed creation"_s);
         mtlRenderPipelineDescriptor.fragmentFunction = fragmentFunction;
 
         for (uint32_t i = 0; i < fragmentDescriptor.targetCount; ++i) {
@@ -689,11 +758,16 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
 
             const auto& mtlColorAttachment = mtlRenderPipelineDescriptor.colorAttachments[i];
 
+            if (Texture::isDepthOrStencilFormat(targetDescriptor.format) || !Texture::isRenderableFormat(targetDescriptor.format, *this))
+                return returnInvalidRenderPipeline(*this, isAsync, "Depth / stencil format passed to color format"_s);
+
             mtlColorAttachment.pixelFormat = Texture::pixelFormat(targetDescriptor.format);
 
             mtlColorAttachment.writeMask = colorWriteMask(targetDescriptor.writeMask);
 
             if (targetDescriptor.blend) {
+                if (!Texture::supportsBlending(targetDescriptor.format, *this))
+                    return returnInvalidRenderPipeline(*this, isAsync, "Color target attempted to use blending on non-blendable format"_s);
                 mtlColorAttachment.blendingEnabled = YES;
 
                 const auto& alphaBlend = targetDescriptor.blend->alpha;
@@ -713,6 +787,9 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
     MTLDepthStencilDescriptor *depthStencilDescriptor = nil;
     float depthBias = 0.f, depthBiasSlopeScale = 0.f, depthBiasClamp = 0.f;
     if (auto depthStencil = descriptor.depthStencil) {
+        if (NSString *error = errorValidatingDepthStencilState(*depthStencil))
+            return returnInvalidRenderPipeline(*this, isAsync, error);
+
         MTLPixelFormat depthStencilFormat = Texture::pixelFormat(depthStencil->format);
         bool isStencilOnlyFormat = Device::isStencilOnlyFormat(depthStencilFormat);
         mtlRenderPipelineDescriptor.depthAttachmentPixelFormat = isStencilOnlyFormat ? MTLPixelFormatInvalid : depthStencilFormat;
@@ -721,7 +798,7 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
 
         depthStencilDescriptor = [MTLDepthStencilDescriptor new];
         depthStencilDescriptor.depthCompareFunction = convertToMTLCompare(depthStencil->depthCompare);
-        depthStencilDescriptor.depthWriteEnabled = depthStencil->depthWriteEnabled;
+        depthStencilDescriptor.depthWriteEnabled = depthStencil->depthWriteEnabled.value_or(false);
         populateStencilOperation(depthStencilDescriptor.frontFaceStencil, depthStencil->stencilFront, depthStencil->stencilReadMask, depthStencil->stencilWriteMask);
         populateStencilOperation(depthStencilDescriptor.backFaceStencil, depthStencil->stencilBack, depthStencil->stencilReadMask, depthStencil->stencilWriteMask);
         depthBias = depthStencil->depthBias;
@@ -729,6 +806,9 @@ static WGPUTextureFormat convertFormat(WGSL::TexelFormat format)
         depthBiasClamp = depthStencil->depthBiasClamp;
     }
 
+    if (usesFragDepth && mtlRenderPipelineDescriptor.depthAttachmentPixelFormat == MTLPixelFormatInvalid)
+        return returnInvalidRenderPipeline(*this, isAsync, "Shader writes to frag depth but no depth texture set"_s);
+
     mtlRenderPipelineDescriptor.rasterSampleCount = descriptor.multisample.count ?: 1;
     mtlRenderPipelineDescriptor.alphaToCoverageEnabled = descriptor.multisample.alphaToCoverageEnabled;
     RELEASE_ASSERT([mtlRenderPipelineDescriptor respondsToSelector:@selector(setSampleMask:)]);
diff --git a/Source/WebGPU/WebGPU/Texture.h b/Source/WebGPU/WebGPU/Texture.h
index a4f9e83df867b..2730fa26048c4 100644
--- a/Source/WebGPU/WebGPU/Texture.h
+++ b/Source/WebGPU/WebGPU/Texture.h
@@ -83,6 +83,7 @@ class Texture : public WGPUTextureImpl, public RefCounted<Texture> {
     static WGPUTextureFormat removeSRGBSuffix(WGPUTextureFormat);
     static std::optional<WGPUTextureFormat> resolveTextureFormat(WGPUTextureFormat, WGPUTextureAspect);
     static bool isCompressedFormat(WGPUTextureFormat);
+    static bool isRenderableFormat(WGPUTextureFormat, const Device&);
 
     WGPUExtent3D logicalMiplevelSpecificTextureExtent(uint32_t mipLevel);
     WGPUExtent3D physicalMiplevelSpecificTextureExtent(uint32_t mipLevel);
@@ -104,6 +105,8 @@ class Texture : public WGPUTextureImpl, public RefCounted<Texture> {
     void setPreviouslyCleared(uint32_t mipLevel, uint32_t slice);
     bool isDestroyed() const;
     static bool hasStorageBindingCapability(WGPUTextureFormat, const Device&, WGPUStorageTextureAccess = WGPUStorageTextureAccess_Undefined);
+    static bool supportsMultisampling(WGPUTextureFormat, const Device&);
+    static bool supportsBlending(WGPUTextureFormat, const Device&);
 
 private:
     Texture(id<MTLTexture>, const WGPUTextureDescriptor&, Vector<WGPUTextureFormat>&& viewFormats, Device&);
diff --git a/Source/WebGPU/WebGPU/Texture.mm b/Source/WebGPU/WebGPU/Texture.mm
index eb389ede528c1..302c047cf7fca 100644
--- a/Source/WebGPU/WebGPU/Texture.mm
+++ b/Source/WebGPU/WebGPU/Texture.mm
@@ -732,7 +732,7 @@
     }
 }
 
-static bool isRenderableFormat(WGPUTextureFormat format, const Device& device)
+bool Texture::isRenderableFormat(WGPUTextureFormat format, const Device& device)
 {
     // https://gpuweb.github.io/gpuweb/#renderable-format
     switch (format) {
@@ -841,7 +841,7 @@ static bool isRenderableFormat(WGPUTextureFormat format, const Device& device)
     }
 }
 
-static bool supportsMultisampling(WGPUTextureFormat format, const Device& device)
+bool Texture::supportsMultisampling(WGPUTextureFormat format, const Device& device)
 {
     switch (format) {
     // https://gpuweb.github.io/gpuweb/#texture-format-caps
@@ -951,6 +951,115 @@ static bool supportsMultisampling(WGPUTextureFormat format, const Device& device
     }
 }
 
+bool Texture::supportsBlending(WGPUTextureFormat format, const Device& device)
+{
+    switch (format) {
+    // https://gpuweb.github.io/gpuweb/#texture-format-caps
+    case WGPUTextureFormat_R8Unorm:
+    case WGPUTextureFormat_RG8Unorm:
+    case WGPUTextureFormat_RGBA8Unorm:
+    case WGPUTextureFormat_RGBA8UnormSrgb:
+    case WGPUTextureFormat_BGRA8Unorm:
+    case WGPUTextureFormat_BGRA8UnormSrgb:
+    case WGPUTextureFormat_R16Float:
+    case WGPUTextureFormat_RG16Float:
+    case WGPUTextureFormat_RGBA16Float:
+    case WGPUTextureFormat_RGB10A2Unorm:
+        return true;
+    case WGPUTextureFormat_RG11B10Ufloat:
+        return device.hasFeature(WGPUFeatureName_RG11B10UfloatRenderable);
+    case WGPUTextureFormat_R8Snorm:
+    case WGPUTextureFormat_R8Uint:
+    case WGPUTextureFormat_R8Sint:
+    case WGPUTextureFormat_R16Uint:
+    case WGPUTextureFormat_R16Sint:
+    case WGPUTextureFormat_RG8Snorm:
+    case WGPUTextureFormat_RG8Uint:
+    case WGPUTextureFormat_RG8Sint:
+    case WGPUTextureFormat_R32Float:
+    case WGPUTextureFormat_RG16Uint:
+    case WGPUTextureFormat_RG16Sint:
+    case WGPUTextureFormat_RGBA8Snorm:
+    case WGPUTextureFormat_RGBA8Uint:
+    case WGPUTextureFormat_RGBA8Sint:
+    case WGPUTextureFormat_RGB10A2Uint:
+    case WGPUTextureFormat_RGBA16Uint:
+    case WGPUTextureFormat_RGBA16Sint:
+    case WGPUTextureFormat_Stencil8:
+    case WGPUTextureFormat_Depth16Unorm:
+    case WGPUTextureFormat_Depth24Plus:
+    case WGPUTextureFormat_Depth24PlusStencil8:
+    case WGPUTextureFormat_Depth32Float:
+    case WGPUTextureFormat_Depth32FloatStencil8:
+    case WGPUTextureFormat_R32Uint:
+    case WGPUTextureFormat_R32Sint:
+    case WGPUTextureFormat_RG32Float:
+    case WGPUTextureFormat_RG32Uint:
+    case WGPUTextureFormat_RG32Sint:
+    case WGPUTextureFormat_RGBA32Float:
+    case WGPUTextureFormat_RGBA32Uint:
+    case WGPUTextureFormat_RGBA32Sint:
+    case WGPUTextureFormat_RGB9E5Ufloat:
+    case WGPUTextureFormat_BC1RGBAUnorm:
+    case WGPUTextureFormat_BC1RGBAUnormSrgb:
+    case WGPUTextureFormat_BC2RGBAUnorm:
+    case WGPUTextureFormat_BC2RGBAUnormSrgb:
+    case WGPUTextureFormat_BC3RGBAUnorm:
+    case WGPUTextureFormat_BC3RGBAUnormSrgb:
+    case WGPUTextureFormat_BC4RUnorm:
+    case WGPUTextureFormat_BC4RSnorm:
+    case WGPUTextureFormat_BC5RGUnorm:
+    case WGPUTextureFormat_BC5RGSnorm:
+    case WGPUTextureFormat_BC6HRGBUfloat:
+    case WGPUTextureFormat_BC6HRGBFloat:
+    case WGPUTextureFormat_BC7RGBAUnorm:
+    case WGPUTextureFormat_BC7RGBAUnormSrgb:
+    case WGPUTextureFormat_ETC2RGB8Unorm:
+    case WGPUTextureFormat_ETC2RGB8UnormSrgb:
+    case WGPUTextureFormat_ETC2RGB8A1Unorm:
+    case WGPUTextureFormat_ETC2RGB8A1UnormSrgb:
+    case WGPUTextureFormat_ETC2RGBA8Unorm:
+    case WGPUTextureFormat_ETC2RGBA8UnormSrgb:
+    case WGPUTextureFormat_EACR11Unorm:
+    case WGPUTextureFormat_EACR11Snorm:
+    case WGPUTextureFormat_EACRG11Unorm:
+    case WGPUTextureFormat_EACRG11Snorm:
+    case WGPUTextureFormat_ASTC4x4Unorm:
+    case WGPUTextureFormat_ASTC4x4UnormSrgb:
+    case WGPUTextureFormat_ASTC5x4Unorm:
+    case WGPUTextureFormat_ASTC5x4UnormSrgb:
+    case WGPUTextureFormat_ASTC5x5Unorm:
+    case WGPUTextureFormat_ASTC5x5UnormSrgb:
+    case WGPUTextureFormat_ASTC6x5Unorm:
+    case WGPUTextureFormat_ASTC6x5UnormSrgb:
+    case WGPUTextureFormat_ASTC6x6Unorm:
+    case WGPUTextureFormat_ASTC6x6UnormSrgb:
+    case WGPUTextureFormat_ASTC8x5Unorm:
+    case WGPUTextureFormat_ASTC8x5UnormSrgb:
+    case WGPUTextureFormat_ASTC8x6Unorm:
+    case WGPUTextureFormat_ASTC8x6UnormSrgb:
+    case WGPUTextureFormat_ASTC8x8Unorm:
+    case WGPUTextureFormat_ASTC8x8UnormSrgb:
+    case WGPUTextureFormat_ASTC10x5Unorm:
+    case WGPUTextureFormat_ASTC10x5UnormSrgb:
+    case WGPUTextureFormat_ASTC10x6Unorm:
+    case WGPUTextureFormat_ASTC10x6UnormSrgb:
+    case WGPUTextureFormat_ASTC10x8Unorm:
+    case WGPUTextureFormat_ASTC10x8UnormSrgb:
+    case WGPUTextureFormat_ASTC10x10Unorm:
+    case WGPUTextureFormat_ASTC10x10UnormSrgb:
+    case WGPUTextureFormat_ASTC12x10Unorm:
+    case WGPUTextureFormat_ASTC12x10UnormSrgb:
+    case WGPUTextureFormat_ASTC12x12Unorm:
+    case WGPUTextureFormat_ASTC12x12UnormSrgb:
+        return false;
+    case WGPUTextureFormat_Undefined:
+    case WGPUTextureFormat_Force32:
+        ASSERT_NOT_REACHED();
+        return false;
+    }
+}
+
 static uint32_t maximumMiplevelCount(WGPUTextureDimension dimension, WGPUExtent3D size)
 {
     // https://gpuweb.github.io/gpuweb/#abstract-opdef-maximum-miplevel-count
@@ -1311,10 +1420,10 @@ static bool textureViewFormatCompatible(WGPUTextureFormat format1, WGPUTextureFo
         if ((descriptor.usage & WGPUTextureUsage_StorageBinding) || !(descriptor.usage & WGPUTextureUsage_RenderAttachment))
             return @"createTexture: descriptor.sampleCount > 1 and (descriptor.usage & WGPUTextureUsage_StorageBinding) || !(descriptor.usage & WGPUTextureUsage_RenderAttachment)";
 
-        if (!isRenderableFormat(descriptor.format, *this))
+        if (!Texture::isRenderableFormat(descriptor.format, *this))
             return @"createTexture: descriptor.sampleCount > 1 and !isRenderableFormat(descriptor.format, *this)";
 
-        if (!supportsMultisampling(descriptor.format, *this))
+        if (!Texture::supportsMultisampling(descriptor.format, *this))
             return @"createTexture: descriptor.sampleCount > 1 and !supportsMultisampling(descriptor.format, *this)";
     }
 
@@ -1322,7 +1431,7 @@ static bool textureViewFormatCompatible(WGPUTextureFormat format1, WGPUTextureFo
         return @"createTexture: descriptor.mipLevelCount > maximumMiplevelCount(descriptor.dimension, descriptor.size)";
 
     if (descriptor.usage & WGPUTextureUsage_RenderAttachment) {
-        if (!isRenderableFormat(descriptor.format, *this))
+        if (!Texture::isRenderableFormat(descriptor.format, *this))
             return @"createTexture: descriptor.usage & WGPUTextureUsage_RenderAttachment && !isRenderableFormat(descriptor.format, *this)";
 
         if (descriptor.dimension == WGPUTextureDimension_1D)
diff --git a/Source/WebGPU/WebGPU/WebGPU.h b/Source/WebGPU/WebGPU/WebGPU.h
index a2fad5757cb61..b5b7e95723569 100644
--- a/Source/WebGPU/WebGPU/WebGPU.h
+++ b/Source/WebGPU/WebGPU/WebGPU.h
@@ -1157,7 +1157,11 @@ typedef struct WGPUComputePassDescriptor {
 typedef struct WGPUDepthStencilState {
     WGPUChainedStruct const * nextInChain;
     WGPUTextureFormat format;
+#ifdef __cplusplus
+    std::optional<WGPUBool> depthWriteEnabled;
+#else
     WGPUBool depthWriteEnabled;
+#endif
     WGPUCompareFunction depthCompare;
     WGPUStencilFaceState stencilFront;
     WGPUStencilFaceState stencilBack;
diff --git a/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.h b/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.h
index 83e0a6d9adc39..8f9ceffe7810a 100644
--- a/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.h
+++ b/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.h
@@ -38,8 +38,8 @@ namespace WebKit::WebGPU {
 struct DepthStencilState {
     WebCore::WebGPU::TextureFormat format { WebCore::WebGPU::TextureFormat::R8unorm };
 
-    bool depthWriteEnabled { false };
-    WebCore::WebGPU::CompareFunction depthCompare { WebCore::WebGPU::CompareFunction::Always };
+    std::optional<bool> depthWriteEnabled;
+    std::optional<WebCore::WebGPU::CompareFunction> depthCompare;
 
     StencilFaceState stencilFront;
     StencilFaceState stencilBack;
diff --git a/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.serialization.in b/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.serialization.in
index 64be9bd6a4ef9..c49f917531223 100644
--- a/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.serialization.in
+++ b/Source/WebKit/Shared/WebGPU/WebGPUDepthStencilState.serialization.in
@@ -24,8 +24,8 @@
 [AdditionalEncoder=StreamConnectionEncoder] struct WebKit::WebGPU::DepthStencilState {
     WebCore::WebGPU::TextureFormat format;
 
-    bool depthWriteEnabled;
-    WebCore::WebGPU::CompareFunction depthCompare;
+    std::optional<bool> depthWriteEnabled;
+    std::optional<WebCore::WebGPU::CompareFunction> depthCompare;
 
     WebKit::WebGPU::StencilFaceState stencilFront;
     WebKit::WebGPU::StencilFaceState stencilBack;