LayoutTests/fast/webgpu/nocrash/fuzz-288383.html

<style>
  :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; }
</style>
<script src="../../../resources/js-test-pre.js"></script>
<script id="shared">
const log = console.log;

</script>

<script>
globalThis.testRunner?.dumpAsText();
globalThis.testRunner?.waitUntilDone();


async function window0() {
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  defaultQueue: {},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
    'float32-blendable',
  ],
});
// START
veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({
  entries : [
    {
      binding : 0,
      visibility : GPUShaderStage.COMPUTE,
      buffer : {type : 'storage', }
    },
    {
      binding : 3,
      visibility : GPUShaderStage.COMPUTE,
      buffer : {type : 'storage' }},
    {
      binding : 11,
      visibility : GPUShaderStage.COMPUTE,
      externalTexture : {}}]});
veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({
  entries : [
    {
      binding : 0,
      visibility : GPUShaderStage.COMPUTE,
      buffer : {type : 'storage', }
    },
    {
      binding : 3,
      visibility : GPUShaderStage.COMPUTE,
      buffer : {type : 'storage' }},
    {
      binding : 11,
      visibility : GPUShaderStage.COMPUTE,
      externalTexture : {}}]});
pipelineLayout2 = device0.createPipelineLayout({
  bindGroupLayouts :
      [ veryExplicitBindGroupLayout0, ]
});
veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({
  entries : []});
buffer10 = device0.createBuffer(
    {size : 84, usage : GPUBufferUsage.STORAGE});
videoFrame0 = new VideoFrame(new ArrayBuffer(16), {
  codedWidth : 2,
  codedHeight : 2,
  format : 'BGRX',
  timestamp : 0,
  });
shaderModule1 = device0.createShaderModule({
  code : ` ;
              @group(0) @binding(3) var<storage, read_write> buffer16: T4;
              struct T4 {
              f0: atomic<i32>}
              @compute @workgroup_size(41, ) fn compute1() {
              atomicOr(&buffer16.f0, (586128435));
            }
             `});
pipeline3 = await device0.createComputePipelineAsync({
  layout : pipelineLayout2,
  compute : {module : shaderModule1, }
});
externalTexture1 = device0.importExternalTexture(
    {source : videoFrame0, });
buffer33 = device0.createBuffer(
    {size : 176, usage : GPUBufferUsage.STORAGE});
{
}
bindGroup9 = device0.createBindGroup({
  layout : veryExplicitBindGroupLayout2,
  entries : [
    {binding : 3, resource : {buffer : buffer33, }},
    {binding : 11, resource : externalTexture1},
    {binding : 0, resource : {buffer : buffer10}}]});
{
}
commandEncoder35 = device0.createCommandEncoder();
device0.createBindGroup({
  layout : veryExplicitBindGroupLayout3,
  entries : [
    {binding : 3, resource : {buffer : buffer33}},
    {binding : 11, resource : externalTexture1},
    {binding : 0, resource : {buffer : buffer10}}]});
computePassEncoder18 = commandEncoder35.beginComputePass();
try {
  computePassEncoder18.setPipeline(pipeline3);
  computePassEncoder18.setBindGroup(0, bindGroup9)} catch {
}
try {
  computePassEncoder18.dispatchWorkgroups(21)} catch {
}
try {
  computePassEncoder18.end()} catch {
}
commandBuffer0 = commandEncoder35.finish();
try {
  device0.queue.submit([ commandBuffer0 ])} catch {
}
// END
await device0.queue.onSubmittedWorkDone();
}

onload = async () => {
  try {
  let sharedScript = document.querySelector('#shared').textContent;

  let workers = [

  ];
  let promises = [ window0() ];
  debug('promises created');
  let results = await Promise.allSettled(promises);
  for (let result of results) {
    if (result.status === 'rejected') { throw result.reason; }
  }
  debug('Pass')
  } catch (e) {
    log('error');
    log(e);
    log(e[Symbol.toStringTag]);
    log(e.stack);
    if (e instanceof GPUPipelineError) {
      log(`${e} - ${e.reason}`);
      
    } else if (e instanceof DOMException) {
      if (e.name === 'OperationError') {
      log(e.message);
      
      } else if (e.name === 'InvalidStateError') {
      } else {
        log(e);
        
      }
    } else if (e instanceof GPUValidationError) {
      
    } else if (e instanceof GPUOutOfMemoryError) {
      
    } else if (e instanceof TypeError) {
      log(e);
      
    } else {
      log('unexpected error type');
      log(e);
      
    }
  }
    globalThis.testRunner?.notifyDone();
};
</script>