webgpu: Update wgpu and revamp computepass (#32575)

* Do not wait on drop, but rather wake poller thread * Update wgpu and render stuff * Set some good expectations * Update wgpu again * handle IPC error as warning * More good expectations * Some more expectations CTS does not match the spec: https://github.com/gpuweb/cts/issues/3806 * This expectations are due to other changes in servo also happening on main * Explain error_command_encoders and remove RefCell around it * fixup * store validness of passes * More good expectations * More docs * this assert is wrong * This is even more right per CTS/spec Only Command encoder state errors are allowed here, but wgpu does not exposes them. * More good expectations * One bad expectation * Fix my english
author: Samson <16504129+sagudev@users.noreply.github.com> 2024-06-28 06:49:35 +0200
committer: GitHub <noreply@github.com> 2024-06-28 04:49:35 +0000
commit: e9cf4d4971c0ce8ec64da7f09d6e97ae10be5b05 (patch)
tree: fb9f0179cfe93744118835c3a34edc8c19672a3e
parent: fced0b49404c02bb5aafa9ddd468f9077ce26c19 (diff)
download: servo-e9cf4d4971c0ce8ec64da7f09d6e97ae10be5b05.tar.gz
servo-e9cf4d4971c0ce8ec64da7f09d6e97ae10be5b05.zip
16 files changed, 369 insertions, 1867 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 53f9359edfd..4dc79a0df78 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -214,11 +214,11 @@ checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
 
 [[package]]
 name = "ash"
-version = "0.37.3+1.3.251"
+version = "0.38.0+1.3.281"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39e9c3835d686b0a6084ab4234fcd1b07dbf6e4767dce60874b12356a25ecd4a"
+checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f"
 dependencies = [
- "libloading 0.7.4",
+ "libloading 0.8.4",
 ]
 
 [[package]]
@@ -1176,10 +1176,10 @@ checksum = "96a6ac251f4a2aca6b3f91340350eab87ae57c3f127ffeb585e92bd336717991"
 [[package]]
 name = "d3d12"
 version = "0.20.0"
-source = "git+https://github.com/gfx-rs/wgpu?rev=d0a5e48aa7e84683114c3870051cc414ae92ac03#d0a5e48aa7e84683114c3870051cc414ae92ac03"
+source = "git+https://github.com/gfx-rs/wgpu?rev=1e784c9c0af7a785b62e3b6840ed012a7477520f#1e784c9c0af7a785b62e3b6840ed012a7477520f"
 dependencies = [
  "bitflags 2.6.0",
- "libloading 0.8.4",
+ "libloading 0.7.4",
  "winapi",
 ]
 
@@ -2261,9 +2261,9 @@ dependencies = [
 
 [[package]]
 name = "glutin_wgl_sys"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8098adac955faa2d31079b65dc48841251f69efd3ac25477903fc424362ead"
+checksum = "0a4e1951bbd9434a81aa496fe59ccc2235af3820d27b85f9314e279609211e2c"
 dependencies = [
  "gl_generator",
 ]
@@ -4003,7 +4003,7 @@ checksum = "956787520e75e9bd233246045d19f42fb73242759cc57fba9611d940ae96d4b0"
 [[package]]
 name = "naga"
 version = "0.20.0"
-source = "git+https://github.com/gfx-rs/wgpu?rev=d0a5e48aa7e84683114c3870051cc414ae92ac03#d0a5e48aa7e84683114c3870051cc414ae92ac03"
+source = "git+https://github.com/gfx-rs/wgpu?rev=1e784c9c0af7a785b62e3b6840ed012a7477520f#1e784c9c0af7a785b62e3b6840ed012a7477520f"
 dependencies = [
  "arrayvec",
  "bit-set",
@@ -4012,7 +4012,6 @@ dependencies = [
  "hexf-parse",
  "indexmap",
  "log",
- "num-traits",
  "rustc-hash",
  "serde",
  "spirv",
@@ -7295,7 +7294,7 @@ checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
 [[package]]
 name = "wgpu-core"
 version = "0.20.0"
-source = "git+https://github.com/gfx-rs/wgpu?rev=d0a5e48aa7e84683114c3870051cc414ae92ac03#d0a5e48aa7e84683114c3870051cc414ae92ac03"
+source = "git+https://github.com/gfx-rs/wgpu?rev=1e784c9c0af7a785b62e3b6840ed012a7477520f#1e784c9c0af7a785b62e3b6840ed012a7477520f"
 dependencies = [
  "arrayvec",
  "bit-vec",
@@ -7313,7 +7312,6 @@ dependencies = [
  "serde",
  "smallvec",
  "thiserror",
- "web-sys",
  "wgpu-hal",
  "wgpu-types",
 ]
@@ -7321,7 +7319,7 @@ dependencies = [
 [[package]]
 name = "wgpu-hal"
 version = "0.20.0"
-source = "git+https://github.com/gfx-rs/wgpu?rev=d0a5e48aa7e84683114c3870051cc414ae92ac03#d0a5e48aa7e84683114c3870051cc414ae92ac03"
+source = "git+https://github.com/gfx-rs/wgpu?rev=1e784c9c0af7a785b62e3b6840ed012a7477520f#1e784c9c0af7a785b62e3b6840ed012a7477520f"
 dependencies = [
  "android_system_properties",
  "arrayvec",
@@ -7339,7 +7337,7 @@ dependencies = [
  "js-sys",
  "khronos-egl",
  "libc",
- "libloading 0.8.4",
+ "libloading 0.7.4",
  "log",
  "metal 0.28.0",
  "naga",
@@ -7362,7 +7360,7 @@ dependencies = [
 [[package]]
 name = "wgpu-types"
 version = "0.20.0"
-source = "git+https://github.com/gfx-rs/wgpu?rev=d0a5e48aa7e84683114c3870051cc414ae92ac03#d0a5e48aa7e84683114c3870051cc414ae92ac03"
+source = "git+https://github.com/gfx-rs/wgpu?rev=1e784c9c0af7a785b62e3b6840ed012a7477520f#1e784c9c0af7a785b62e3b6840ed012a7477520f"
 dependencies = [
  "bitflags 2.6.0",
  "js-sys",
diff --git a/Cargo.toml b/Cargo.toml
index f9d6711de24..7efb895ac9e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -136,8 +136,8 @@ webpki-roots = "0.25"
 webrender = { git = "https://github.com/servo/webrender", branch = "0.64", features = ["capture"] }
 webrender_api = { git = "https://github.com/servo/webrender", branch = "0.64" }
 webrender_traits = { path = "components/shared/webrender" }
-wgpu-core = { git = "https://github.com/gfx-rs/wgpu", rev = "d0a5e48aa7e84683114c3870051cc414ae92ac03" }
-wgpu-types = { git = "https://github.com/gfx-rs/wgpu", rev = "d0a5e48aa7e84683114c3870051cc414ae92ac03" }
+wgpu-core = { git = "https://github.com/gfx-rs/wgpu", rev = "1e784c9c0af7a785b62e3b6840ed012a7477520f" }
+wgpu-types = { git = "https://github.com/gfx-rs/wgpu", rev = "1e784c9c0af7a785b62e3b6840ed012a7477520f" }
 windows-sys = "0.52"
 xi-unicode = "0.1.0"
 xml5ever = "0.18"
diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs
index cacc5eaa17b..3e0bc2d0881 100644
--- a/components/script/dom/bindings/trace.rs
+++ b/components/script/dom/bindings/trace.rs
@@ -64,7 +64,6 @@ use crate::dom::bindings::str::{DOMString, USVString};
 use crate::dom::bindings::utils::WindowProxyHandler;
 use crate::dom::gpubuffer::GPUBufferState;
 use crate::dom::gpucanvascontext::WebGPUContextId;
-use crate::dom::gpucommandencoder::GPUCommandEncoderState;
 use crate::dom::htmlimageelement::SourceSet;
 use crate::dom::htmlmediaelement::HTMLMediaElementFetchContext;
 use crate::script_runtime::{ContextForRequestInterrupt, StreamConsumer};
@@ -371,7 +370,6 @@ unsafe_no_jsmanaged_fields!(DOMString);
 unsafe_no_jsmanaged_fields!(USVString);
 unsafe_no_jsmanaged_fields!(WebGPUContextId);
 unsafe_no_jsmanaged_fields!(GPUBufferState);
-unsafe_no_jsmanaged_fields!(GPUCommandEncoderState);
 unsafe_no_jsmanaged_fields!(SourceSet);
 unsafe_no_jsmanaged_fields!(HTMLMediaElementFetchContext);
 unsafe_no_jsmanaged_fields!(StreamConsumer);
diff --git a/components/script/dom/gpucommandencoder.rs b/components/script/dom/gpucommandencoder.rs
index 799db233a28..5024f9ff9f9 100644
--- a/components/script/dom/gpucommandencoder.rs
+++ b/components/script/dom/gpucommandencoder.rs
@@ -8,8 +8,9 @@ use std::collections::HashSet;
 
 use dom_struct::dom_struct;
 use webgpu::wgc::command as wgpu_com;
-use webgpu::{self, wgt, WebGPU, WebGPURequest};
+use webgpu::{self, wgt, WebGPU, WebGPUComputePass, WebGPURequest};
 
+use super::gpuconvert::convert_label;
 use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::WebGPUBinding::{
     GPUCommandBufferDescriptor, GPUCommandEncoderMethods, GPUComputePassDescriptor, GPUExtent3D,
@@ -31,16 +32,6 @@ use crate::dom::gpuconvert::{
 use crate::dom::gpudevice::GPUDevice;
 use crate::dom::gpurenderpassencoder::GPURenderPassEncoder;
 
-// TODO(sagudev): this is different now
-// https://gpuweb.github.io/gpuweb/#enumdef-encoder-state
-#[derive(MallocSizeOf, PartialEq)]
-pub enum GPUCommandEncoderState {
-    Open,
-    EncodingRenderPass,
-    EncodingComputePass,
-    Closed,
-}
-
 #[dom_struct]
 pub struct GPUCommandEncoder {
     reflector_: Reflector,
@@ -51,7 +42,6 @@ pub struct GPUCommandEncoder {
     #[no_trace]
     encoder: webgpu::WebGPUCommandEncoder,
     buffers: DomRefCell<HashSet<DomRoot<GPUBuffer>>>,
-    state: DomRefCell<GPUCommandEncoderState>,
     device: Dom<GPUDevice>,
     valid: Cell<bool>,
 }
@@ -70,7 +60,6 @@ impl GPUCommandEncoder {
             device: Dom::from_ref(device),
             encoder,
             buffers: DomRefCell::new(HashSet::new()),
-            state: DomRefCell::new(GPUCommandEncoderState::Open),
             valid: Cell::new(true),
         }
     }
@@ -96,13 +85,8 @@ impl GPUCommandEncoder {
         self.encoder
     }
 
-    pub fn set_state(&self, set: GPUCommandEncoderState, expect: GPUCommandEncoderState) {
-        if *self.state.borrow() == expect {
-            *self.state.borrow_mut() = set;
-        } else {
-            self.valid.set(false);
-            *self.state.borrow_mut() = GPUCommandEncoderState::Closed;
-        }
+    pub fn device_id(&self) -> webgpu::WebGPUDevice {
+        self.device.id()
     }
 }
 
@@ -122,32 +106,26 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
         &self,
         descriptor: &GPUComputePassDescriptor,
     ) -> DomRoot<GPUComputePassEncoder> {
-        self.set_state(
-            GPUCommandEncoderState::EncodingComputePass,
-            GPUCommandEncoderState::Open,
-        );
+        let compute_pass_id = self
+            .global()
+            .wgpu_id_hub()
+            .lock()
+            .create_compute_pass_id(self.device.id().0.backend());
 
-        let compute_pass = if !self.valid.get() {
-            None
-        } else {
-            Some(wgpu_com::ComputePass::new(
-                self.encoder.0,
-                &wgpu_com::ComputePassDescriptor {
-                    label: descriptor
-                        .parent
-                        .label
-                        .as_ref()
-                        .map(|l| Cow::Borrowed(&**l)),
-                    timestamp_writes: None,
-                },
-            ))
-        };
+        if let Err(e) = self.channel.0.send(WebGPURequest::BeginComputePass {
+            command_encoder_id: self.id().0,
+            compute_pass_id,
+            label: convert_label(&descriptor.parent),
+            device_id: self.device.id().0,
+        }) {
+            warn!("Failed to send WebGPURequest::BeginComputePass {e:?}");
+        }
 
         GPUComputePassEncoder::new(
             &self.global(),
             self.channel.clone(),
             self,
-            compute_pass,
+            WebGPUComputePass(compute_pass_id),
             descriptor.parent.label.clone().unwrap_or_default(),
         )
     }
@@ -157,11 +135,6 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
         &self,
         descriptor: &GPURenderPassDescriptor,
     ) -> DomRoot<GPURenderPassEncoder> {
-        self.set_state(
-            GPUCommandEncoderState::EncodingRenderPass,
-            GPUCommandEncoderState::Open,
-        );
-
         let render_pass = if !self.valid.get() {
             None
         } else {
@@ -259,11 +232,6 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
         destination_offset: GPUSize64,
         size: GPUSize64,
     ) {
-        if !(*self.state.borrow() == GPUCommandEncoderState::Open) {
-            self.valid.set(false);
-            return;
-        }
-
         self.buffers.borrow_mut().insert(DomRoot::from_ref(source));
         self.buffers
             .borrow_mut()
@@ -288,11 +256,6 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
         destination: &GPUImageCopyTexture,
         copy_size: GPUExtent3D,
     ) {
-        if !(*self.state.borrow() == GPUCommandEncoderState::Open) {
-            self.valid.set(false);
-            return;
-        }
-
         self.buffers
             .borrow_mut()
             .insert(DomRoot::from_ref(&*source.buffer));
@@ -315,11 +278,6 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
         destination: &GPUImageCopyBuffer,
         copy_size: GPUExtent3D,
     ) {
-        if !(*self.state.borrow() == GPUCommandEncoderState::Open) {
-            self.valid.set(false);
-            return;
-        }
-
         self.buffers
             .borrow_mut()
             .insert(DomRoot::from_ref(&*destination.buffer));
@@ -342,11 +300,6 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
         destination: &GPUImageCopyTexture,
         copy_size: GPUExtent3D,
     ) {
-        if !(*self.state.borrow() == GPUCommandEncoderState::Open) {
-            self.valid.set(false);
-            return;
-        }
-
         self.channel
             .0
             .send(WebGPURequest::CopyTextureToTexture {
@@ -371,7 +324,6 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
             })
             .expect("Failed to send Finish");
 
-        *self.state.borrow_mut() = GPUCommandEncoderState::Closed;
         let buffer = webgpu::WebGPUCommandBuffer(self.encoder.0.into_command_buffer_id());
         GPUCommandBuffer::new(
             &self.global(),
diff --git a/components/script/dom/gpucomputepassencoder.rs b/components/script/dom/gpucomputepassencoder.rs
index 23ffba400fc..4fd943fd3bc 100644
--- a/components/script/dom/gpucomputepassencoder.rs
+++ b/components/script/dom/gpucomputepassencoder.rs
@@ -3,8 +3,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use dom_struct::dom_struct;
-use webgpu::wgc::command::{compute_commands as wgpu_comp, ComputePass};
-use webgpu::{WebGPU, WebGPURequest};
+use webgpu::{WebGPU, WebGPUComputePass, WebGPURequest};
 
 use super::bindings::error::Fallible;
 use crate::dom::bindings::cell::DomRefCell;
@@ -15,7 +14,7 @@ use crate::dom::bindings::str::USVString;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::gpubindgroup::GPUBindGroup;
 use crate::dom::gpubuffer::GPUBuffer;
-use crate::dom::gpucommandencoder::{GPUCommandEncoder, GPUCommandEncoderState};
+use crate::dom::gpucommandencoder::GPUCommandEncoder;
 use crate::dom::gpucomputepipeline::GPUComputePipeline;
 
 #[dom_struct]
@@ -25,9 +24,8 @@ pub struct GPUComputePassEncoder {
     #[no_trace]
     channel: WebGPU,
     label: DomRefCell<USVString>,
-    #[ignore_malloc_size_of = "defined in wgpu-core"]
     #[no_trace]
-    compute_pass: DomRefCell<Option<ComputePass>>,
+    compute_pass: WebGPUComputePass,
     command_encoder: Dom<GPUCommandEncoder>,
 }
 
@@ -35,14 +33,14 @@ impl GPUComputePassEncoder {
     fn new_inherited(
         channel: WebGPU,
         parent: &GPUCommandEncoder,
-        compute_pass: Option<ComputePass>,
+        compute_pass: WebGPUComputePass,
         label: USVString,
     ) -> Self {
         Self {
             channel,
             reflector_: Reflector::new(),
             label: DomRefCell::new(label),
-            compute_pass: DomRefCell::new(compute_pass),
+            compute_pass,
             command_encoder: Dom::from_ref(parent),
         }
     }
@@ -51,7 +49,7 @@ impl GPUComputePassEncoder {
         global: &GlobalScope,
         channel: WebGPU,
         parent: &GPUCommandEncoder,
-        compute_pass: Option<ComputePass>,
+        compute_pass: WebGPUComputePass,
         label: USVString,
     ) -> DomRoot<Self> {
         reflect_dom_object(
@@ -79,57 +77,83 @@ impl GPUComputePassEncoderMethods for GPUComputePassEncoder {
 
     /// <https://gpuweb.github.io/gpuweb/#dom-gpucomputepassencoder-dispatchworkgroups>
     fn DispatchWorkgroups(&self, x: u32, y: u32, z: u32) {
-        if let Some(compute_pass) = self.compute_pass.borrow_mut().as_mut() {
-            wgpu_comp::wgpu_compute_pass_dispatch_workgroups(compute_pass, x, y, z);
+        if let Err(e) = self
+            .channel
+            .0
+            .send(WebGPURequest::ComputePassDispatchWorkgroups {
+                compute_pass_id: self.compute_pass.0,
+                x,
+                y,
+                z,
+                device_id: self.command_encoder.device_id().0,
+            })
+        {
+            warn!("Error sending WebGPURequest::ComputePassDispatchWorkgroups: {e:?}")
         }
     }
 
     /// <https://gpuweb.github.io/gpuweb/#dom-gpucomputepassencoder-dispatchworkgroupsindirect>
-    fn DispatchWorkgroupsIndirect(&self, indirect_buffer: &GPUBuffer, indirect_offset: u64) {
-        if let Some(compute_pass) = self.compute_pass.borrow_mut().as_mut() {
-            wgpu_comp::wgpu_compute_pass_dispatch_workgroups_indirect(
-                compute_pass,
-                indirect_buffer.id().0,
-                indirect_offset,
-            );
+    fn DispatchWorkgroupsIndirect(&self, buffer: &GPUBuffer, offset: u64) {
+        if let Err(e) = self
+            .channel
+            .0
+            .send(WebGPURequest::ComputePassDispatchWorkgroupsIndirect {
+                compute_pass_id: self.compute_pass.0,
+                buffer_id: buffer.id().0,
+                offset,
+                device_id: self.command_encoder.device_id().0,
+            })
+        {
+            warn!("Error sending WebGPURequest::ComputePassDispatchWorkgroupsIndirect: {e:?}")
         }
     }
 
     /// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-endpass>
     fn End(&self) -> Fallible<()> {
-        let compute_pass = self.compute_pass.borrow_mut().take();
-        self.channel
-            .0
-            .send(WebGPURequest::RunComputePass {
-                command_encoder_id: self.command_encoder.id().0,
-                compute_pass,
-            })
-            .expect("Failed to send RunComputePass"); //TODO: handle error
-
-        self.command_encoder.set_state(
-            GPUCommandEncoderState::Open,
-            GPUCommandEncoderState::EncodingComputePass,
-        );
+        if let Err(e) = self.channel.0.send(WebGPURequest::EndComputePass {
+            compute_pass_id: self.compute_pass.0,
+            device_id: self.command_encoder.device_id().0,
+            command_encoder_id: self.command_encoder.id().0,
+        }) {
+            warn!("Failed to send WebGPURequest::EndComputePass: {e:?}");
+        }
         Ok(())
     }
 
     /// <https://gpuweb.github.io/gpuweb/#dom-gpuprogrammablepassencoder-setbindgroup>
     #[allow(unsafe_code)]
-    fn SetBindGroup(&self, index: u32, bind_group: &GPUBindGroup, dynamic_offsets: Vec<u32>) {
-        if let Some(compute_pass) = self.compute_pass.borrow_mut().as_mut() {
-            wgpu_comp::wgpu_compute_pass_set_bind_group(
-                compute_pass,
-                index,
-                bind_group.id().0,
-                &dynamic_offsets,
-            )
+    fn SetBindGroup(&self, index: u32, bind_group: &GPUBindGroup, offsets: Vec<u32>) {
+        if let Err(e) = self.channel.0.send(WebGPURequest::ComputePassSetBindGroup {
+            compute_pass_id: self.compute_pass.0,
+            index,
+            bind_group_id: bind_group.id().0,
+            offsets,
+            device_id: self.command_encoder.device_id().0,
+        }) {
+            warn!("Error sending WebGPURequest::ComputePassSetBindGroup: {e:?}")
         }
     }
 
     /// <https://gpuweb.github.io/gpuweb/#dom-gpucomputepassencoder-setpipeline>
     fn SetPipeline(&self, pipeline: &GPUComputePipeline) {
-        if let Some(compute_pass) = self.compute_pass.borrow_mut().as_mut() {
-            wgpu_comp::wgpu_compute_pass_set_pipeline(compute_pass, pipeline.id().0);
+        if let Err(e) = self.channel.0.send(WebGPURequest::ComputePassSetPipeline {
+            compute_pass_id: self.compute_pass.0,
+            pipeline_id: pipeline.id().0,
+            device_id: self.command_encoder.device_id().0,
+        }) {
+            warn!("Error sending WebGPURequest::ComputePassSetPipeline: {e:?}")
+        }
+    }
+}
+
+impl Drop for GPUComputePassEncoder {
+    fn drop(&mut self) {
+        if let Err(e) = self
+            .channel
+            .0
+            .send(WebGPURequest::DropComputePass(self.compute_pass.0))
+        {
+            warn!("Failed to send WebGPURequest::DropComputePass with {e:?}");
         }
     }
 }
diff --git a/components/script/dom/gpudevice.rs b/components/script/dom/gpudevice.rs
index da1432e99b6..f2f9cf4f721 100644
--- a/components/script/dom/gpudevice.rs
+++ b/components/script/dom/gpudevice.rs
@@ -586,7 +586,9 @@ impl GPUDeviceMethods for GPUDevice {
                 entry_point: Some(Cow::Owned(descriptor.compute.entryPoint.to_string())),
                 constants: Cow::Owned(HashMap::new()),
                 zero_initialize_workgroup_memory: true,
+                vertex_pulling_transform: false,
             },
+            cache: None,
         };
 
         self.channel
@@ -769,6 +771,7 @@ impl GPUDeviceMethods for GPUDevice {
             Some(wgpu_pipe::RenderPipelineDescriptor {
                 label: convert_label(&descriptor.parent.parent),
                 layout,
+                cache: None,
                 vertex: wgpu_pipe::VertexState {
                     stage: wgpu_pipe::ProgrammableStageDescriptor {
                         module: descriptor.vertex.parent.module.id().0,
@@ -777,6 +780,7 @@ impl GPUDeviceMethods for GPUDevice {
                         )),
                         constants: Cow::Owned(HashMap::new()),
                         zero_initialize_workgroup_memory: true,
+                        vertex_pulling_transform: false,
                     },
                     buffers: Cow::Owned(
                         descriptor
@@ -813,6 +817,7 @@ impl GPUDeviceMethods for GPUDevice {
                             entry_point: Some(Cow::Owned(stage.parent.entryPoint.to_string())),
                             constants: Cow::Owned(HashMap::new()),
                             zero_initialize_workgroup_memory: true,
+                            vertex_pulling_transform: false,
                         },
                         targets: Cow::Owned(
                             stage
diff --git a/components/script/dom/gpurenderpassencoder.rs b/components/script/dom/gpurenderpassencoder.rs
index e650284664f..5fc3d20c3df 100644
--- a/components/script/dom/gpurenderpassencoder.rs
+++ b/components/script/dom/gpurenderpassencoder.rs
@@ -19,7 +19,7 @@ use crate::dom::bindings::str::USVString;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::gpubindgroup::GPUBindGroup;
 use crate::dom::gpubuffer::GPUBuffer;
-use crate::dom::gpucommandencoder::{GPUCommandEncoder, GPUCommandEncoderState};
+use crate::dom::gpucommandencoder::GPUCommandEncoder;
 use crate::dom::gpurenderbundle::GPURenderBundle;
 use crate::dom::gpurenderpipeline::GPURenderPipeline;
 
@@ -164,16 +164,12 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
         let render_pass = self.render_pass.borrow_mut().take();
         self.channel
             .0
-            .send(WebGPURequest::RunRenderPass {
-                command_encoder_id: self.command_encoder.id().0,
+            .send(WebGPURequest::EndRenderPass {
                 render_pass,
+                device_id: self.command_encoder.device_id().0,
             })
             .expect("Failed to send RunRenderPass");
 
-        self.command_encoder.set_state(
-            GPUCommandEncoderState::Open,
-            GPUCommandEncoderState::EncodingRenderPass,
-        );
         Ok(())
     }
 
diff --git a/components/script/dom/identityhub.rs b/components/script/dom/identityhub.rs
index f97e02ecaf4..cb1b0c39d6a 100644
--- a/components/script/dom/identityhub.rs
+++ b/components/script/dom/identityhub.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use smallvec::SmallVec;
+use webgpu::identity::{ComputePass, ComputePassId};
 use webgpu::wgc::id::markers::{
     Adapter, BindGroup, BindGroupLayout, Buffer, CommandEncoder, ComputePipeline, Device,
     PipelineLayout, RenderBundle, RenderPipeline, Sampler, ShaderModule, Texture, TextureView,
@@ -31,6 +32,7 @@ pub struct IdentityHub {
     samplers: IdentityManager<Sampler>,
     render_pipelines: IdentityManager<RenderPipeline>,
     render_bundles: IdentityManager<RenderBundle>,
+    compute_passes: IdentityManager<ComputePass>,
 }
 
 impl IdentityHub {
@@ -50,6 +52,7 @@ impl IdentityHub {
             samplers: IdentityManager::new(),
             render_pipelines: IdentityManager::new(),
             render_bundles: IdentityManager::new(),
+            compute_passes: IdentityManager::new(),
         }
     }
 }
@@ -225,6 +228,14 @@ impl Identities {
     pub fn kill_render_bundle_id(&mut self, id: RenderBundleId) {
         self.select(id.backend()).render_bundles.free(id);
     }
+
+    pub fn create_compute_pass_id(&mut self, backend: Backend) -> ComputePassId {
+        self.select(backend).compute_passes.process(backend)
+    }
+
+    pub fn kill_compute_pass_id(&mut self, id: ComputePassId) {
+        self.select(id.backend()).compute_passes.free(id);
+    }
 }
 
 impl Default for Identities {
diff --git a/components/script/script_thread.rs b/components/script/script_thread.rs
index f57451195cd..258af8eecc6 100644
--- a/components/script/script_thread.rs
+++ b/components/script/script_thread.rs
@@ -2450,6 +2450,7 @@ impl ScriptThread {
             WebGPUMsg::FreeRenderPipeline(id) => self.gpu_id_hub.lock().kill_render_pipeline_id(id),
             WebGPUMsg::FreeTexture(id) => self.gpu_id_hub.lock().kill_texture_id(id),
             WebGPUMsg::FreeTextureView(id) => self.gpu_id_hub.lock().kill_texture_view_id(id),
+            WebGPUMsg::FreeComputePass(id) => self.gpu_id_hub.lock().kill_compute_pass_id(id),
             WebGPUMsg::Exit => *self.webgpu_port.borrow_mut() = None,
             WebGPUMsg::DeviceLost {
                 pipeline_id,
diff --git a/components/webgpu/dom_messages.rs b/components/webgpu/dom_messages.rs
index f9f0fc0ffe5..78bde1c91b2 100644
--- a/components/webgpu/dom_messages.rs
+++ b/components/webgpu/dom_messages.rs
@@ -16,8 +16,7 @@ use wgc::binding_model::{
     BindGroupDescriptor, BindGroupLayoutDescriptor, PipelineLayoutDescriptor,
 };
 use wgc::command::{
-    ComputePass, ImageCopyBuffer, ImageCopyTexture, RenderBundleDescriptor, RenderBundleEncoder,
-    RenderPass,
+    ImageCopyBuffer, ImageCopyTexture, RenderBundleDescriptor, RenderBundleEncoder, RenderPass,
 };
 use wgc::device::HostMap;
 use wgc::id;
@@ -191,6 +190,7 @@ pub enum WebGPURequest {
     DropShaderModule(id::ShaderModuleId),
     DropRenderBundle(id::RenderBundleId),
     DropQuerySet(id::QuerySetId),
+    DropComputePass(id::ComputePassEncoderId),
     Exit(IpcSender<()>),
     RenderBundleEncoderFinish {
         render_bundle_encoder: RenderBundleEncoder,
@@ -210,13 +210,45 @@ pub enum WebGPURequest {
         device_id: id::DeviceId,
         pipeline_id: PipelineId,
     },
-    RunComputePass {
+    BeginComputePass {
         command_encoder_id: id::CommandEncoderId,
-        compute_pass: Option<ComputePass>,
+        compute_pass_id: ComputePassId,
+        label: Option<Cow<'static, str>>,
+        device_id: id::DeviceId,
+    },
+    ComputePassSetPipeline {
+        compute_pass_id: ComputePassId,
+        pipeline_id: id::ComputePipelineId,
+        device_id: id::DeviceId,
+    },
+    ComputePassSetBindGroup {
+        compute_pass_id: ComputePassId,
+        index: u32,
+        bind_group_id: id::BindGroupId,
+        offsets: Vec<u32>,
+        device_id: id::DeviceId,
+    },
+    ComputePassDispatchWorkgroups {
+        compute_pass_id: ComputePassId,
+        x: u32,
+        y: u32,
+        z: u32,
+        device_id: id::DeviceId,
+    },
+    ComputePassDispatchWorkgroupsIndirect {
+        compute_pass_id: ComputePassId,
+        buffer_id: id::BufferId,
+        offset: u64,
+        device_id: id::DeviceId,
     },
-    RunRenderPass {
+    EndComputePass {
+        compute_pass_id: ComputePassId,
+        device_id: id::DeviceId,
         command_encoder_id: id::CommandEncoderId,
+    },
+    EndRenderPass {
         render_pass: Option<RenderPass>,
+        device_id: id::DeviceId,
     },
     Submit {
         queue_id: id::QueueId,
diff --git a/components/webgpu/identity.rs b/components/webgpu/identity.rs
index 86ea497f67d..bb1cb1ca4a0 100644
--- a/components/webgpu/identity.rs
+++ b/components/webgpu/identity.rs
@@ -5,6 +5,8 @@
 use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use serde::{Deserialize, Serialize};
 
+pub use crate::wgc::id::markers::ComputePassEncoder as ComputePass;
+pub use crate::wgc::id::ComputePassEncoderId as ComputePassId;
 use crate::wgc::id::{
     AdapterId, BindGroupId, BindGroupLayoutId, BufferId, CommandBufferId, CommandEncoderId,
     ComputePipelineId, DeviceId, PipelineLayoutId, QueueId, RenderBundleId, RenderPipelineId,
@@ -43,3 +45,4 @@ webgpu_resource!(WebGPUShaderModule, ShaderModuleId);
 webgpu_resource!(WebGPUSurface, SurfaceId);
 webgpu_resource!(WebGPUTexture, TextureId);
 webgpu_resource!(WebGPUTextureView, TextureViewId);
+webgpu_resource!(WebGPUComputePass, ComputePassId);
diff --git a/components/webgpu/script_messages.rs b/components/webgpu/script_messages.rs
index 15fe198386d..774bfd6cb7c 100644
--- a/components/webgpu/script_messages.rs
+++ b/components/webgpu/script_messages.rs
@@ -10,9 +10,9 @@ use serde::{Deserialize, Serialize};
 use crate::gpu_error::Error;
 use crate::identity::WebGPUDevice;
 use crate::wgc::id::{
-    AdapterId, BindGroupId, BindGroupLayoutId, BufferId, CommandBufferId, ComputePipelineId,
-    DeviceId, PipelineLayoutId, QuerySetId, RenderBundleId, RenderPipelineId, SamplerId,
-    ShaderModuleId, StagingBufferId, SurfaceId, TextureId, TextureViewId,
+    AdapterId, BindGroupId, BindGroupLayoutId, BufferId, CommandBufferId, ComputePassEncoderId,
+    ComputePipelineId, DeviceId, PipelineLayoutId, QuerySetId, RenderBundleId, RenderPipelineId,
+    SamplerId, ShaderModuleId, StagingBufferId, SurfaceId, TextureId, TextureViewId,
 };
 
 /// <https://gpuweb.github.io/gpuweb/#enumdef-gpudevicelostreason>
@@ -44,6 +44,7 @@ pub enum WebGPUMsg {
     FreeRenderBundle(RenderBundleId),
     FreeStagingBuffer(StagingBufferId),
     FreeQuerySet(QuerySetId),
+    FreeComputePass(ComputePassEncoderId),
     UncapturedError {
         device: WebGPUDevice,
         pipeline_id: PipelineId,
diff --git a/components/webgpu/wgpu_thread.rs b/components/webgpu/wgpu_thread.rs
index f98fd2869a3..9688bb0726a 100644
--- a/components/webgpu/wgpu_thread.rs
+++ b/components/webgpu/wgpu_thread.rs
@@ -4,7 +4,6 @@
 
 //! Data and main loop of WebGPU thread.
 
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::slice;
 use std::sync::{Arc, Mutex};
@@ -26,14 +25,15 @@ use wgc::instance::parse_backends_from_comma_list;
 use wgc::pipeline::ShaderModuleDescriptor;
 use wgc::resource::{BufferMapCallback, BufferMapOperation};
 use wgc::{gfx_select, id};
+use wgpu_core::command::{ComputePassDescriptor, DynComputePass};
 use wgt::InstanceDescriptor;
 pub use {wgpu_core as wgc, wgpu_types as wgt};
 
 use crate::gpu_error::ErrorScope;
 use crate::poll_thread::Poller;
 use crate::{
-    Error, PopError, PresentationData, Transmute, WebGPU, WebGPUAdapter, WebGPUDevice, WebGPUMsg,
-    WebGPUQueue, WebGPURequest, WebGPUResponse,
+    ComputePassId, Error, PopError, PresentationData, Transmute, WebGPU, WebGPUAdapter,
+    WebGPUDevice, WebGPUMsg, WebGPUQueue, WebGPURequest, WebGPUResponse,
 };
 
 pub const PRESENTATION_BUFFER_COUNT: usize = 10;
@@ -73,13 +73,20 @@ pub(crate) struct WGPU {
     devices: Arc<Mutex<HashMap<DeviceId, DeviceScope>>>,
     // Track invalid adapters https://gpuweb.github.io/gpuweb/#invalid
     _invalid_adapters: Vec<WebGPUAdapter>,
-    //TODO: Remove this (https://github.com/gfx-rs/wgpu/issues/867)
-    error_command_encoders: RefCell<HashMap<id::CommandEncoderId, String>>,
+    // TODO: Remove this (https://github.com/gfx-rs/wgpu/issues/867)
+    /// This stores first error on command encoder,
+    /// because wgpu does not invalidate command encoder object
+    /// (this is also reused for invalidation of command buffers)
+    error_command_encoders: HashMap<id::CommandEncoderId, String>,
     webrender_api: Arc<Mutex<RenderApi>>,
     webrender_document: DocumentId,
     external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
     wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>,
+    /// Provides access to poller thread
     poller: Poller,
+    /// Store compute passes (that have not ended yet) and their validity
+    compute_passes: HashMap<ComputePassId, (Box<dyn DynComputePass>, bool)>,
+    //render_passes: HashMap<RenderPassId, Box<dyn DynRenderPass>>,
 }
 
 impl WGPU {
@@ -118,11 +125,12 @@ impl WGPU {
             adapters: Vec::new(),
             devices: Arc::new(Mutex::new(HashMap::new())),
             _invalid_adapters: Vec::new(),
-            error_command_encoders: RefCell::new(HashMap::new()),
+            error_command_encoders: HashMap::new(),
             webrender_api: Arc::new(Mutex::new(webrender_api_sender.create_api())),
             webrender_document,
             external_images,
             wgpu_image_map,
+            compute_passes: HashMap::new(),
         }
     }
 
@@ -199,13 +207,11 @@ impl WGPU {
                     } => {
                         let global = &self.global;
                         let result = if is_error {
-                            Err(Error::Internal(String::from("Invalid GPUCommandEncoder")))
-                        } else if let Some(err) = self
-                            .error_command_encoders
-                            .borrow()
-                            .get(&command_encoder_id)
+                            Err(Error::Validation(String::from("Invalid GPUCommandEncoder")))
+                        } else if let Some(err) =
+                            self.error_command_encoders.get(&command_encoder_id)
                         {
-                            Err(Error::Internal(err.clone()))
+                            Err(Error::Validation(err.clone()))
                         } else if let Some(error) =
                             gfx_select!(command_encoder_id => global.command_encoder_finish(
                                 command_encoder_id,
@@ -218,7 +224,9 @@ impl WGPU {
                             Ok(())
                         };
 
+                        // invalidate command buffer too
                         self.encoder_record_error(command_encoder_id, &result);
+                        // dispatch validation error
                         self.maybe_dispatch_error(device_id, result.err());
                     },
                     WebGPURequest::CopyBufferToBuffer {
@@ -575,7 +583,6 @@ impl WGPU {
                     },
                     WebGPURequest::DropCommandBuffer(id) => {
                         self.error_command_encoders
-                            .borrow_mut()
                             .remove(&id.into_command_encoder_id());
                         let global = &self.global;
                         gfx_select!(id => global.command_buffer_drop(id));
@@ -745,35 +752,129 @@ impl WGPU {
                             )
                         }
                     },
-                    WebGPURequest::RunComputePass {
+                    WebGPURequest::BeginComputePass {
                         command_encoder_id,
-                        compute_pass,
+                        compute_pass_id,
+                        label,
+                        device_id: _device_id,
                     } => {
                         let global = &self.global;
-                        let result = if let Some(pass) = compute_pass {
-                            gfx_select!(command_encoder_id => global.command_encoder_run_compute_pass(
+                        let (pass, error) = gfx_select!(
+                            command_encoder_id => global.command_encoder_create_compute_pass_dyn(
                                 command_encoder_id,
-                                &pass
-                            )).map_err(|e| format!("{:?}", e))
+                                &ComputePassDescriptor { label, timestamp_writes: None }
+                        ));
+                        assert!(
+                            self.compute_passes
+                                .insert(compute_pass_id, (pass, error.is_none()))
+                                .is_none(),
+                            "ComputePass should not exist yet."
+                        );
+                        // TODO: Command encoder state errors
+                        // self.maybe_dispatch_wgpu_error(device_id, error);
+                    },
+                    WebGPURequest::ComputePassSetPipeline {
+                        compute_pass_id,
+                        pipeline_id,
+                        device_id,
+                    } => {
+                        if let Some((pass, valid)) = self.compute_passes.get_mut(&compute_pass_id) {
+                            *valid &= pass.set_pipeline(&self.global, pipeline_id).is_ok();
                         } else {
-                            Err(String::from("Invalid ComputePass"))
+                            self.maybe_dispatch_error(
+                                device_id,
+                                Some(Error::Validation("pass already ended".to_string())),
+                            );
                         };
-                        self.encoder_record_error(command_encoder_id, &result);
                     },
-                    WebGPURequest::RunRenderPass {
+                    WebGPURequest::ComputePassSetBindGroup {
+                        compute_pass_id,
+                        index,
+                        bind_group_id,
+                        offsets,
+                        device_id,
+                    } => {
+                        if let Some((pass, valid)) = self.compute_passes.get_mut(&compute_pass_id) {
+                            *valid &= pass
+                                .set_bind_group(&self.global, index, bind_group_id, &offsets)
+                                .is_ok();
+                        } else {
+                            self.maybe_dispatch_error(
+                                device_id,
+                                Some(Error::Validation("pass already ended".to_string())),
+                            );
+                        };
+                    },
+                    WebGPURequest::ComputePassDispatchWorkgroups {
+                        compute_pass_id,
+                        x,
+                        y,
+                        z,
+                        device_id,
+                    } => {
+                        if let Some((pass, valid)) = self.compute_passes.get_mut(&compute_pass_id) {
+                            *valid &= pass.dispatch_workgroups(&self.global, x, y, z).is_ok();
+                        } else {
+                            self.maybe_dispatch_error(
+                                device_id,
+                                Some(Error::Validation("pass already ended".to_string())),
+                            );
+                        };
+                    },
+                    WebGPURequest::ComputePassDispatchWorkgroupsIndirect {
+                        compute_pass_id,
+                        buffer_id,
+                        offset,
+                        device_id,
+                    } => {
+                        if let Some((pass, valid)) = self.compute_passes.get_mut(&compute_pass_id) {
+                            *valid &= pass
+                                .dispatch_workgroups_indirect(&self.global, buffer_id, offset)
+                                .is_ok();
+                        } else {
+                            self.maybe_dispatch_error(
+                                device_id,
+                                Some(Error::Validation("pass already ended".to_string())),
+                            );
+                        };
+                    },
+                    WebGPURequest::EndComputePass {
+                        compute_pass_id,
+                        device_id,
                         command_encoder_id,
-                        render_pass,
                     } => {
-                        let global = &self.global;
-                        let result = if let Some(pass) = render_pass {
-                            gfx_select!(command_encoder_id => global.command_encoder_run_render_pass(
-                                command_encoder_id,
-                                &pass
-                            )).map_err(|e| format!("{:?}", e))
+                        // TODO: Command encoder state error
+                        if let Some((mut pass, valid)) =
+                            self.compute_passes.remove(&compute_pass_id)
+                        {
+                            if pass.end(&self.global).is_ok() && !valid {
+                                self.encoder_record_error(
+                                    command_encoder_id,
+                                    &Err::<(), _>("Pass is invalid".to_string()),
+                                );
+                            }
                         } else {
-                            Err(String::from("Invalid RenderPass"))
+                            self.dispatch_error(
+                                device_id,
+                                Error::Validation("pass already ended".to_string()),
+                            );
                         };
-                        self.encoder_record_error(command_encoder_id, &result);
+                    },
+                    WebGPURequest::EndRenderPass {
+                        render_pass,
+                        device_id,
+                    } => {
+                        if let Some(render_pass) = render_pass {
+                            let command_encoder_id = render_pass.parent_id();
+                            let global = &self.global;
+                            let result = gfx_select!(command_encoder_id => global.render_pass_end(&render_pass));
+                            self.maybe_dispatch_wgpu_error(device_id, result.err())
+                        } else {
+                            self.dispatch_error(
+                                device_id,
+                                Error::Validation("Render pass already ended".to_string()),
+                            )
+                        }
                     },
                     WebGPURequest::Submit {
                         queue_id,
@@ -782,11 +883,10 @@ impl WGPU {
                         let global = &self.global;
                         let cmd_id = command_buffers.iter().find(|id| {
                             self.error_command_encoders
-                                .borrow()
                                 .contains_key(&id.into_command_encoder_id())
                         });
                         let result = if cmd_id.is_some() {
-                            Err(Error::Internal(String::from(
+                            Err(Error::Validation(String::from(
                                 "Invalid command buffer submitted",
                             )))
                         } else {
@@ -1026,7 +1126,8 @@ impl WGPU {
                     },
                     WebGPURequest::DropTexture(id) => {
                         let global = &self.global;
-                        gfx_select!(id => global.texture_drop(id, true));
+                        gfx_select!(id => global.texture_drop(id, false));
+                        self.poller.wake();
                         if let Err(e) = self.script_sender.send(WebGPUMsg::FreeTexture(id)) {
                             warn!("Unable to send FreeTexture({:?}) ({:?})", id, e);
                         };
@@ -1040,7 +1141,8 @@ impl WGPU {
                     },
                     WebGPURequest::DropBuffer(id) => {
                         let global = &self.global;
-                        gfx_select!(id => global.buffer_drop(id, true));
+                        gfx_select!(id => global.buffer_drop(id, false));
+                        self.poller.wake();
                         if let Err(e) = self.script_sender.send(WebGPUMsg::FreeBuffer(id)) {
                             warn!("Unable to send FreeBuffer({:?}) ({:?})", id, e);
                         };
@@ -1060,6 +1162,13 @@ impl WGPU {
                             warn!("Unable to send FreeComputePipeline({:?}) ({:?})", id, e);
                         };
                     },
+                    WebGPURequest::DropComputePass(id) => {
+                        // Compute pass might have already ended
+                        self.compute_passes.remove(&id);
+                        if let Err(e) = self.script_sender.send(WebGPUMsg::FreeComputePass(id)) {
+                            warn!("Unable to send FreeComputePass({:?}) ({:?})", id, e);
+                        };
+                    },
                     WebGPURequest::DropRenderPipeline(id) => {
                         let global = &self.global;
                         gfx_select!(id => global.render_pipeline_drop(id));
@@ -1084,7 +1193,8 @@ impl WGPU {
                     },
                     WebGPURequest::DropTextureView(id) => {
                         let global = &self.global;
-                        let _result = gfx_select!(id => global.texture_view_drop(id, true));
+                        let _result = gfx_select!(id => global.texture_view_drop(id, false));
+                        self.poller.wake();
                         if let Err(e) = self.script_sender.send(WebGPUMsg::FreeTextureView(id)) {
                             warn!("Unable to send FreeTextureView({:?}) ({:?})", id, e);
                         };
@@ -1214,13 +1324,12 @@ impl WGPU {
     }
 
     fn encoder_record_error<U, T: std::fmt::Debug>(
-        &self,
+        &mut self,
         encoder_id: id::CommandEncoderId,
         result: &Result<U, T>,
     ) {
         if let Err(ref e) = result {
             self.error_command_encoders
-                .borrow_mut()
                 .entry(encoder_id)
                 .or_insert_with(|| format!("{:?}", e));
         }
diff --git a/tests/wpt/webgpu/meta/webgpu/cts.https.html.ini b/tests/wpt/webgpu/meta/webgpu/cts.https.html.ini
index cade0d0a67d..8fafbcaaf67 100644
--- a/tests/wpt/webgpu/meta/webgpu/cts.https.html.ini
+++ b/tests/wpt/webgpu/meta/webgpu/cts.https.html.ini
@@ -2377,8 +2377,12 @@
   [:name="createRenderBundleEncoder"]
 
   [:name="createRenderPipeline"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:name="createRenderPipelineAsync"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:name="createSampler"]
 
@@ -2397,6 +2401,8 @@
 
 [cts.https.html?q=webgpu:api,operation,labels:wrappers_do_not_share_labels:*]
   [:]
+    expected:
+      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,operation,memory_sync,buffer,multiple_buffers:multiple_pairs_of_dispatches_in_one_compute_pass:*]
@@ -10989,8 +10995,12 @@
   [:limitTest="atDefault";testValueName="atLimit";createPipelineType="createComputePipeline";async=true]
 
   [:limitTest="atDefault";testValueName="atLimit";createPipelineType="createRenderPipeline";async=false]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";createPipelineType="createRenderPipeline";async=true]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";createPipelineType="createRenderPipelineWithFragmentStage";async=false]
 
@@ -11005,8 +11015,6 @@
       if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";createPipelineType="createRenderPipeline";async=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";createPipelineType="createRenderPipeline";async=true]
     expected:
@@ -11025,8 +11033,12 @@
   [:limitTest="atMaximum";testValueName="atLimit";createPipelineType="createComputePipeline";async=true]
 
   [:limitTest="atMaximum";testValueName="atLimit";createPipelineType="createRenderPipeline";async=false]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atMaximum";testValueName="atLimit";createPipelineType="createRenderPipeline";async=true]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atMaximum";testValueName="atLimit";createPipelineType="createRenderPipelineWithFragmentStage";async=false]
 
@@ -11041,8 +11053,6 @@
       if os == "linux" and not debug: FAIL
 
   [:limitTest="atMaximum";testValueName="overLimit";createPipelineType="createRenderPipeline";async=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atMaximum";testValueName="overLimit";createPipelineType="createRenderPipeline";async=true]
     expected:
@@ -11061,8 +11071,12 @@
   [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";createPipelineType="createComputePipeline";async=true]
 
   [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";createPipelineType="createRenderPipeline";async=false]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";createPipelineType="createRenderPipeline";async=true]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";createPipelineType="createRenderPipelineWithFragmentStage";async=false]
 
@@ -11077,8 +11091,6 @@
       if os == "linux" and not debug: FAIL
 
   [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";createPipelineType="createRenderPipeline";async=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";createPipelineType="createRenderPipeline";async=true]
     expected:
@@ -15747,16 +15759,28 @@
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
 
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
 
@@ -15807,16 +15831,28 @@
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
 
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
 
@@ -15891,28 +15927,16 @@
       if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
     expected:
@@ -27610,14 +27634,10 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,compute_pass:indirect_dispatch_buffer,device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,compute_pass:indirect_dispatch_buffer,usage:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,compute_pass:indirect_dispatch_buffer_state:*]
@@ -27628,20 +27648,14 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,compute_pass:pipeline,device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,compute_pass:set_pipeline:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:buffer,device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:buffer_state:*]
@@ -27650,70 +27664,48 @@
       if os == "linux" and not debug: FAIL
 
   [:srcBufferState="destroyed";dstBufferState="invalid"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:srcBufferState="destroyed";dstBufferState="valid"]
     expected:
       if os == "linux" and not debug: FAIL
 
   [:srcBufferState="invalid";dstBufferState="destroyed"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:srcBufferState="invalid";dstBufferState="invalid"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:srcBufferState="invalid";dstBufferState="valid"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:srcBufferState="valid";dstBufferState="destroyed"]
     expected:
       if os == "linux" and not debug: FAIL
 
   [:srcBufferState="valid";dstBufferState="invalid"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:srcBufferState="valid";dstBufferState="valid"]
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:buffer_usage:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_offset_alignment:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_out_of_bounds:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_overflow:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_size_alignment:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_within_same_buffer:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyTextureToTexture:copy_aspects:*]
@@ -27722,24 +27714,16 @@
       if os == "linux" and not debug: FAIL
 
   [:format="depth24plus"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth32float"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth32float-stencil8"]
     expected:
       if os == "linux" and not debug: FAIL
 
   [:format="rgba8unorm"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="stencil8"]
     expected:
@@ -27786,112 +27770,58 @@
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=3]
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=0;dstCopyLevel=0]
 
@@ -27966,40 +27896,22 @@
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=3;dstCopyLevel=3]
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d";copyBoxOffsets={"x":0,"y":1,"z":0,"width":0,"height":-1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=0]
 
@@ -28094,178 +28006,92 @@
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=0]
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":0,"depthOrArrayLayers":1};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":0,"width":1,"height":0,"depthOrArrayLayers":-2};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=0;dstCopyLevel=0]
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":0,"depthOrArrayLayers":-1};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":1,"width":0,"height":1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=0]
     expected:
@@ -28338,40 +28164,22 @@
       if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=0;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=1;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=0]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=1]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":0,"z":2,"width":0,"height":1,"depthOrArrayLayers":0};srcCopyLevel=3;dstCopyLevel=3]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d";copyBoxOffsets={"x":0,"y":1,"z":0,"width":0,"height":-1,"depthOrArrayLayers":-2};srcCopyLevel=0;dstCopyLevel=0]
 
@@ -28504,60 +28312,32 @@
   [:format="astc-8x8-unorm-srgb";dimension="2d"]
 
   [:format="bc1-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc1-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc2-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc2-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc3-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc3-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc4-r-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc4-r-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc5-rg-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc5-rg-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc6h-rgb-float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc6h-rgb-ufloat";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc7-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="bc7-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="eac-r11snorm";dimension="2d"]
 
@@ -28620,16 +28400,10 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyTextureToTexture:mipmap_level:*]
   [:dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyTextureToTexture:multisampled_copy_restrictions:*]
@@ -28646,8 +28420,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyTextureToTexture:texture,device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyTextureToTexture:texture_format_compatibility:*]
@@ -28704,8 +28476,6 @@
   [:srcFormatFeature="texture-compression-bc";dstFormatFeature="texture-compression-astc"]
 
   [:srcFormatFeature="texture-compression-bc";dstFormatFeature="texture-compression-bc"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:srcFormatFeature="texture-compression-bc";dstFormatFeature="texture-compression-etc2"]
 
@@ -28722,8 +28492,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,copyTextureToTexture:texture_usage:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,debug:debug_group:*]
@@ -28928,8 +28696,6 @@
   [:bufferSizeInElements=100;bindingSizeInElements=10;drawIndexCount=10;drawType="drawIndexedIndirect"]
 
   [:bufferSizeInElements=100;bindingSizeInElements=10;drawIndexCount=11;drawType="drawIndexed"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bufferSizeInElements=100;bindingSizeInElements=10;drawIndexCount=11;drawType="drawIndexedIndirect"]
 
@@ -28938,8 +28704,6 @@
   [:bufferSizeInElements=10;bindingSizeInElements=10;drawIndexCount=10;drawType="drawIndexedIndirect"]
 
   [:bufferSizeInElements=10;bindingSizeInElements=10;drawIndexCount=11;drawType="drawIndexed"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bufferSizeInElements=10;bindingSizeInElements=10;drawIndexCount=11;drawType="drawIndexedIndirect"]
 
@@ -29324,8 +29088,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,indirect_draw:indirect_buffer_usage:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,indirect_draw:indirect_offset_alignment:*]
@@ -29342,8 +29104,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setIndexBuffer:index_buffer,device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setIndexBuffer:index_buffer_state:*]
@@ -29354,8 +29114,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setIndexBuffer:index_buffer_usage:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setIndexBuffer:offset_alignment:*]
@@ -29372,14 +29130,10 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setPipeline:invalid_pipeline:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setPipeline:pipeline,device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setVertexBuffer:offset_alignment:*]
@@ -29396,14 +29150,10 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setVertexBuffer:slot:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setVertexBuffer:vertex_buffer,device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setVertexBuffer:vertex_buffer_state:*]
@@ -29414,8 +29164,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,setVertexBuffer:vertex_buffer_usage:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,render,state_tracking:all_needed_index_buffer_should_be_bound:*]
@@ -29440,140 +29188,76 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,setBindGroup:bind_group,device_mismatch:*]
   [:encoderType="compute%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,setBindGroup:buffer_dynamic_offsets:*]
   [:type="read-only-storage";encoderType="compute%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="read-only-storage";encoderType="render%20bundle"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="read-only-storage";encoderType="render%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="storage";encoderType="compute%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="storage";encoderType="render%20bundle"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="storage";encoderType="render%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="uniform";encoderType="compute%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="uniform";encoderType="render%20bundle"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="uniform";encoderType="render%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:*]
   [:encoderType="compute%20pass";dynamicOffsets=[0,1024\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[0,1024\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[0,4294967295\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[0,4294967295\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[0,512\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[0,512\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[1,2\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[1,2\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[1024,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[1024,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[256,0,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[256,0,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[256,0\];useU32array=false]
 
   [:encoderType="compute%20pass";dynamicOffsets=[256,0\];useU32array=true]
 
   [:encoderType="compute%20pass";dynamicOffsets=[256\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[256\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[4294967295,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[4294967295,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[512,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[512,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";dynamicOffsets=[\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[0,1024\];useU32array=false]
     expected:
@@ -29584,12 +29268,8 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[0,4294967295\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[0,4294967295\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[0,512\];useU32array=false]
     expected:
@@ -29600,12 +29280,8 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[1,2\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[1,2\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[1024,0\];useU32array=false]
     expected:
@@ -29616,32 +29292,20 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[256,0,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[256,0,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[256,0\];useU32array=false]
 
   [:encoderType="render%20bundle";dynamicOffsets=[256,0\];useU32array=true]
 
   [:encoderType="render%20bundle";dynamicOffsets=[256\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[256\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[4294967295,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[4294967295,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[512,0\];useU32array=false]
     expected:
@@ -29652,110 +29316,60 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";dynamicOffsets=[\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[0,1024\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[0,1024\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[0,4294967295\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[0,4294967295\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[0,512\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[0,512\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[1,2\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[1,2\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[1024,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[1024,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[256,0,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[256,0,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[256,0\];useU32array=false]
 
   [:encoderType="render%20pass";dynamicOffsets=[256,0\];useU32array=true]
 
   [:encoderType="render%20pass";dynamicOffsets=[256\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[256\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[4294967295,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[4294967295,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[512,0\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[512,0\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[\];useU32array=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";dynamicOffsets=[\];useU32array=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,setBindGroup:dynamic_offsets_passed_but_not_expected:*]
   [:encoderType="compute%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,setBindGroup:state_and_binding_index:*]
@@ -29764,72 +29378,42 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";state="destroyed";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";state="invalid";resourceType="buffer"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";state="invalid";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";state="valid";resourceType="buffer"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";state="valid";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";state="destroyed";resourceType="buffer"]
     expected:
-      if os == "linux" and not debug: [FAIL, NOTRUN]
+      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";state="destroyed";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";state="invalid";resourceType="buffer"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";state="invalid";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";state="valid";resourceType="buffer"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";state="valid";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";state="destroyed";resourceType="buffer"]
     expected:
-      if os == "linux" and not debug: [FAIL, NOTRUN]
+      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";state="destroyed";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";state="invalid";resourceType="buffer"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";state="invalid";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";state="valid";resourceType="buffer"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";state="valid";resourceType="texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,cmds,setBindGroup:u32array_start_and_length:*]
@@ -30188,12 +29772,8 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,encoder_open_state:compute_pass_commands:*]
   [:command="dispatchWorkgroups"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:command="dispatchWorkgroupsIndirect"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:command="insertDebugMarker"]
     expected:
@@ -30208,12 +29788,8 @@
       if os == "linux" and not debug: FAIL
 
   [:command="setBindGroup"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:command="setPipeline"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,encoder_open_state:non_pass_commands:*]
@@ -30402,8 +29978,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,encoder_state:pass_end_invalid_order:*]
   [:pass0Type="compute";pass1Type="compute"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:pass0Type="compute";pass1Type="render"]
     expected:
@@ -30426,8 +30000,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,encoder_state:pass_end_twice,basic:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,encoder_state:pass_end_twice,render_pass_invalid:*]
@@ -30438,20 +30010,12 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_binding_mismatch:*]
   [:encoderType="compute%20pass";call="dispatch";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatch";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";call="draw";callWithZero=false]
     expected:
@@ -30486,36 +30050,20 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="draw";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="draw";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexed";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexed";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_resource_type_mismatch:*]
@@ -30602,20 +30150,12 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_visibility_mismatch:*]
   [:encoderType="compute%20pass";call="dispatch";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatch";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";call="draw";callWithZero=false]
     expected:
@@ -30650,54 +30190,30 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="draw";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="draw";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexed";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexed";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bind_groups_and_pipeline_layout_mismatch:*]
   [:encoderType="compute%20pass";call="dispatch";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatch";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";call="draw";callWithZero=false]
     expected:
@@ -30732,58 +30248,34 @@
       if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="draw";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="draw";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexed";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexed";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndirect";callWithZero=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";call="drawIndirect";callWithZero=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:buffer_binding,render_pipeline:*]
   [:type="read-only-storage"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="storage"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:type="uniform"]
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:empty_bind_group_layouts_requires_empty_bind_groups,compute_pass:*]
   [:bindGroupLayoutEntryCount=3;computeCommand="dispatch"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bindGroupLayoutEntryCount=3;computeCommand="dispatchIndirect"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bindGroupLayoutEntryCount=4;computeCommand="dispatch"]
 
@@ -30820,30 +30312,18 @@
   [:bglType="comparison";bgType="comparison"]
 
   [:bglType="comparison";bgType="filtering"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bglType="comparison";bgType="non-filtering"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bglType="filtering";bgType="comparison"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bglType="filtering";bgType="filtering"]
 
   [:bglType="filtering";bgType="non-filtering"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bglType="non-filtering";bgType="comparison"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bglType="non-filtering";bgType="filtering"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bglType="non-filtering";bgType="non-filtering"]
 
@@ -30988,22 +30468,14 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,render_bundle:color_formats_mismatch:*]
   [:bundleFormats=["bgra8unorm","rg8unorm","rgba8unorm"\];passFormats=["rg8unorm","bgra8unorm"\]]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bundleFormats=["bgra8unorm","rg8unorm"\];passFormats=["bgra8unorm","bgra8unorm"\]]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bundleFormats=["bgra8unorm","rg8unorm"\];passFormats=["bgra8unorm","rg8unorm"\]]
 
   [:bundleFormats=["bgra8unorm","rg8unorm"\];passFormats=["rg8unorm","bgra8unorm","rgba8unorm"\]]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bundleFormats=["bgra8unorm","rg8unorm"\];passFormats=["rg8unorm","bgra8unorm"\]]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,render_bundle:depth_stencil_formats_mismatch:*]
@@ -31014,8 +30486,6 @@
   [:bundleFormat="depth24plus";passFormat="depth24plus"]
 
   [:bundleFormat="depth24plus";passFormat="depth24plus-stencil8"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:bundleFormat="stencil8";passFormat="depth24plus-stencil8"]
     expected:
@@ -31050,8 +30520,6 @@
 
 [cts.https.html?q=webgpu:api,validation,encoding,render_bundle:device_mismatch:*]
   [:]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,encoding,render_bundle:empty_bundle_list:*]
@@ -31976,8 +31444,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="depth32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="eac-r11snorm";dimension="2d"]
 
@@ -32800,18 +32266,12 @@
       if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8";aspect="stencil-only";copyType="CopyB2T"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8";aspect="stencil-only";copyType="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8";aspect="stencil-only";copyType="WriteTexture"]
 
   [:format="depth32float";aspect="depth-only";copyType="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth32float-stencil8";aspect="depth-only";copyType="CopyT2B"]
     expected:
@@ -32856,18 +32316,12 @@
       if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8";aspect="stencil-only";copyType="CopyB2T"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8";aspect="stencil-only";copyType="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8";aspect="stencil-only";copyType="WriteTexture"]
 
   [:format="depth32float";aspect="depth-only";copyType="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth32float-stencil8";aspect="depth-only";copyType="CopyT2B"]
     expected:
@@ -32904,16 +32358,10 @@
       if os == "linux" and not debug: FAIL
 
   [:format="depth24plus"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth24plus-stencil8"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth32float"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:format="depth32float-stencil8"]
     expected:
@@ -32926,12 +32374,8 @@
 
 [cts.https.html?q=webgpu:api,validation,image_copy,buffer_texture_copies:device_mismatch:*]
   [:copyType="CopyB2T"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:copyType="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,image_copy,buffer_texture_copies:sample_count:*]
@@ -32940,18 +32384,12 @@
       if os == "linux" and not debug: FAIL
 
   [:copyType="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,image_copy,buffer_texture_copies:texture_buffer_usages:*]
   [:copyType="CopyB2T"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:copyType="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,image_copy,layout_related:bound_on_bytes_per_row:*]
@@ -33012,84 +32450,44 @@
   [:method="CopyB2T";format="astc-8x8-unorm-srgb";dimension="2d"]
 
   [:method="CopyB2T";format="bc1-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc1-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc2-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc2-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc3-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc3-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc4-r-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc4-r-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc5-rg-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc5-rg-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc6h-rgb-float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc6h-rgb-ufloat";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc7-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc7-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="depth16unorm";dimension="2d"]
     expected:
@@ -33116,124 +32514,64 @@
   [:method="CopyB2T";format="etc2-rgba8unorm-srgb";dimension="2d"]
 
   [:method="CopyB2T";format="r16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg11b10ufloat";dimension="1d"]
     expected:
@@ -33248,124 +32586,64 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2uint";dimension="1d"]
     expected:
@@ -33380,16 +32658,10 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb9e5ufloat";dimension="1d"]
     expected:
@@ -33404,136 +32676,70 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="stencil8";dimension="2d"]
     expected:
@@ -33596,84 +32802,44 @@
   [:method="CopyT2B";format="astc-8x8-unorm-srgb";dimension="2d"]
 
   [:method="CopyT2B";format="bc1-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc1-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc2-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc2-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc3-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc3-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc4-r-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc4-r-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc5-rg-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc5-rg-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc6h-rgb-float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc6h-rgb-ufloat";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc7-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc7-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="depth16unorm";dimension="2d"]
     expected:
@@ -33704,124 +32870,64 @@
   [:method="CopyT2B";format="etc2-rgba8unorm-srgb";dimension="2d"]
 
   [:method="CopyT2B";format="r16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg11b10ufloat";dimension="1d"]
     expected:
@@ -33836,124 +32942,64 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2uint";dimension="1d"]
     expected:
@@ -33968,16 +33014,10 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb9e5ufloat";dimension="1d"]
     expected:
@@ -33992,136 +33032,70 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="stencil8";dimension="2d"]
     expected:
@@ -34546,12 +33520,8 @@
 
 [cts.https.html?q=webgpu:api,validation,image_copy,layout_related:copy_end_overflows_u64:*]
   [:method="CopyB2T"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="WriteTexture"]
 
@@ -34614,84 +33584,44 @@
   [:method="CopyB2T";format="astc-8x8-unorm-srgb";dimension="2d"]
 
   [:method="CopyB2T";format="bc1-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc1-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc2-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc2-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc3-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc3-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc4-r-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc4-r-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc5-rg-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc5-rg-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc6h-rgb-float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc6h-rgb-ufloat";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc7-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bc7-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="depth16unorm";dimension="2d"]
     expected:
@@ -34718,76 +33648,40 @@
   [:method="CopyB2T";format="etc2-rgba8unorm-srgb";dimension="2d"]
 
   [:method="CopyB2T";format="r16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8sint";dimension="1d"]
 
@@ -34826,124 +33720,64 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2uint";dimension="1d"]
     expected:
@@ -34958,16 +33792,10 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb9e5ufloat";dimension="1d"]
     expected:
@@ -34982,136 +33810,70 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="stencil8";dimension="2d"]
     expected:
@@ -35174,92 +33936,50 @@
   [:method="CopyT2B";format="astc-8x8-unorm-srgb";dimension="2d"]
 
   [:method="CopyT2B";format="bc1-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc1-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc2-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc2-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc3-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc3-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc4-r-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc4-r-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc5-rg-snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc5-rg-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc6h-rgb-float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc6h-rgb-ufloat";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc7-rgba-unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bc7-rgba-unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="depth16unorm";dimension="2d"]
     expected:
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="depth32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="eac-r11snorm";dimension="2d"]
 
@@ -35282,76 +34002,40 @@
   [:method="CopyT2B";format="etc2-rgba8unorm-srgb";dimension="2d"]
 
   [:method="CopyT2B";format="r16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8sint";dimension="1d"]
 
@@ -35390,124 +34074,64 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2uint";dimension="1d"]
     expected:
@@ -35522,16 +34146,10 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb9e5ufloat";dimension="1d"]
     expected:
@@ -35546,136 +34164,70 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="3d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="stencil8";dimension="2d"]
     expected:
@@ -36148,8 +34700,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm";dimension="2d"]
     expected:
@@ -36160,8 +34710,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="bgra8unorm-srgb";dimension="2d"]
     expected:
@@ -36196,8 +34744,6 @@
   [:method="CopyB2T";format="etc2-rgba8unorm-srgb";dimension="2d"]
 
   [:method="CopyB2T";format="r16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16float";dimension="2d"]
     expected:
@@ -36208,8 +34754,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16sint";dimension="2d"]
     expected:
@@ -36220,8 +34764,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r16uint";dimension="2d"]
     expected:
@@ -36232,8 +34774,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32float";dimension="2d"]
     expected:
@@ -36244,8 +34784,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32sint";dimension="2d"]
     expected:
@@ -36256,8 +34794,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r32uint";dimension="2d"]
     expected:
@@ -36268,8 +34804,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8sint";dimension="2d"]
     expected:
@@ -36280,8 +34814,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8snorm";dimension="2d"]
     expected:
@@ -36292,8 +34824,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8uint";dimension="2d"]
     expected:
@@ -36304,8 +34834,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="r8unorm";dimension="2d"]
     expected:
@@ -36328,8 +34856,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16float";dimension="2d"]
     expected:
@@ -36340,8 +34866,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16sint";dimension="2d"]
     expected:
@@ -36352,8 +34876,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg16uint";dimension="2d"]
     expected:
@@ -36364,8 +34886,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32float";dimension="2d"]
     expected:
@@ -36376,8 +34896,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32sint";dimension="2d"]
     expected:
@@ -36388,8 +34906,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg32uint";dimension="2d"]
     expected:
@@ -36400,8 +34916,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8sint";dimension="2d"]
     expected:
@@ -36412,8 +34926,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8snorm";dimension="2d"]
     expected:
@@ -36424,8 +34936,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8uint";dimension="2d"]
     expected:
@@ -36436,8 +34946,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rg8unorm";dimension="2d"]
     expected:
@@ -36460,8 +34968,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgb10a2unorm";dimension="2d"]
     expected:
@@ -36484,8 +34990,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16float";dimension="2d"]
     expected:
@@ -36496,8 +35000,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16sint";dimension="2d"]
     expected:
@@ -36508,8 +35010,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba16uint";dimension="2d"]
     expected:
@@ -36520,8 +35020,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32float";dimension="2d"]
     expected:
@@ -36532,8 +35030,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32sint";dimension="2d"]
     expected:
@@ -36544,8 +35040,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba32uint";dimension="2d"]
     expected:
@@ -36556,8 +35050,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8sint";dimension="2d"]
     expected:
@@ -36568,8 +35060,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8snorm";dimension="2d"]
     expected:
@@ -36580,8 +35070,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8uint";dimension="2d"]
     expected:
@@ -36592,8 +35080,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm";dimension="2d"]
     expected:
@@ -36604,8 +35090,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyB2T";format="rgba8unorm-srgb";dimension="2d"]
     expected:
@@ -36732,8 +35216,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm";dimension="2d"]
     expected:
@@ -36744,8 +35226,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="bgra8unorm-srgb";dimension="2d"]
     expected:
@@ -36760,8 +35240,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="depth32float";dimension="2d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="eac-r11snorm";dimension="2d"]
 
@@ -36784,8 +35262,6 @@
   [:method="CopyT2B";format="etc2-rgba8unorm-srgb";dimension="2d"]
 
   [:method="CopyT2B";format="r16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16float";dimension="2d"]
     expected:
@@ -36796,8 +35272,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16sint";dimension="2d"]
     expected:
@@ -36808,8 +35282,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r16uint";dimension="2d"]
     expected:
@@ -36820,8 +35292,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32float";dimension="2d"]
     expected:
@@ -36832,8 +35302,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32sint";dimension="2d"]
     expected:
@@ -36844,8 +35312,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r32uint";dimension="2d"]
     expected:
@@ -36856,8 +35322,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8sint";dimension="2d"]
     expected:
@@ -36868,8 +35332,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8snorm";dimension="2d"]
     expected:
@@ -36880,8 +35342,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8uint";dimension="2d"]
     expected:
@@ -36892,8 +35352,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="r8unorm";dimension="2d"]
     expected:
@@ -36916,8 +35374,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16float";dimension="2d"]
     expected:
@@ -36928,8 +35384,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16sint";dimension="2d"]
     expected:
@@ -36940,8 +35394,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg16uint";dimension="2d"]
     expected:
@@ -36952,8 +35404,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32float";dimension="2d"]
     expected:
@@ -36964,8 +35414,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32sint";dimension="2d"]
     expected:
@@ -36976,8 +35424,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg32uint";dimension="2d"]
     expected:
@@ -36988,8 +35434,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8sint";dimension="2d"]
     expected:
@@ -37000,8 +35444,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8snorm";dimension="2d"]
     expected:
@@ -37012,8 +35454,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8uint";dimension="2d"]
     expected:
@@ -37024,8 +35464,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rg8unorm";dimension="2d"]
     expected:
@@ -37048,8 +35486,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgb10a2unorm";dimension="2d"]
     expected:
@@ -37072,8 +35508,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16float";dimension="2d"]
     expected:
@@ -37084,8 +35518,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16sint";dimension="2d"]
     expected:
@@ -37096,8 +35528,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba16uint";dimension="2d"]
     expected:
@@ -37108,8 +35538,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32float";dimension="2d"]
     expected:
@@ -37120,8 +35548,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32sint";dimension="2d"]
     expected:
@@ -37132,8 +35558,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba32uint";dimension="2d"]
     expected:
@@ -37144,8 +35568,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8sint";dimension="2d"]
     expected:
@@ -37156,8 +35578,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8snorm";dimension="2d"]
     expected:
@@ -37168,8 +35588,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8uint";dimension="2d"]
     expected:
@@ -37180,8 +35598,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm";dimension="2d"]
     expected:
@@ -37192,8 +35608,6 @@
       if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="1d"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:method="CopyT2B";format="rgba8unorm-srgb";dimension="2d"]
     expected:
@@ -44314,18 +42728,24 @@
 
 [cts.https.html?q=webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:source_image,crossOrigin:*]
   [:sourceImage="canvas";isOriginClean=false]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:sourceImage="canvas";isOriginClean=true]
     expected:
       if os == "linux" and not debug: FAIL
 
   [:sourceImage="imageBitmap";isOriginClean=false]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:sourceImage="imageBitmap";isOriginClean=true]
     expected:
       if os == "linux" and not debug: FAIL
 
   [:sourceImage="offscreenCanvas";isOriginClean=false]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:sourceImage="offscreenCanvas";isOriginClean=true]
     expected:
@@ -44641,20 +43061,12 @@
 
 [cts.https.html?q=webgpu:api,validation,render_pass,attachment_compatibility:render_pass_or_bundle_and_pipeline,sample_count:*]
   [:encoderType="render%20bundle";attachmentType="color"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20bundle";attachmentType="depthstencil"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";attachmentType="color"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:encoderType="render%20pass";attachmentType="depthstencil"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:attachments,color_depth_mismatch:*]
@@ -49014,8 +47426,6 @@
 
 [cts.https.html?q=webgpu:api,validation,render_pipeline,fragment_state:color_target_exists:*]
   [:isAsync=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:isAsync=true]
     expected:
@@ -50518,8 +48928,12 @@
 
 [cts.https.html?q=webgpu:api,validation,render_pipeline,misc:vertex_state_only:*]
   [:isAsync=false]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:isAsync=true]
+    expected:
+      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,render_pipeline,multisample_state:alpha_to_coverage,count:*]
@@ -51192,12 +49606,16 @@
   [:isAsync=false;isVertexShaderValid=false]
 
   [:isAsync=false;isVertexShaderValid=true]
+    expected:
+      if os == "linux" and not debug: FAIL
 
   [:isAsync=true;isVertexShaderValid=false]
     expected:
       if os == "linux" and not debug: FAIL
 
   [:isAsync=true;isVertexShaderValid=true]
+    expected:
+      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,render_pipeline,vertex_state:many_attributes_overlapping:*]
@@ -53276,8 +51694,6 @@
   [:usage0AccessibleInDispatch=true;usage1AccessibleInDispatch=false;dispatchBeforeUsage1=true]
 
   [:usage0AccessibleInDispatch=true;usage1AccessibleInDispatch=true;dispatchBeforeUsage1=false]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,resource_usages,buffer,in_pass_encoder:subresources,buffer_usage_in_one_render_pass_with_no_draw:*]
@@ -53978,8 +52394,6 @@
       if os == "linux" and not debug: FAIL
 
   [:dispatch="direct";usage1="sampled-texture";usage2="writeonly-storage-texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dispatch="direct";usage1="writeonly-storage-texture";usage2="readwrite-storage-texture"]
     expected:
@@ -53998,8 +52412,6 @@
       if os == "linux" and not debug: FAIL
 
   [:dispatch="indirect";usage1="sampled-texture";usage2="writeonly-storage-texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:dispatch="indirect";usage1="writeonly-storage-texture";usage2="readwrite-storage-texture"]
     expected:
@@ -54240,8 +52652,6 @@
   [:compute=true;type0="sampled-texture";type1="sampled-texture"]
 
   [:compute=true;type0="sampled-texture";type1="writeonly-storage-texture"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;type0="writeonly-storage-texture";type1="readwrite-storage-texture"]
     expected:
@@ -55548,8 +53958,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=false;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=false;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=false;setBindGroupsOrder="reversed";setPipeline="after";callDrawOrDispatch=false]
 
@@ -55566,8 +53974,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=false;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=false;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=true;setBindGroupsOrder="common";setPipeline="after";callDrawOrDispatch=false]
 
@@ -55584,8 +53990,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=true;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=true;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=true;setBindGroupsOrder="reversed";setPipeline="after";callDrawOrDispatch=false]
 
@@ -55602,8 +54006,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=true;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=false;useBindGroup1=true;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=false;setBindGroupsOrder="common";setPipeline="after";callDrawOrDispatch=false]
 
@@ -55620,8 +54022,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=false;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=false;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=false;setBindGroupsOrder="reversed";setPipeline="after";callDrawOrDispatch=false]
 
@@ -55638,8 +54038,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=false;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=false;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=true;setBindGroupsOrder="common";setPipeline="after";callDrawOrDispatch=false]
 
@@ -55656,8 +54054,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=true;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=true;setBindGroupsOrder="common";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=true;setBindGroupsOrder="reversed";setPipeline="after";callDrawOrDispatch=false]
 
@@ -55674,8 +54070,6 @@
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=true;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=false]
 
   [:compute=true;readOnlyUsage="sampled-texture";writableUsage="writeonly-storage-texture";useBindGroup0=true;useBindGroup1=true;setBindGroupsOrder="reversed";setPipeline="none";callDrawOrDispatch=true]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:api,validation,resource_usages,texture,in_render_common:subresources,color_attachment_and_bind_group:*]
@@ -84696,16 +83090,10 @@
       if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_r"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_rw"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="uniform"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:shader,execution,expression,call,builtin,pack4xI8Clamp:basic:*]
@@ -84732,16 +83120,10 @@
       if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_r"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_rw"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="uniform"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:shader,execution,expression,call,builtin,pack4xU8Clamp:basic:*]
@@ -88174,16 +86556,10 @@
       if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_r"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_rw"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="uniform"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:shader,execution,expression,call,builtin,unpack4xU8:basic:*]
@@ -88192,16 +86568,10 @@
       if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_r"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="storage_rw"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
   [:inputSource="uniform"]
-    expected:
-      if os == "linux" and not debug: FAIL
 
 
 [cts.https.html?q=webgpu:shader,execution,expression,call,builtin,workgroupBarrier:barrier:*]
diff --git a/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_complex_rgba8unorm_store.https.html.ini b/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_complex_rgba8unorm_store.https.html.ini
index 59810e46f72..3848337c5b5 100644
--- a/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_complex_rgba8unorm_store.https.html.ini
+++ b/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_complex_rgba8unorm_store.https.html.ini
@@ -1,2 +1,3 @@
 [canvas_complex_rgba8unorm_store.https.html]
-  expected: FAIL
+  expected:
+    if os == "linux" and not debug: PASS
diff --git a/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_image_rendering.https.html.ini b/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_image_rendering.https.html.ini
index b64101496ff..1582f163f6d 100644
--- a/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_image_rendering.https.html.ini
+++ b/tests/wpt/webgpu/meta/webgpu/webgpu/web_platform/reftests/canvas_image_rendering.https.html.ini
@@ -1,2 +1,3 @@
 [canvas_image_rendering.https.html]
-  expected: TIMEOUT
+  expected:
+    if os == "linux" and not debug: PASS
author	Samson <16504129+sagudev@users.noreply.github.com>	2024-06-28 06:49:35 +0200
committer	GitHub <noreply@github.com>	2024-06-28 04:49:35 +0000
commit	e9cf4d4971c0ce8ec64da7f09d6e97ae10be5b05 (patch)
tree	fb9f0179cfe93744118835c3a34edc8c19672a3e
parent	fced0b49404c02bb5aafa9ddd468f9077ce26c19 (diff)
download	servo-e9cf4d4971c0ce8ec64da7f09d6e97ae10be5b05.tar.gz servo-e9cf4d4971c0ce8ec64da7f09d6e97ae10be5b05.zip