[cts.https.html?q=webgpu:api,validation,capability_checks,limits,maxInterStageShaderVariables:createRenderPipeline,at_over:*]
  tags: [webgpu, webgpu-long]
  implementation-status: backlog
  expected:
    if os == "win": [OK, CRASH]
    if os == "linux": [OK, CRASH]
    if os == "mac" and debug: [OK, TIMEOUT]
    if os == "mac" and not debug: [OK, CRASH]
  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win": FAIL

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win": FAIL

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]

  [:limitTest="atDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux" and debug: FAIL
      if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: FAIL
      if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atDefault";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="atMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "linux": [FAIL, TIMEOUT, NOTRUN]
      if os == "mac": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="betweenDefaultAndMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="overMaximum";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL
      if os == "linux": [PASS, TIMEOUT, NOTRUN]
      if os == "mac": [PASS, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=false;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
      if os == "win" and not debug: FAIL

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="atLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=false;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    expected:
      if os == "win" and debug: [PASS, 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;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=false;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=false;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=false;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=false;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=false]
    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": [FAIL, TIMEOUT, NOTRUN]

  [:limitTest="underDefault";testValueName="overLimit";async=true;pointList=true;frontFacing=true;sampleIndex=true;sampleMaskIn=true;sampleMaskOut=true]
    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": [FAIL, TIMEOUT, NOTRUN]
