[color-resolving-hwb.html]
  [HWB value with commas should not be parsed: hwb(0deg, 0%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(0, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 50%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 75%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(30, 100%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 75%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(60, 100%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 50%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(90, 100%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 50%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120deg, 100%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(120, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 50%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(180, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 75%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(210, 100%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 75%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(240, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(270, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 50%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 75%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 87.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(300, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 25%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 50%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 50%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 62.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 75%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(330, 100%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 0%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 0%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 12.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 12.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 25%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 37.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 37.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 50%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 25%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 62.5%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 37.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 50%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 100%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 75%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 0%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 0%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 0%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 12.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 12.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 12.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 25%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 25%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 25%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 37.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 37.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 50%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 62.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 62.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 75%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 75%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 87.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 100%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 87.5%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 0%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 0%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 0%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 0%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 0%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 12.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 12.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 12.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 12.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 12.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 25%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 25%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 25%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 25%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 37.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 37.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 37.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 37.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 37.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 50%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 50%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 50%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 50%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 50%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 50%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 62.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 62.5%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 62.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 62.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 62.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 75%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 75%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 75%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 75%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 75%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 75%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 87.5%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 87.5%)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 87.5%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 87.5%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 87.5%, 0.2)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 87.5%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 87.5%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 100%)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 100%, 0)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 100%, 0)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 100%, 0.2)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360deg, 100%, 100%, 1)]
    expected:
      if (os == "android") and not debug: [PASS, FAIL]
      if (os == "mac") and not debug: [PASS, FAIL]

  [HWB value with commas should not be parsed: hwb(360, 100%, 100%, 1)]
    expected:
      if (os == "mac") and not debug: [PASS, FAIL]
      if (os == "android") and not debug: [PASS, FAIL]
