### ----------------------------------------------------
### -- Perl6::Parser
### -- Licenses: Artistic-2.0
### -- Authors: Jeffrey Goff <drforr@pobox.com>
### -- File: t/16-quote.t
### ----------------------------------------------------
### -- Chunk 2 of 4
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::WordQuoting::QuoteProtection,
             Q{correct type};
      is $node.quote, Q{qww}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :w};
  
  subtest {
    subtest {
      my $source = Q{qww :x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::WordQuoting::QuoteProtection,
             Q{correct type};
      is $node.quote, Q{qww}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{qww :x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::WordQuoting::QuoteProtection,
             Q{correct type};
      is $node.quote, Q{qww}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{qww:x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::WordQuoting::QuoteProtection,
             Q{correct type};
      is $node.quote, Q{qww}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{qww:x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::WordQuoting::QuoteProtection,
             Q{correct type};
      is $node.quote, Q{qww}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :x};
  
  subtest {
    my $source = Q{qww <pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::WordQuoting::QuoteProtection,
             Q{correct type};
    is $node.quote, Q{qww}, Q{quote name};
    is $node.delimiter-start, Q{<}, Q{start delimiter};
    is $node.delimiter-end, Q{>}, Q{end delimiter};
    
    done-testing;
  }, Q{ws, no adverbs};
  
  subtest {
    my $source = Q{qww<pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::WordQuoting::QuoteProtection,
             Q{correct type};
    is $node.quote, Q{qww}, Q{quote name};
    is $node.delimiter-start, Q{<}, Q{start delimiter};
    is $node.delimiter-end, Q{>}, Q{end delimiter};
    
    done-testing;
  }, Q{no ws, no adverbs};
  
  done-testing;
}, Q{qww<>};

# Qq is illegal

subtest {
  subtest {
    subtest {
      my $source = Q{Qw :q <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qw :q<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qw:q <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{Qw:q<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :q};
  
  subtest {
    subtest {
      my $source = Q{Qw :to <END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qw :to<END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qw:to <END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};

    subtest {
      my $source = Q{Qw:to<END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};

    done-testing;
  }, Q{adverb :to};

  subtest {
    subtest {
      my $source = Q{Qw :w <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qw :w<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qw:w <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{Qw:w<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
  
    done-testing;
  }, Q{adverb :w};

  subtest {
    subtest {
      my $source = Q{Qw :x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qw :x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qw:x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{Qw:x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
      is $node.quote, Q{Qw}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :x};
  
  subtest {
    my $source = Q{Qw <pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
    is $node.quote, Q{Qw}, Q{quote name};
    is $node.delimiter-start, Q{<}, Q{start delimiter};
    is $node.delimiter-end, Q{>}, Q{end delimiter};
    
    done-testing;
  }, Q{ws, no adverbs};
  
  subtest {
    my $source = Q{Qw<pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::Literal::WordQuoting,
             Q{correct type};
    is $node.quote, Q{Qw}, Q{quote name};
    is $node.delimiter-start, Q{<}, Q{start delimiter};
    is $node.delimiter-end, Q{>}, Q{end delimiter};
    
    done-testing;
  }, Q{no ws, no adverbs};
  
  done-testing;
}, Q{Qw<>};

subtest {
  subtest {
    subtest {
      my $source = Q{Qx :q <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qx :q<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qx:q <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{Qx:q<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :q};
  
  subtest {
    subtest {
      my $source = Q{Qx :to <END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qx :to<END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qx:to <END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};

    subtest {
      my $source = Q{Qx:to<END>
pi
END};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};

    done-testing;
  }, Q{adverb :to};

  subtest {
    subtest {
      my $source = Q{Qx :w <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qx :w<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qx:w <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{Qx:w<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :w};

  subtest {
    subtest {
      my $source = Q{Qx :x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{Qx :x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{Qx:x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{Qx:x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
      is $node.quote, Q{Qx}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :x};

  subtest {
    my $source = Q{Qx <pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
    is $node.quote, Q{Qx}, Q{quote name};
    is $node.delimiter-start, Q{<}, Q{start delimiter};
    is $node.delimiter-end, Q{>}, Q{end delimiter};
    
    done-testing;
  }, Q{ws, no adverbs};

  subtest {
    my $source = Q{Qx<pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::Literal::Shell,
             Q{correct type};
    is $node.quote, Q{Qx}, Q{quote name};
    is $node.delimiter-start, Q{<}, Q{start delimiter};
    is $node.delimiter-end, Q{>}, Q{end delimiter};
    
    done-testing;
  }, Q{no ws, no adverbs};

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

subtest {
  subtest {
    subtest {
      my $source = Q{qq :w <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{qq :w<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{qq:w <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{qq:w<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :w};
  
  subtest {
    subtest {
      my $source = Q{qq :x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{all intervening ws};
    
    subtest {
      my $source = Q{qq :x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{leading intervening ws};
    
    subtest {
      my $source = Q{qq:x <pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{trailing intervening ws};
    
    subtest {
      my $source = Q{qq:x<pi>};
      my $tree = $pp.to-tree( $source );
      my $node = $tree.child.[0].child.[0];
      
      is $pp.to-string( $tree ), $source, Q{formatted};
      isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
      is $node.quote, Q{qq}, Q{quote name};
      is $node.delimiter-start, Q{<}, Q{start delimiter};
      is $node.delimiter-end, Q{>}, Q{end delimiter};
      
      done-testing;
    }, Q{no intervening ws};
    
    done-testing;
  }, Q{adverb :x};
  
  subtest {
    my $source = Q{qq <pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::Interpolation,
             Q{correct type};
    is $node.quote, Q{qq}, Q{quote name};
    is $node.delimiter-start, Q{<}, Q{start delimiter};
    is $node.delimiter-end, Q{>}, Q{end delimiter};
    
    done-testing;
  }, Q{ws, no adverbs};
  
  subtest {
    my $source = Q{qq<pi>};
    my $tree = $pp.to-tree( $source );
    my $node = $tree.child.[0].child.[0];
    
    is $pp.to-string( $tree ), $source, Q{formatted};
    isa-ok $node, Perl6::String::Interpolation,
