Test that mismatching swizzles cause validation error in compat mode

Author: greggman

src/webgpu/api/validation/capability_checks/features/texture_component_swizzle.spec.ts

@@ -14,6 +14,7 @@ import { UniqueFeaturesOrLimitsGPUTest } from '../../../../gpu_test.js';
 import {
   isIdentitySwizzle,
   kSwizzleTests,
+  swizzlesAreTheSame,
   swizzleSpecToGPUTextureComponentSwizzle,
 } from './texture_component_swizzle_utils.js';
 
@@ -80,3 +81,120 @@ g.test('no_render_nor_storage')
       texture.createView({ swizzle });
     }, shouldError);
   });
+
+g.test('compatibility_mode')
+  .desc(
+    `
+  Test that in compatibility mode, swizzles must be equivalent.
+  `
+  )
+  .beforeAllSubcases(t => {
+    // MAINTENANCE_TODO: Remove this cast once texture-component-swizzle is added to @webgpu/types
+    t.selectDeviceOrSkipTestCase('texture-component-swizzle' as GPUFeatureName);
+  })
+  .params(u =>
+    u
+      .beginSubcases()
+      .combine('swizzleSpec', kSwizzleTests)
+      .combine('otherSwizzleSpec', kSwizzleTests)
+      .combine('pipelineType', ['render', 'compute'] as const)
+  )
+  .fn(t => {
+    const { swizzleSpec, otherSwizzleSpec, pipelineType } = t.params;
+    const swizzle = swizzleSpecToGPUTextureComponentSwizzle(swizzleSpec);
+    const otherSwizzle = swizzleSpecToGPUTextureComponentSwizzle(otherSwizzleSpec);
+
+    const module = t.device.createShaderModule({
+      code: `
+        @group(0) @binding(0) var tex0: texture_2d<f32>;
+        @group(1) @binding(0) var tex1: texture_2d<f32>;
+
+        @compute @workgroup_size(1) fn cs() {
+          _ = tex0;
+          _ = tex1;
+        }
+
+        @vertex fn vs() -> @builtin(position) vec4f {
+          return vec4f(0);
+        }
+
+        @fragment fn fs() -> @location(0) vec4f {
+          _ = tex0;
+          _ = tex1;
+          return vec4f(0);
+        }
+      `,
+    });
+
+    const pipeline =
+      pipelineType === 'compute'
+        ? t.device.createComputePipeline({
+            layout: 'auto',
+            compute: { module },
+          })
+        : t.device.createRenderPipeline({
+            layout: 'auto',
+            vertex: { module },
+            fragment: { module, targets: [{ format: 'rgba8unorm' }] },
+          });
+
+    const texture = t.createTextureTracked({
+      size: [1],
+      format: 'rgba8unorm',
+      usage: GPUTextureUsage.TEXTURE_BINDING,
+    });
+
+    const bindGroup0 = t.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        {
+          binding: 0,
+          resource: texture.createView({ swizzle }),
+        },
+      ],
+    });
+
+    const bindGroup1 = t.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        {
+          binding: 0,
+          resource: texture.createView({ swizzle: otherSwizzle }),
+        },
+      ],
+    });
+
+    const encoder = t.device.createCommandEncoder();
+    switch (pipelineType) {
+      case 'compute': {
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(pipeline as GPUComputePipeline);
+        pass.setBindGroup(0, bindGroup0);
+        pass.setBindGroup(1, bindGroup1);
+        pass.dispatchWorkgroups(1);
+        pass.end();
+        break;
+      }
+      case 'render': {
+        const view = t.createTextureTracked({
+          size: [1],
+          format: 'rgba8unorm',
+          usage: GPUTextureUsage.RENDER_ATTACHMENT,
+        });
+        const pass = encoder.beginRenderPass({
+          colorAttachments: [{ view, loadOp: 'clear', storeOp: 'store' }],
+        });
+        pass.setPipeline(pipeline as GPURenderPipeline);
+        pass.setBindGroup(0, bindGroup0);
+        pass.setBindGroup(1, bindGroup1);
+        pass.draw(3);
+        pass.end();
+      }
+    }
+
+    const shouldError = t.isCompatibility && !swizzlesAreTheSame(swizzle, otherSwizzle);
+
+    t.expectValidationError(() => {
+      encoder.finish();
+    }, shouldError);
+  });