[shape-outside-circle-004.html]
  disabled:
    if os == "android": https://bugzilla.mozilla.org/show_bug.cgi?id=1559989
  [test unit (computed): cm - circle(at 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at 50% 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at 50cm 50%)]
    expected: FAIL

  [test unit (computed): cm - circle(at 50cm 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at left 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at 50cm top)]
    expected: FAIL

  [test unit (computed): cm - circle(at right 80cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at 70cm bottom)]
    expected: FAIL

  [test unit (computed): cm - circle(at center 60cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at 60cm center)]
    expected: FAIL

  [test unit (computed): cm - circle(at left 50% top 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at left 50% bottom 70cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at left 50cm top 50%)]
    expected: FAIL

  [test unit (computed): cm - circle(at left 50cm top 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at left 50cm bottom 70%)]
    expected: FAIL

  [test unit (computed): cm - circle(at left 50cm bottom 70cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at top 50% left 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at top 50% right 80cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at top 50cm left 50%)]
    expected: FAIL

  [test unit (computed): cm - circle(at top 50cm left 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at top 50cm right 80%)]
    expected: FAIL

  [test unit (computed): cm - circle(at top 50cm right 80cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at bottom 70% left 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at bottom 70% right 80cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at bottom 70cm left 50%)]
    expected: FAIL

  [test unit (computed): cm - circle(at bottom 70cm left 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at bottom 70cm right 80%)]
    expected: FAIL

  [test unit (computed): cm - circle(at bottom 70cm right 80cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at right 80% top 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at right 80% bottom 70cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at right 80cm top 50%)]
    expected: FAIL

  [test unit (computed): cm - circle(at right 80cm top 50cm)]
    expected: FAIL

  [test unit (computed): cm - circle(at right 80cm bottom 70%)]
    expected: FAIL

  [test unit (computed): cm - circle(at right 80cm bottom 70cm)]
    expected: FAIL

  [test unit (computed): mm - circle(at left 50% bottom 70mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at left 50mm bottom 70mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at top 50% right 80mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at top 50mm right 80mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at bottom 70% right 80mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at bottom 70mm left 50%)]
    expected: FAIL

  [test unit (computed): mm - circle(at bottom 70mm left 50mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at bottom 70mm right 80%)]
    expected: FAIL

  [test unit (computed): mm - circle(at bottom 70mm right 80mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at right 80% bottom 70mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at right 80mm top 50%)]
    expected: FAIL

  [test unit (computed): mm - circle(at right 80mm top 50mm)]
    expected: FAIL

  [test unit (computed): mm - circle(at right 80mm bottom 70%)]
    expected: FAIL

  [test unit (computed): mm - circle(at right 80mm bottom 70mm)]
    expected: FAIL

  [test unit (computed): in - circle(at left 50% bottom 70in)]
    expected: FAIL

  [test unit (computed): in - circle(at left 50in bottom 70in)]
    expected: FAIL

  [test unit (computed): in - circle(at top 50% right 80in)]
    expected: FAIL

  [test unit (computed): in - circle(at top 50in right 80in)]
    expected: FAIL

  [test unit (computed): in - circle(at bottom 70% right 80in)]
    expected: FAIL

  [test unit (computed): in - circle(at bottom 70in left 50%)]
    expected: FAIL

  [test unit (computed): in - circle(at bottom 70in left 50in)]
    expected: FAIL

  [test unit (computed): in - circle(at bottom 70in right 80%)]
    expected: FAIL

  [test unit (computed): in - circle(at bottom 70in right 80in)]
    expected: FAIL

  [test unit (computed): in - circle(at right 80% bottom 70in)]
    expected: FAIL

  [test unit (computed): in - circle(at right 80in top 50%)]
    expected: FAIL

  [test unit (computed): in - circle(at right 80in top 50in)]
    expected: FAIL

  [test unit (computed): in - circle(at right 80in bottom 70%)]
    expected: FAIL

  [test unit (computed): in - circle(at right 80in bottom 70in)]
    expected: FAIL

  [test unit (computed): pt - circle(at left 50% bottom 70pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at left 50pt bottom 70pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at top 50% right 80pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at top 50pt right 80pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at bottom 70% right 80pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at bottom 70pt left 50%)]
    expected: FAIL

  [test unit (computed): pt - circle(at bottom 70pt left 50pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at bottom 70pt right 80%)]
    expected: FAIL

  [test unit (computed): pt - circle(at bottom 70pt right 80pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at right 80% bottom 70pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at right 80pt top 50%)]
    expected: FAIL

  [test unit (computed): pt - circle(at right 80pt top 50pt)]
    expected: FAIL

  [test unit (computed): pt - circle(at right 80pt bottom 70%)]
    expected: FAIL

  [test unit (computed): pt - circle(at right 80pt bottom 70pt)]
    expected: FAIL

  [test unit (computed): pc - circle(at left 50% bottom 70pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at left 50pc bottom 70pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at top 50% right 80pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at top 50pc right 80pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at bottom 70% right 80pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at bottom 70pc left 50%)]
    expected: FAIL

  [test unit (computed): pc - circle(at bottom 70pc left 50pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at bottom 70pc right 80%)]
    expected: FAIL

  [test unit (computed): pc - circle(at bottom 70pc right 80pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at right 80% bottom 70pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at right 80pc top 50%)]
    expected: FAIL

  [test unit (computed): pc - circle(at right 80pc top 50pc)]
    expected: FAIL

  [test unit (computed): pc - circle(at right 80pc bottom 70%)]
    expected: FAIL

  [test unit (computed): pc - circle(at right 80pc bottom 70pc)]
    expected: FAIL

  [test unit (computed): em - circle(at left 50% bottom 70em)]
    expected: FAIL

  [test unit (computed): em - circle(at left 50em bottom 70em)]
    expected: FAIL

  [test unit (computed): em - circle(at top 50% right 80em)]
    expected: FAIL

  [test unit (computed): em - circle(at top 50em right 80em)]
    expected: FAIL

  [test unit (computed): em - circle(at bottom 70% right 80em)]
    expected: FAIL

  [test unit (computed): em - circle(at bottom 70em left 50%)]
    expected: FAIL

  [test unit (computed): em - circle(at bottom 70em left 50em)]
    expected: FAIL

  [test unit (computed): em - circle(at bottom 70em right 80%)]
    expected: FAIL

  [test unit (computed): em - circle(at bottom 70em right 80em)]
    expected: FAIL

  [test unit (computed): em - circle(at right 80% bottom 70em)]
    expected: FAIL

  [test unit (computed): em - circle(at right 80em top 50%)]
    expected: FAIL

  [test unit (computed): em - circle(at right 80em top 50em)]
    expected: FAIL

  [test unit (computed): em - circle(at right 80em bottom 70%)]
    expected: FAIL

  [test unit (computed): em - circle(at right 80em bottom 70em)]
    expected: FAIL

  [test unit (computed): ex - circle(at 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at 50% 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at 50ex 50%)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at 50ex 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at left 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at 50ex top)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at right 80ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at 70ex bottom)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at center 60ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at 60ex center)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at left 50% top 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at left 50% bottom 70ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at left 50ex top 50%)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at left 50ex top 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at left 50ex bottom 70%)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at left 50ex bottom 70ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at top 50% left 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at top 50% right 80ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at top 50ex left 50%)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at top 50ex left 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at top 50ex right 80%)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at top 50ex right 80ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at bottom 70% left 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at bottom 70% right 80ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at bottom 70ex left 50%)]
    expected: FAIL

  [test unit (computed): ex - circle(at bottom 70ex left 50ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at bottom 70ex right 80%)]
    expected: FAIL

  [test unit (computed): ex - circle(at bottom 70ex right 80ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at right 80% top 50ex)]
    expected:
      if os == "linux": FAIL

  [test unit (computed): ex - circle(at right 80% bottom 70ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at right 80ex top 50%)]
    expected: FAIL

  [test unit (computed): ex - circle(at right 80ex top 50ex)]
    expected: FAIL

  [test unit (computed): ex - circle(at right 80ex bottom 70%)]
    expected: FAIL

  [test unit (computed): ex - circle(at right 80ex bottom 70ex)]
    expected: FAIL

  [test unit (computed): ch - circle(at left 50% bottom 70ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at left 50ch bottom 70ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at top 50% right 80ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at top 50ch right 80ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at bottom 70% right 80ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at bottom 70ch left 50%)]
    expected: FAIL

  [test unit (computed): ch - circle(at bottom 70ch left 50ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at bottom 70ch right 80%)]
    expected: FAIL

  [test unit (computed): ch - circle(at bottom 70ch right 80ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at right 80% bottom 70ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at right 80ch top 50%)]
    expected: FAIL

  [test unit (computed): ch - circle(at right 80ch top 50ch)]
    expected: FAIL

  [test unit (computed): ch - circle(at right 80ch bottom 70%)]
    expected: FAIL

  [test unit (computed): ch - circle(at right 80ch bottom 70ch)]
    expected: FAIL

  [test unit (computed): rem - circle(at left 50% bottom 70rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at left 50rem bottom 70rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at top 50% right 80rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at top 50rem right 80rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at bottom 70% right 80rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at bottom 70rem left 50%)]
    expected: FAIL

  [test unit (computed): rem - circle(at bottom 70rem left 50rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at bottom 70rem right 80%)]
    expected: FAIL

  [test unit (computed): rem - circle(at bottom 70rem right 80rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at right 80% bottom 70rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at right 80rem top 50%)]
    expected: FAIL

  [test unit (computed): rem - circle(at right 80rem top 50rem)]
    expected: FAIL

  [test unit (computed): rem - circle(at right 80rem bottom 70%)]
    expected: FAIL

  [test unit (computed): rem - circle(at right 80rem bottom 70rem)]
    expected: FAIL

  [test unit (computed): vw - circle(at left 50% bottom 70vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at left 50vw bottom 70vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at top 50% right 80vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at top 50vw right 80vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at bottom 70% right 80vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at bottom 70vw left 50%)]
    expected: FAIL

  [test unit (computed): vw - circle(at bottom 70vw left 50vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at bottom 70vw right 80%)]
    expected: FAIL

  [test unit (computed): vw - circle(at bottom 70vw right 80vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at right 80% bottom 70vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at right 80vw top 50%)]
    expected: FAIL

  [test unit (computed): vw - circle(at right 80vw top 50vw)]
    expected: FAIL

  [test unit (computed): vw - circle(at right 80vw bottom 70%)]
    expected: FAIL

  [test unit (computed): vw - circle(at right 80vw bottom 70vw)]
    expected: FAIL

  [test unit (computed): vh - circle(at left 50% bottom 70vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at left 50vh bottom 70vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at top 50% right 80vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at top 50vh right 80vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at bottom 70% right 80vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at bottom 70vh left 50%)]
    expected: FAIL

  [test unit (computed): vh - circle(at bottom 70vh left 50vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at bottom 70vh right 80%)]
    expected: FAIL

  [test unit (computed): vh - circle(at bottom 70vh right 80vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at right 80% bottom 70vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at right 80vh top 50%)]
    expected: FAIL

  [test unit (computed): vh - circle(at right 80vh top 50vh)]
    expected: FAIL

  [test unit (computed): vh - circle(at right 80vh bottom 70%)]
    expected: FAIL

  [test unit (computed): vh - circle(at right 80vh bottom 70vh)]
    expected: FAIL

  [test unit (computed): vmin - circle(at left 50% bottom 70vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at left 50vmin bottom 70vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at top 50% right 80vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at top 50vmin right 80vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at bottom 70% right 80vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at bottom 70vmin left 50%)]
    expected: FAIL

  [test unit (computed): vmin - circle(at bottom 70vmin left 50vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at bottom 70vmin right 80%)]
    expected: FAIL

  [test unit (computed): vmin - circle(at bottom 70vmin right 80vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at right 80% bottom 70vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at right 80vmin top 50%)]
    expected: FAIL

  [test unit (computed): vmin - circle(at right 80vmin top 50vmin)]
    expected: FAIL

  [test unit (computed): vmin - circle(at right 80vmin bottom 70%)]
    expected: FAIL

  [test unit (computed): vmin - circle(at right 80vmin bottom 70vmin)]
    expected: FAIL

  [test unit (computed): vmax - circle(at left 50% bottom 70vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at left 50vmax bottom 70vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at top 50% right 80vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at top 50vmax right 80vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at bottom 70% right 80vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at bottom 70vmax left 50%)]
    expected: FAIL

  [test unit (computed): vmax - circle(at bottom 70vmax left 50vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at bottom 70vmax right 80%)]
    expected: FAIL

  [test unit (computed): vmax - circle(at bottom 70vmax right 80vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at right 80% bottom 70vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at right 80vmax top 50%)]
    expected: FAIL

  [test unit (computed): vmax - circle(at right 80vmax top 50vmax)]
    expected: FAIL

  [test unit (computed): vmax - circle(at right 80vmax bottom 70%)]
    expected: FAIL

  [test unit (computed): vmax - circle(at right 80vmax bottom 70vmax)]
    expected: FAIL

  [test unit (inline): cm - circle(at 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at left 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at 50cm top)]
    expected: FAIL

  [test unit (inline): cm - circle(at right 80cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at 70cm bottom)]
    expected: FAIL

  [test unit (inline): cm - circle(at center 60cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at 60cm center)]
    expected: FAIL

  [test unit (inline): cm - circle(at left 50% top 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at left 50cm top 50%)]
    expected: FAIL

  [test unit (inline): cm - circle(at left 50cm top 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at left 50cm bottom 70%)]
    expected: FAIL

  [test unit (inline): cm - circle(at top 50% left 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at top 50cm left 50%)]
    expected: FAIL

  [test unit (inline): cm - circle(at top 50cm left 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at top 50cm right 80%)]
    expected: FAIL

  [test unit (inline): cm - circle(at bottom 70% left 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at bottom 70% right 80cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at bottom 70cm right 80%)]
    expected: FAIL

  [test unit (inline): cm - circle(at right 80% top 50cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at right 80% bottom 70cm)]
    expected: FAIL

  [test unit (inline): cm - circle(at right 80cm bottom 70%)]
    expected: FAIL

  [test unit (inline): mm - circle(at 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at left 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at 50mm top)]
    expected: FAIL

  [test unit (inline): mm - circle(at right 80mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at 70mm bottom)]
    expected: FAIL

  [test unit (inline): mm - circle(at center 60mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at 60mm center)]
    expected: FAIL

  [test unit (inline): mm - circle(at left 50% top 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at left 50mm top 50%)]
    expected: FAIL

  [test unit (inline): mm - circle(at left 50mm top 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at left 50mm bottom 70%)]
    expected: FAIL

  [test unit (inline): mm - circle(at top 50% left 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at top 50mm left 50%)]
    expected: FAIL

  [test unit (inline): mm - circle(at top 50mm left 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at top 50mm right 80%)]
    expected: FAIL

  [test unit (inline): mm - circle(at bottom 70% left 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at bottom 70% right 80mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at bottom 70mm right 80%)]
    expected: FAIL

  [test unit (inline): mm - circle(at right 80% top 50mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at right 80% bottom 70mm)]
    expected: FAIL

  [test unit (inline): mm - circle(at right 80mm bottom 70%)]
    expected: FAIL

  [test unit (inline): in - circle(at 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at left 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at 50in top)]
    expected: FAIL

  [test unit (inline): in - circle(at right 80in)]
    expected: FAIL

  [test unit (inline): in - circle(at 70in bottom)]
    expected: FAIL

  [test unit (inline): in - circle(at center 60in)]
    expected: FAIL

  [test unit (inline): in - circle(at 60in center)]
    expected: FAIL

  [test unit (inline): in - circle(at left 50% top 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at left 50in top 50%)]
    expected: FAIL

  [test unit (inline): in - circle(at left 50in top 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at left 50in bottom 70%)]
    expected: FAIL

  [test unit (inline): in - circle(at top 50% left 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at top 50in left 50%)]
    expected: FAIL

  [test unit (inline): in - circle(at top 50in left 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at top 50in right 80%)]
    expected: FAIL

  [test unit (inline): in - circle(at bottom 70% left 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at bottom 70% right 80in)]
    expected: FAIL

  [test unit (inline): in - circle(at bottom 70in right 80%)]
    expected: FAIL

  [test unit (inline): in - circle(at right 80% top 50in)]
    expected: FAIL

  [test unit (inline): in - circle(at right 80% bottom 70in)]
    expected: FAIL

  [test unit (inline): in - circle(at right 80in bottom 70%)]
    expected: FAIL

  [test unit (inline): pt - circle(at 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at left 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at 50pt top)]
    expected: FAIL

  [test unit (inline): pt - circle(at right 80pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at 70pt bottom)]
    expected: FAIL

  [test unit (inline): pt - circle(at center 60pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at 60pt center)]
    expected: FAIL

  [test unit (inline): pt - circle(at left 50% top 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at left 50pt top 50%)]
    expected: FAIL

  [test unit (inline): pt - circle(at left 50pt top 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at left 50pt bottom 70%)]
    expected: FAIL

  [test unit (inline): pt - circle(at top 50% left 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at top 50pt left 50%)]
    expected: FAIL

  [test unit (inline): pt - circle(at top 50pt left 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at top 50pt right 80%)]
    expected: FAIL

  [test unit (inline): pt - circle(at bottom 70% left 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at bottom 70% right 80pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at bottom 70pt right 80%)]
    expected: FAIL

  [test unit (inline): pt - circle(at right 80% top 50pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at right 80% bottom 70pt)]
    expected: FAIL

  [test unit (inline): pt - circle(at right 80pt bottom 70%)]
    expected: FAIL

  [test unit (inline): pc - circle(at 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at left 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at 50pc top)]
    expected: FAIL

  [test unit (inline): pc - circle(at right 80pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at 70pc bottom)]
    expected: FAIL

  [test unit (inline): pc - circle(at center 60pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at 60pc center)]
    expected: FAIL

  [test unit (inline): pc - circle(at left 50% top 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at left 50pc top 50%)]
    expected: FAIL

  [test unit (inline): pc - circle(at left 50pc top 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at left 50pc bottom 70%)]
    expected: FAIL

  [test unit (inline): pc - circle(at top 50% left 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at top 50pc left 50%)]
    expected: FAIL

  [test unit (inline): pc - circle(at top 50pc left 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at top 50pc right 80%)]
    expected: FAIL

  [test unit (inline): pc - circle(at bottom 70% left 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at bottom 70% right 80pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at bottom 70pc right 80%)]
    expected: FAIL

  [test unit (inline): pc - circle(at right 80% top 50pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at right 80% bottom 70pc)]
    expected: FAIL

  [test unit (inline): pc - circle(at right 80pc bottom 70%)]
    expected: FAIL

  [test unit (inline): em - circle(at 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at left 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at 50em top)]
    expected: FAIL

  [test unit (inline): em - circle(at right 80em)]
    expected: FAIL

  [test unit (inline): em - circle(at 70em bottom)]
    expected: FAIL

  [test unit (inline): em - circle(at center 60em)]
    expected: FAIL

  [test unit (inline): em - circle(at 60em center)]
    expected: FAIL

  [test unit (inline): em - circle(at left 50% top 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at left 50em top 50%)]
    expected: FAIL

  [test unit (inline): em - circle(at left 50em top 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at left 50em bottom 70%)]
    expected: FAIL

  [test unit (inline): em - circle(at top 50% left 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at top 50em left 50%)]
    expected: FAIL

  [test unit (inline): em - circle(at top 50em left 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at top 50em right 80%)]
    expected: FAIL

  [test unit (inline): em - circle(at bottom 70% left 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at bottom 70% right 80em)]
    expected: FAIL

  [test unit (inline): em - circle(at bottom 70em right 80%)]
    expected: FAIL

  [test unit (inline): em - circle(at right 80% top 50em)]
    expected: FAIL

  [test unit (inline): em - circle(at right 80% bottom 70em)]
    expected: FAIL

  [test unit (inline): em - circle(at right 80em bottom 70%)]
    expected: FAIL

  [test unit (inline): ex - circle(at 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at left 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at 50ex top)]
    expected: FAIL

  [test unit (inline): ex - circle(at right 80ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at 70ex bottom)]
    expected: FAIL

  [test unit (inline): ex - circle(at center 60ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at 60ex center)]
    expected: FAIL

  [test unit (inline): ex - circle(at left 50% top 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at left 50ex top 50%)]
    expected: FAIL

  [test unit (inline): ex - circle(at left 50ex top 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at left 50ex bottom 70%)]
    expected: FAIL

  [test unit (inline): ex - circle(at top 50% left 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at top 50ex left 50%)]
    expected: FAIL

  [test unit (inline): ex - circle(at top 50ex left 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at top 50ex right 80%)]
    expected: FAIL

  [test unit (inline): ex - circle(at bottom 70% left 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at bottom 70% right 80ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at bottom 70ex right 80%)]
    expected: FAIL

  [test unit (inline): ex - circle(at right 80% top 50ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at right 80% bottom 70ex)]
    expected: FAIL

  [test unit (inline): ex - circle(at right 80ex bottom 70%)]
    expected: FAIL

  [test unit (inline): ch - circle(at 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at left 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at 50ch top)]
    expected: FAIL

  [test unit (inline): ch - circle(at right 80ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at 70ch bottom)]
    expected: FAIL

  [test unit (inline): ch - circle(at center 60ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at 60ch center)]
    expected: FAIL

  [test unit (inline): ch - circle(at left 50% top 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at left 50ch top 50%)]
    expected: FAIL

  [test unit (inline): ch - circle(at left 50ch top 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at left 50ch bottom 70%)]
    expected: FAIL

  [test unit (inline): ch - circle(at top 50% left 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at top 50ch left 50%)]
    expected: FAIL

  [test unit (inline): ch - circle(at top 50ch left 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at top 50ch right 80%)]
    expected: FAIL

  [test unit (inline): ch - circle(at bottom 70% left 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at bottom 70% right 80ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at bottom 70ch right 80%)]
    expected: FAIL

  [test unit (inline): ch - circle(at right 80% top 50ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at right 80% bottom 70ch)]
    expected: FAIL

  [test unit (inline): ch - circle(at right 80ch bottom 70%)]
    expected: FAIL

  [test unit (inline): rem - circle(at 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at left 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at 50rem top)]
    expected: FAIL

  [test unit (inline): rem - circle(at right 80rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at 70rem bottom)]
    expected: FAIL

  [test unit (inline): rem - circle(at center 60rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at 60rem center)]
    expected: FAIL

  [test unit (inline): rem - circle(at left 50% top 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at left 50rem top 50%)]
    expected: FAIL

  [test unit (inline): rem - circle(at left 50rem top 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at left 50rem bottom 70%)]
    expected: FAIL

  [test unit (inline): rem - circle(at top 50% left 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at top 50rem left 50%)]
    expected: FAIL

  [test unit (inline): rem - circle(at top 50rem left 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at top 50rem right 80%)]
    expected: FAIL

  [test unit (inline): rem - circle(at bottom 70% left 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at bottom 70% right 80rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at bottom 70rem right 80%)]
    expected: FAIL

  [test unit (inline): rem - circle(at right 80% top 50rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at right 80% bottom 70rem)]
    expected: FAIL

  [test unit (inline): rem - circle(at right 80rem bottom 70%)]
    expected: FAIL

  [test unit (inline): vw - circle(at 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at left 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at 50vw top)]
    expected: FAIL

  [test unit (inline): vw - circle(at right 80vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at 70vw bottom)]
    expected: FAIL

  [test unit (inline): vw - circle(at center 60vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at 60vw center)]
    expected: FAIL

  [test unit (inline): vw - circle(at left 50% top 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at left 50vw top 50%)]
    expected: FAIL

  [test unit (inline): vw - circle(at left 50vw top 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at left 50vw bottom 70%)]
    expected: FAIL

  [test unit (inline): vw - circle(at top 50% left 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at top 50vw left 50%)]
    expected: FAIL

  [test unit (inline): vw - circle(at top 50vw left 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at top 50vw right 80%)]
    expected: FAIL

  [test unit (inline): vw - circle(at bottom 70% left 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at bottom 70% right 80vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at bottom 70vw right 80%)]
    expected: FAIL

  [test unit (inline): vw - circle(at right 80% top 50vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at right 80% bottom 70vw)]
    expected: FAIL

  [test unit (inline): vw - circle(at right 80vw bottom 70%)]
    expected: FAIL

  [test unit (inline): vh - circle(at 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at left 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at 50vh top)]
    expected: FAIL

  [test unit (inline): vh - circle(at right 80vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at 70vh bottom)]
    expected: FAIL

  [test unit (inline): vh - circle(at center 60vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at 60vh center)]
    expected: FAIL

  [test unit (inline): vh - circle(at left 50% top 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at left 50vh top 50%)]
    expected: FAIL

  [test unit (inline): vh - circle(at left 50vh top 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at left 50vh bottom 70%)]
    expected: FAIL

  [test unit (inline): vh - circle(at top 50% left 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at top 50vh left 50%)]
    expected: FAIL

  [test unit (inline): vh - circle(at top 50vh left 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at top 50vh right 80%)]
    expected: FAIL

  [test unit (inline): vh - circle(at bottom 70% left 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at bottom 70% right 80vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at bottom 70vh right 80%)]
    expected: FAIL

  [test unit (inline): vh - circle(at right 80% top 50vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at right 80% bottom 70vh)]
    expected: FAIL

  [test unit (inline): vh - circle(at right 80vh bottom 70%)]
    expected: FAIL

  [test unit (inline): vmin - circle(at 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at left 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at 50vmin top)]
    expected: FAIL

  [test unit (inline): vmin - circle(at right 80vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at 70vmin bottom)]
    expected: FAIL

  [test unit (inline): vmin - circle(at center 60vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at 60vmin center)]
    expected: FAIL

  [test unit (inline): vmin - circle(at left 50% top 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at left 50vmin top 50%)]
    expected: FAIL

  [test unit (inline): vmin - circle(at left 50vmin top 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at left 50vmin bottom 70%)]
    expected: FAIL

  [test unit (inline): vmin - circle(at top 50% left 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at top 50vmin left 50%)]
    expected: FAIL

  [test unit (inline): vmin - circle(at top 50vmin left 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at top 50vmin right 80%)]
    expected: FAIL

  [test unit (inline): vmin - circle(at bottom 70% left 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at bottom 70% right 80vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at bottom 70vmin right 80%)]
    expected: FAIL

  [test unit (inline): vmin - circle(at right 80% top 50vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at right 80% bottom 70vmin)]
    expected: FAIL

  [test unit (inline): vmin - circle(at right 80vmin bottom 70%)]
    expected: FAIL

  [test unit (inline): vmax - circle(at 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at left 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at 50vmax top)]
    expected: FAIL

  [test unit (inline): vmax - circle(at right 80vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at 70vmax bottom)]
    expected: FAIL

  [test unit (inline): vmax - circle(at center 60vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at 60vmax center)]
    expected: FAIL

  [test unit (inline): vmax - circle(at left 50% top 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at left 50vmax top 50%)]
    expected: FAIL

  [test unit (inline): vmax - circle(at left 50vmax top 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at left 50vmax bottom 70%)]
    expected: FAIL

  [test unit (inline): vmax - circle(at top 50% left 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at top 50vmax left 50%)]
    expected: FAIL

  [test unit (inline): vmax - circle(at top 50vmax left 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at top 50vmax right 80%)]
    expected: FAIL

  [test unit (inline): vmax - circle(at bottom 70% left 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at bottom 70% right 80vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at bottom 70vmax right 80%)]
    expected: FAIL

  [test unit (inline): vmax - circle(at right 80% top 50vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at right 80% bottom 70vmax)]
    expected: FAIL

  [test unit (inline): vmax - circle(at right 80vmax bottom 70%)]
    expected: FAIL

