### ----------------------------------------------------
### -- Perl6::Parser
### -- Licenses: Artistic-2.0
### -- Authors: Jeffrey Goff <drforr@pobox.com>
### -- File: t/19-operators.t
### ----------------------------------------------------
### -- Chunk 2 of 3
 done-testing;
  }, Q{x};

  # XXX '1xx2' is illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 xx 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{xx};
}, Q{Replication Precedence};

subtest {
  plan 2;

  subtest {
    plan 2;

    my $source = Q{1~2};
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{no ws};

  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 ~ 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ws};
}, Q{Concatenation Precedence};

subtest {
  plan 2;

  subtest {
    plan 2;

    my $source = Q{1&2};
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{no ws};

  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 & 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ws};
}, Q{Junctive AND Precedence};

subtest {
  plan 2;

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1|2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 | 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{|};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1^2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ^ 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{^};
}, Q{Junctive OR Precedence};

# XXX 'temp$a' is illegal (weird.)
subtest {
  plan 2;

  subtest {
    plan 2;

    my $source = Q:to[_END_];
    my $a; temp $a
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{temp};

  # XXX 'let$a' is illegal (weird.)
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    my $a; let $a
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ws};
}, Q{Named Unary Precedence};

subtest {
  plan 9;

  # XXX '1does2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 does 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{does};

  # XXX '1but2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 but 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{but};

  # XXX '1cmp2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 cmp 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{cmp};

  # XXX '1leg2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 leg 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{leg};

  # XXX '1<=>2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 <=> 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{<=>};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1..2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 .. 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{..};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1^..2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ^.. 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{^..};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1..^2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ..^ 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{..^};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1^..^2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ^..^ 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{^..^};
}, Q{Nonchaining Binary Precedence};

subtest {
  plan 20;

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1==2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 == 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{==};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1!=2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 != 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{!=};

  # XXX '1<2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 < 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{<};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1>2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 > 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{>};

  # XXX '1<=2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 <= 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{<=};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1>2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 > 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{>};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1>=2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 >= 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{>=};

  # XXX '1eq2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 eq 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{eq};

  # XXX '1ne2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 ne 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ne};

  # XXX '1gt2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 gt 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{gt};

  # XXX '1ge2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 ge 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ge};

  # XXX '1lt2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 lt 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{lt};

  # XXX '1le2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 le 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{le};

  # XXX '1before2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 before 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{before};

  # XXX '1after2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 after 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{after};

  # XXX '1eqv2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 eqv 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{eqv};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1===2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1===2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{===};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1=:=2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 =:= 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{=:=};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1~~2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ~~ 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{~~};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1=~=2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 =~= 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{=~=};
}, Q{Chaining Binary Precedence};

subtest {
  plan 2;

  subtest {
    plan 2;

    my $source = Q{1&&2};
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{no ws};

  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 && 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ws};
}, Q{Tight AND Precedence};

subtest {
  plan 5;

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1||2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 || 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{||};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1^^2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ^^ 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{^^};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1//2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 // 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{//};

  # XXX '1min2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 min 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{min};

  # XXX '1max2' is illegal.
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 max 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ws};
}, Q{Tight OR Precedence};

subtest {
  plan 9;

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1??2!!3};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ?? 2 !! 3
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{?? !!};

  # XXX '1ff2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 ff 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ff};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1...2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ^ff 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{^ff};

  # XXX '1ff^2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 ff^ 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{ff^};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1^ff^2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ^ff^ 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{^ff^};

  # XXX '1fff2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 fff 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{fff};

  # XXX '1^fff2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 ^fff 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{^fff};

  # XXX '1fff^2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 fff^ 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{fff^};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{1^fff^2};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      1 ^fff^ 2
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{^fff^};
}, Q{Conditional Operator Precedence};

subtest {
  plan 2;

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{my$a=1};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      my $a = 1
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{=};

  subtest {
    plan 2;

    subtest {
      plan 2;

      my $source = Q{a=>1};
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{no ws};

    subtest {
      plan 2;

      my $source = Q:to[_END_];
      a => 1
      _END_
      my $tree = $pp.to-tree( $source );
      ok has-a( $tree, Perl6::Operator ), Q{found operator};
      is $pp.to-string( $tree ), $source, Q{formatted};

      done-testing;
    }, Q{ws};
  }, Q{=>};
}, Q{Item Assignment Precedence};

subtest {
  plan 2;

  # XXX 'not2' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    not 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{not};

  # XXX 'so1' illegal
  subtest {
    plan 2;

    my $source = Q:to[_END_];
    so 1
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{so};
}, Q{Loose Unary Precedence};

subtest {
  plan 2;

  subtest {
    plan 2;

    my $source = Q{1,2};
    my $tree = $pp.to-tree( $source );
    ok has-a( $tree, Perl6::Operator ), Q{found operator};
    is $pp.to-string( $tree ), $source, Q{formatted};

    done-testing;
  }, Q{no ws};

  subtest {
    plan 2;

    my $source = Q:to[_END_];
    1 , 2
    _END_
    my $tree = $pp.to-tree( $source );
    ok has-a