[cts.https.html?q=webgpu:api,validation,capability_checks,limits,maxSampledTexturesPerShaderStage:createBindGroupLayout,at_over:*]
  tags: [webgpu, webgpu-long]
  implementation-status: backlog
  expected: [OK, CRASH]
  [:limitTest="atDefault";testValueName="atLimit";visibility=1;order="backward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=1;order="forward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=2;order="backward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=2;order="forward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=3;order="backward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=3;order="forward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=4;order="backward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=4;order="forward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=5;order="backward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=5;order="forward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=6;order="backward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=6;order="forward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=7;order="backward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=7;order="forward"]

  [:limitTest="atDefault";testValueName="atLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=1;order="backward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=1;order="forward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=2;order="backward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=2;order="forward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=3;order="backward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=3;order="forward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=4;order="backward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=4;order="forward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=5;order="backward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=5;order="forward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=6;order="backward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=6;order="forward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=7;order="backward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=7;order="forward"]

  [:limitTest="atDefault";testValueName="overLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=1;order="backward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=1;order="forward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=2;order="backward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=2;order="forward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=3;order="backward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=3;order="forward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=4;order="backward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=4;order="forward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=5;order="backward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=5;order="forward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=6;order="backward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=6;order="forward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=7;order="backward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=7;order="forward"]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=1;order="backward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=1;order="forward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=2;order="backward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=2;order="forward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=3;order="backward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=3;order="forward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=4;order="backward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=4;order="forward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=5;order="backward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=5;order="forward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=6;order="backward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=6;order="forward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=7;order="backward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=7;order="forward"]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=1;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=1;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=2;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=2;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=3;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=3;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=4;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=4;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=5;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=5;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=6;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=6;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=7;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=7;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=1;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=1;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=2;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=2;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=3;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=3;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=4;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=4;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=5;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=5;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=6;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=6;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=7;order="backward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=7;order="forward"]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=1;order="backward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=1;order="forward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=2;order="backward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=2;order="forward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=3;order="backward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=3;order="forward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=4;order="backward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=4;order="forward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=5;order="backward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=5;order="forward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=6;order="backward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=6;order="forward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=7;order="backward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=7;order="forward"]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=1;order="backward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=1;order="forward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=2;order="backward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=2;order="forward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=3;order="backward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=3;order="forward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=4;order="backward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=4;order="forward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=5;order="backward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=5;order="forward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=6;order="backward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=6;order="forward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=7;order="backward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=7;order="forward"]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=1;order="backward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=1;order="forward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=2;order="backward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=2;order="forward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=3;order="backward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=3;order="forward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=4;order="backward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=4;order="forward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=5;order="backward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=5;order="forward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=6;order="backward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=6;order="forward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=7;order="backward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=7;order="forward"]

  [:limitTest="underDefault";testValueName="atLimit";visibility=7;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=1;order="backward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=1;order="forward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=1;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=2;order="backward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=2;order="forward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=2;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=3;order="backward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=3;order="forward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=3;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=4;order="backward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=4;order="forward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=4;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=5;order="backward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=5;order="forward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=5;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=6;order="backward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=6;order="forward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=6;order="shiftByHalf"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=7;order="backward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=7;order="forward"]

  [:limitTest="underDefault";testValueName="overLimit";visibility=7;order="shiftByHalf"]


[cts.https.html?q=webgpu:api,validation,capability_checks,limits,maxSampledTexturesPerShaderStage:createPipeline,at_over:*]
  tags: [webgpu, webgpu-long]
  implementation-status: backlog
  expected:
    if os == "win": [OK, CRASH]
    if os == "linux" and not debug: [OK, CRASH]
    if os == "mac": [OK, CRASH]
  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, FAIL]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="compute";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="fragment";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertex";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleFragmentStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="backward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="forward";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="differentGroups"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;bindingCombination="vertexAndFragmentWithPossibleVertexStageOverflow";order="shiftByHalf";bindGroupTest="sameGroup"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]


[cts.https.html?q=webgpu:api,validation,capability_checks,limits,maxSampledTexturesPerShaderStage:createPipelineLayout,at_over:*]
  tags: [webgpu, webgpu-long]
  implementation-status: backlog
  expected:
    if os == "win" and debug: [OK, TIMEOUT]
    if os == "win" and not debug: [OK, CRASH]
    if os == "linux" and not debug: [OK, CRASH]
    if os == "mac": [OK, CRASH]
  [:limitTest="atDefault";testValueName="atLimit";visibility=1;order="backward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=1;order="forward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=1;order="shiftByHalf"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=2;order="backward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=2;order="forward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=2;order="shiftByHalf"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=3;order="backward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=3;order="forward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=3;order="shiftByHalf"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=4;order="backward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=4;order="forward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=4;order="shiftByHalf"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=5;order="backward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=5;order="forward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=5;order="shiftByHalf"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=6;order="backward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=6;order="forward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=6;order="shiftByHalf"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=7;order="backward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=7;order="forward"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="atLimit";visibility=7;order="shiftByHalf"]
    expected:
      if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=1;order="backward"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=1;order="forward"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=1;order="shiftByHalf"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=2;order="backward"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=2;order="forward"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=2;order="shiftByHalf"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=3;order="backward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=3;order="forward"]
    expected:
      if os == "win" and debug: FAIL
      if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=3;order="shiftByHalf"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=4;order="backward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=4;order="forward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": FAIL

  [:limitTest="atDefault";testValueName="overLimit";visibility=4;order="shiftByHalf"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=5;order="backward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=5;order="forward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=5;order="shiftByHalf"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=6;order="backward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=6;order="forward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=6;order="shiftByHalf"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=7;order="backward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=7;order="forward"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";visibility=7;order="shiftByHalf"]
    expected:
      if os == "win": [FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=1;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=1;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=1;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=2;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=2;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=2;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=3;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=3;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=3;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=4;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=4;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=4;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=5;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=5;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=5;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=6;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=6;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=6;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=7;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=7;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";visibility=7;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=1;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=1;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=1;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=2;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=2;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=2;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=3;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=3;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=3;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=4;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=4;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=4;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=5;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=5;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=5;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=6;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=6;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=6;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=7;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=7;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";visibility=7;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=1;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=1;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=1;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=2;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=2;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=2;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=3;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=3;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=3;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=4;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=4;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=4;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=5;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=5;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=5;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=6;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=6;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=6;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=7;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=7;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";visibility=7;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=1;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=1;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=1;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=2;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=2;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=2;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=3;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=3;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=3;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=4;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=4;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=4;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=5;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=5;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=5;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=6;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=6;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=6;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=7;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=7;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";visibility=7;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=1;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=1;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=1;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=2;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=2;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=2;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=3;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=3;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=3;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=4;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=4;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=4;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=5;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=5;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=5;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=6;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=6;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=6;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=7;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=7;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";visibility=7;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=1;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=1;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=1;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=2;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=2;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=2;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=3;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=3;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=3;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=4;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=4;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=4;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=5;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=5;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=5;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=6;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=6;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=6;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=7;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=7;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";visibility=7;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=1;order="backward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=1;order="forward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=1;order="shiftByHalf"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=2;order="backward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=2;order="forward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=2;order="shiftByHalf"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=3;order="backward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=3;order="forward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=3;order="shiftByHalf"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=4;order="backward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=4;order="forward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=4;order="shiftByHalf"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=5;order="backward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=5;order="forward"]
    expected:
      if os == "win": [PASS, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=5;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=6;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=6;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=6;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=7;order="backward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=7;order="forward"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";visibility=7;order="shiftByHalf"]
    expected: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=1;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=1;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=1;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=2;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=2;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=2;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=3;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=3;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=3;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=4;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=4;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=4;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=5;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=5;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=5;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=6;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=6;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=6;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=7;order="backward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=7;order="forward"]
    expected: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";visibility=7;order="shiftByHalf"]
    expected: [FAIL, TIMEOUT, NOTRUN]
