[cts.https.html?q=webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupStorageSize:createComputePipeline,at_over:*]
  tags: [webgpu, webgpu-long]
  implementation-status: backlog
  expected:
    if os == "win" and not debug: TIMEOUT
  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="S1"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="S2"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="S3"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="f16"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="f32"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="i32"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="u32"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec2%3Ci32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec2%3Cu32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec3%3Ci32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec3%3Cu32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec4%3Ci32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;wgslType="vec4%3Cu32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="S1"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="S2"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="S3"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="f16"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="f32"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="i32"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="u32"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec2%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec2%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec2%3Ci32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec2%3Cu32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec3%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec3%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec3%3Ci32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec3%3Cu32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec4%3Cf16%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec4%3Cf32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec4%3Ci32%3E"]

  [:limitTest="atDefault";testValueName="atLimit";async=true;wgslType="vec4%3Cu32%3E"]

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="S1"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="S2"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="S3"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="f16"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="f32"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="i32"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="u32"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="S1"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="S2"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="S3"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="f16"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="f32"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="i32"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="u32"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected: FAIL

  [:limitTest="atDefault";testValueName="overLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected: FAIL

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="f32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="i32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="u32"]
    expected:
      if os == "win" and debug: [PASS, FAIL]
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and debug: [PASS, FAIL]
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and debug: [PASS, FAIL]
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and debug: [PASS, FAIL]
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="f32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="i32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="u32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="atMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="f32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="i32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="u32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
      if os == "linux": FAIL
      if os == "mac": FAIL

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="f16"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="f32"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="i32"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="u32"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec2%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec2%3Cf32%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec2%3Ci32%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec3%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec4%3Cf16%3E"]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="S1"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="S2"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="S3"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="f16"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="f32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="i32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat2x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat2x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat2x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat3x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat3x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat3x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat4x2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat4x3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="mat4x4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="u32"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec2%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec2%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec2%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec2%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec3%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec3%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec3%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec3%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec4%3Cf16%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec4%3Cf32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec4%3Ci32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;wgslType="vec4%3Cu32%3E"]
    expected:
      if os == "win" and not debug: [TIMEOUT, NOTRUN]
