xref: /external/antlr/antlr-3.4/runtime/Ruby/test/functional/ast-output/tree-rewrite.rb

#!/usr/bin/ruby
# encoding: utf-8

require 'antlr3/test/functional'


class TestASTRewritingTreeParsers < ANTLR3::Test::Functional
  inline_grammar( <<-'END' )
    grammar FlatList;
    options {
      language=Ruby;
      output=AST;
    }
    a : ID INT;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END
  
  inline_grammar( <<-'END' )
    tree grammar FlatListWalker;
    options {
      language=Ruby;
      output=AST;
      ASTLabelType=CommonTree;
      tokenVocab=FlatList;
    }
    
    a : ID INT -> INT ID;
  END

  inline_grammar( <<-'END' )
    grammar SimpleTree;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar SimpleTreeWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=SimpleTree;
    }
    a : ^(ID INT) -> ^(INT ID);
  END

  inline_grammar( <<-END )
    grammar CombinedRewriteAndAuto;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT) | INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-END )
    tree grammar CombinedRewriteAndAutoTree;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=CombinedRewriteAndAuto;
    }
    a : ^(ID INT) -> ^(INT ID) | INT;
  END

  inline_grammar( <<-'END' )
    grammar AvoidDup;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AvoidDupWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AvoidDup;
    }
    a : ID -> ^(ID ID);
  END

  inline_grammar( <<-'END' )
    grammar Loop;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID+ INT+ -> (^(ID INT))+ ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar LoopWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=Loop;
    }
    a : (^(ID INT))+ -> INT+ ID+;
  END

  inline_grammar( <<-'END' )
    grammar AutoDup;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDup;
    }
    a : ID;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupRule;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupRuleWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupRule;
    }
    a : b c ;
    b : ID ;
    c : INT ;
  END

  inline_grammar( <<-'END' )
    grammar AutoWildcard;
    options {language=Ruby;output=AST;}
    a : ID INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoWildcardWalker;
    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcard;}
    a : ID . 
      ;
  END
  
  inline_grammar( <<-'END' )
    grammar AutoWildcard2;
    options {language=Ruby;output=AST;}
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoWildcard2Walker;
    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcard2;}
    a : ^(ID .) 
      ;
  END

  inline_grammar( <<-'END' )
    grammar AutoWildcardWithLabel;
    options {language=Ruby;output=AST;}
    a : ID INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoWildcardWithLabelWalker;
    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcardWithLabel;}
    a : ID c=. 
      ;
  END

  inline_grammar( <<-'END' )
    grammar AutoWildcardWithListLabel;
    options {language=Ruby;output=AST;}
    a : ID INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END
  
  inline_grammar( <<-'END' )
    tree grammar AutoWildcardWithListLabelWalker;
    options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcardWithListLabel;}
    a : ID c+=. 
      ;
  END
  
  inline_grammar( <<-'END' )
    grammar AutoDupMultiple;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID ID INT;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupMultipleWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupMultiple;
    }
    a : ID ID INT
      ;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupTree;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupTreeWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupTree;
    }
    a : ^(ID INT)
      ;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupTreeWithLabels;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupTreeWithLabelsWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupTreeWithLabels;
    }
    a : ^(x=ID y=INT)
      ;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupTreeWithListLabels;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupTreeWithListLabelsWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupTreeWithListLabels;
    }
    a : ^(x+=ID y+=INT)
      ;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupTreeWithRuleRoot;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupTreeWithRuleRootWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupTreeWithRuleRoot;
    }
    a : ^(b INT) ;
    b : ID ;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupTreeWithRuleRootAndLabels;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupTreeWithRuleRootAndLabelsWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupTreeWithRuleRootAndLabels;
    }
    a : ^(x=b INT) ;
    b : ID ;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupTreeWithRuleRootAndListLabels;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupTreeWithRuleRootAndListLabelsWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupTreeWithRuleRootAndListLabels;
    }
    a : ^(x+=b y+=c) ;
    b : ID ;
    c : INT ;
  END

  inline_grammar( <<-'END' )
    grammar AutoDupNestedTree;
    options {
        language=Ruby;
        output=AST;
    }
    a : x=ID y=ID INT -> ^($x ^($y INT));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar AutoDupNestedTreeWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=AutoDupNestedTree;
    }
    a : ^(ID ^(ID INT))
      ;
  END

  inline_grammar( <<-'END' )
    grammar Delete;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar DeleteWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=Delete;
    }
    a : ID -> 
      ;
  END

  inline_grammar( <<-'END' )
    grammar SetMatchNoRewrite;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar SetMatchNoRewriteWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=SetMatchNoRewrite;
    }
    a : b INT;
    b : ID | INT;
  END

  inline_grammar( <<-'END' )
    grammar SetOptionalMatchNoRewrite;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar SetOptionalMatchNoRewriteWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=SetOptionalMatchNoRewrite;
    }
    a : (ID|INT)? INT ;
  END

  inline_grammar( <<-'END' )
    grammar SetMatchNoRewriteLevel2;
    options {
        language=Ruby;
        output=AST;
    }
    a : x=ID INT -> ^($x INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar SetMatchNoRewriteLevel2Walker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=SetMatchNoRewriteLevel2;
    }
    a : ^(ID (ID | INT) ) ;
  END

  inline_grammar( <<-'END' )
    grammar SetMatchNoRewriteLevel2Root;
    options {
        language=Ruby;
        output=AST;
    }
    a : x=ID INT -> ^($x INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar SetMatchNoRewriteLevel2RootWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=SetMatchNoRewriteLevel2Root;
    }
    a : ^((ID | INT) INT) ;
  END

  inline_grammar( <<-END )
    grammar RewriteModeCombinedRewriteAndAuto;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT) | INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-END )
    tree grammar RewriteModeCombinedRewriteAndAutoTree;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=RewriteModeCombinedRewriteAndAuto;
        rewrite=true;
    }
    a : ^(ID INT) -> ^(ID["ick"] INT)
      | INT // leaves it alone, returning $a.start
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeFlatTree;
    options {
      language=Ruby;
      output=AST;
    }
    a : ID INT -> ID INT | INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeFlatTreeWalker;
    options {
      language=Ruby;
      output=AST;
      ASTLabelType=CommonTree;
      tokenVocab=RewriteModeFlatTree;
      rewrite=true;
    }
    s : ID a ;
    a : INT -> INT["1"]
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeChainRuleFlatTree;
    options {language=Ruby; output=AST;}
    a : ID INT -> ID INT | INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeChainRuleFlatTreeWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleFlatTree; rewrite=true;}
    s : a ;
    a : b ;
    b : ID INT -> INT ID
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeChainRuleTree;
    options {language=Ruby; output=AST;}
    a : ID INT -> ^(ID INT) ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeChainRuleTreeWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree; rewrite=true;}
    s : a ;
    a : b ; // a.tree must become b.tree
    b : ^(ID INT) -> INT
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeChainRuleTree2;
    options {language=Ruby; output=AST;}
    a : ID INT -> ^(ID INT) ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeChainRuleTree2Walker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree2; rewrite=true;}
    tokens { X; }
    s : a* b ; // only b contributes to tree, but it's after a*; s.tree = b.tree
    a : X ;
    b : ^(ID INT) -> INT
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeChainRuleTree3;
    options {language=Ruby; output=AST;}
    a : 'boo' ID INT -> 'boo' ^(ID INT) ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeChainRuleTree3Walker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree3; rewrite=true;}
    tokens { X; }
    s : 'boo' a* b ; // don't reset s.tree to b.tree due to 'boo'
    a : X ;
    b : ^(ID INT) -> INT
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeChainRuleTree4;
    options {language=Ruby; output=AST;}
    a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeChainRuleTree4Walker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree4; rewrite=true;}
    tokens { X; }
    s : ^('boo' a* b) ; // don't reset s.tree to b.tree due to 'boo'
    a : X ;
    b : ^(ID INT) -> INT
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeChainRuleTree5;
    options {language=Ruby; output=AST;}
    a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeChainRuleTree5Walker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree5; rewrite=true;}
    tokens { X; }
    s : ^(a b) ; // s.tree is a.tree
    a : 'boo' ;
    b : ^(ID INT) -> INT
      ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteOfRuleRef;
    options {language=Ruby; output=AST;}
    a : ID INT -> ID INT | INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteOfRuleRefWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRef; rewrite=true;}
    s : a -> a ;
    a : ID INT -> ID INT ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteOfRuleRefRoot;
    options {language=Ruby; output=AST;}
    a : ID INT INT -> ^(INT ^(ID INT));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteOfRuleRefRootWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRoot; rewrite=true;}
    s : ^(a ^(ID INT)) -> a ;
    a : INT ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteOfRuleRefRootLabeled;
    options {language=Ruby; output=AST;}
    a : ID INT INT -> ^(INT ^(ID INT));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteOfRuleRefRootLabeledWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRootLabeled; rewrite=true;}
    s : ^(label=a ^(ID INT)) -> a ;
    a : INT ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteOfRuleRefRootListLabeled;
    options {language=Ruby; output=AST;}
    a : ID INT INT -> ^(INT ^(ID INT));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteOfRuleRefRootListLabeledWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRootListLabeled; rewrite=true;}
    s : ^(label+=a ^(ID INT)) -> a ;
    a : INT ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteOfRuleRefChild;
    options {language=Ruby; output=AST;}
    a : ID INT -> ^(ID ^(INT INT));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteOfRuleRefChildWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefChild; rewrite=true;}
    s : ^(ID a) -> a ;
    a : ^(INT INT) ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteOfRuleRefLabel;
    options {language=Ruby; output=AST;}
    a : ID INT -> ^(ID ^(INT INT));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteOfRuleRefLabelWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefLabel; rewrite=true;}
    s : ^(ID label=a) -> a ;
    a : ^(INT INT) ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteOfRuleRefListLabel;
    options {language=Ruby; output=AST;}
    a : ID INT -> ^(ID ^(INT INT));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteOfRuleRefListLabelWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefListLabel; rewrite=true;}
    s : ^(ID label+=a) -> a ;
    a : ^(INT INT) ;
  END

  inline_grammar( <<-'END' )
    grammar RewriteModeWithPredicatedRewrites;
    options {
      language=Ruby;
      output=AST;
    }
    a : ID INT -> ^(ID["root"] ^(ID INT)) | INT -> ^(ID["root"] INT) ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar RewriteModeWithPredicatedRewritesWalker;
    options {
      language=Ruby;
      output=AST;
      ASTLabelType=CommonTree;
      tokenVocab=RewriteModeWithPredicatedRewrites;
      rewrite=true;
    }
    s : ^(ID a) {
      # self.buf += $s.start.inspect
    };
    a : ^(ID INT) -> {true}? ^(ID["ick"] INT)
                  -> INT
      ;
  END

  inline_grammar( <<-'END' )
    grammar WildcardSingleNode;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID["root"] INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar WildcardSingleNodeWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=WildcardSingleNode;
    }
    s : ^(ID c=.) -> $c
    ;
  END

  inline_grammar( <<-'END' )
    grammar WildcardUnlabeledSingleNode;
    options {language=Ruby; output=AST;}
    a : ID INT -> ^(ID INT);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar WildcardUnlabeledSingleNodeWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardUnlabeledSingleNode;}
    s : ^(ID .) -> ID
      ;
  END

  inline_grammar( <<-'END' )
    grammar WildcardListLabel;
    options {language=Ruby; output=AST;}
    a : INT INT INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END
  
  inline_grammar( <<-'END' )
    tree grammar WildcardListLabelWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardListLabel;}
    s : (c+=.)+ -> $c+
      ;
  END
  
  inline_grammar( <<-'END' )
    grammar WildcardListLabel2;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree;}
    a  : x=INT y=INT z=INT -> ^($x ^($y $z) ^($y $z));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END
  
  inline_grammar( <<-'END' )
    tree grammar WildcardListLabel2Walker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardListLabel2; rewrite=true;}
    s : ^(INT (c+=.)+) -> $c+
      ;
  END

  inline_grammar( <<-'END' )
    grammar WildcardGrabsSubtree;
    options {language=Ruby; output=AST;}
    a : ID x=INT y=INT z=INT -> ^(ID[\"root\"] ^($x $y $z));
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END

  inline_grammar( <<-'END' )
    tree grammar WildcardGrabsSubtreeWalker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardGrabsSubtree;}
    s : ^(ID c=.) -> $c
      ;
  END
  
  inline_grammar( <<-'END' )
    grammar WildcardGrabsSubtree2;
    options {language=Ruby; output=AST;}
    a : ID x=INT y=INT z=INT -> ID ^($x $y $z);
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\n') {$channel=HIDDEN;} ;
  END
  
  inline_grammar( <<-'END' )
    tree grammar WildcardGrabsSubtree2Walker;
    options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardGrabsSubtree2;}
    s : ID c=. -> $c
      ;
  END

  inline_grammar( <<-END )
    grammar CombinedRewriteAndAuto;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT) | INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\\n') {$channel=HIDDEN;} ;
  END
  
  inline_grammar( <<-END )
    tree grammar CombinedRewriteAndAutoWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=CombinedRewriteAndAuto;
    }
    a : ^(ID INT) -> ^(INT ID) | INT;
  END

  inline_grammar( <<-END )
    grammar RewriteModeCombinedRewriteAndAuto;
    options {
        language=Ruby;
        output=AST;
    }
    a : ID INT -> ^(ID INT) | INT ;
    ID : 'a'..'z'+ ;
    INT : '0'..'9'+;
    WS : (' '|'\\n') {$channel=HIDDEN;} ;
  END
  
  inline_grammar( <<-END )
    tree grammar RewriteModeCombinedRewriteAndAutoWalker;
    options {
        language=Ruby;
        output=AST;
        ASTLabelType=CommonTree;
        tokenVocab=RewriteModeCombinedRewriteAndAuto;
        rewrite=true;
    }
    a : ^(ID INT) -> ^(ID["ick"] INT)
      | INT // leaves it alone, returning $a.start
      ;
  END
  
  example "flat list" do
    lexer  = FlatList::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = FlatList::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = FlatListWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "34 abc"
  end

  example "simple tree" do
    lexer  = SimpleTree::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = SimpleTree::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = SimpleTreeWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(34 abc)"
  end

  example "combined rewrite and auto" do
    lexer  = CombinedRewriteAndAuto::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = CombinedRewriteAndAuto::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = CombinedRewriteAndAutoWalker::TreeParser.new( nodes )
    result = walker.a.tree
    result.inspect.should == '(34 abc)'
    lexer  = CombinedRewriteAndAuto::Lexer.new( "34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = CombinedRewriteAndAuto::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = CombinedRewriteAndAutoWalker::TreeParser.new( nodes )
    result = walker.a.tree
    result.inspect.should == '34'
  end

  example "avoid dup" do
    lexer  = AvoidDup::Lexer.new( "abc" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AvoidDup::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AvoidDupWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(abc abc)"
  end
  
  example "loop" do
    lexer  = Loop::Lexer.new( "a b c 3 4 5" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = Loop::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = LoopWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "3 4 5 a b c"
  end
  
  example "auto dup" do
    lexer  = AutoDup::Lexer.new( "abc" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDup::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc"
  end

  example "auto dup rule" do
    lexer  = AutoDupRule::Lexer.new( "a 1" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupRule::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupRuleWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "a 1"
  end

  example "auto wildcard" do
    lexer  = AutoWildcard::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoWildcard::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoWildcardWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc 34"
  end

  example "auto wildcard2" do
    lexer  = AutoWildcard2::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoWildcard2::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoWildcard2Walker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(abc 34)"
  end

  example "auto wildcard with label" do
    lexer  = AutoWildcardWithLabel::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoWildcardWithLabel::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoWildcardWithLabelWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc 34"
  end

  example "auto wildcard with list label" do
    lexer  = AutoWildcardWithListLabel::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoWildcardWithListLabel::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoWildcardWithListLabelWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc 34"
  end

  example "auto dup multiple" do
    lexer  = AutoDupMultiple::Lexer.new( "a b 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupMultiple::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupMultipleWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "a b 3"
  end

  example "auto dup tree" do
    lexer  = AutoDupTree::Lexer.new( "a 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupTree::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupTreeWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(a 3)"
  end

  example "auto dup tree with labels" do
    lexer  = AutoDupTreeWithLabels::Lexer.new( "a 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupTreeWithLabels::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupTreeWithLabelsWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(a 3)"
  end

  example "auto dup tree with list labels" do
    lexer  = AutoDupTreeWithListLabels::Lexer.new( "a 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupTreeWithListLabels::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupTreeWithListLabelsWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(a 3)"
  end

  example "auto dup tree with rule root" do
    lexer  = AutoDupTreeWithRuleRoot::Lexer.new( "a 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupTreeWithRuleRoot::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupTreeWithRuleRootWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(a 3)"
  end

  example "auto dup tree with rule root and labels" do
    lexer  = AutoDupTreeWithRuleRootAndLabels::Lexer.new( "a 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupTreeWithRuleRootAndLabels::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupTreeWithRuleRootAndLabelsWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(a 3)"
  end

  example "auto dup tree with rule root and list labels" do
    lexer  = AutoDupTreeWithRuleRootAndListLabels::Lexer.new( "a 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupTreeWithRuleRootAndListLabels::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupTreeWithRuleRootAndListLabelsWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(a 3)"
  end

  example "auto dup nested tree" do
    lexer  = AutoDupNestedTree::Lexer.new( "a b 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = AutoDupNestedTree::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = AutoDupNestedTreeWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(a (b 3))"
  end

  example "delete" do
    lexer  = Delete::Lexer.new( "abc" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = Delete::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = DeleteWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == ""
  end

  example "set match no rewrite" do
    lexer  = SetMatchNoRewrite::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = SetMatchNoRewrite::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = SetMatchNoRewriteWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc 34"
  end

  example "set optional match no rewrite" do
    lexer  = SetOptionalMatchNoRewrite::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = SetOptionalMatchNoRewrite::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = SetOptionalMatchNoRewriteWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc 34"
  end

  example "set match no rewrite level2" do
    lexer  = SetMatchNoRewriteLevel2::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = SetMatchNoRewriteLevel2::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = SetMatchNoRewriteLevel2Walker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(abc 34)"
  end

  example "set match no rewrite level2 root" do
    lexer  = SetMatchNoRewriteLevel2Root::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = SetMatchNoRewriteLevel2Root::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = SetMatchNoRewriteLevel2RootWalker::TreeParser.new( nodes )
    result = walker.a
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(abc 34)"
  end

  example "rewrite mode combined rewrite and auto" do
    
    parser_test = proc do |input, expected_output|
      lexer = RewriteModeCombinedRewriteAndAuto::Lexer.new( input )
      tokens = ANTLR3::CommonTokenStream.new( lexer )
      parser = RewriteModeCombinedRewriteAndAuto::Parser.new( tokens )
      result = parser.a
      nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
      nodes.token_stream = tokens
      walker = RewriteModeCombinedRewriteAndAutoWalker::TreeParser.new( nodes )
      result = walker.a
      stree = result.tree.nil? ? '' : result.tree.inspect
      stree.should == expected_output
    end
    
    parser_test[ 'abc 34', '(ick 34)' ]
    parser_test[ '34', '34' ]
  end
  
  example "rewrite mode flat tree" do
    lexer  = RewriteModeFlatTree::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeFlatTree::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeFlatTreeWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc 1"
  end
  
  example "rewrite mode chain rule flat tree" do
    lexer  = RewriteModeChainRuleFlatTree::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeChainRuleFlatTree::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeChainRuleFlatTreeWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "34 abc"
  end

  example "rewrite mode chain rule tree" do
    lexer  = RewriteModeChainRuleTree::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeChainRuleTree::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeChainRuleTreeWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "34"
  end

  example "rewrite mode chain rule tree2" do
    lexer  = RewriteModeChainRuleTree2::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeChainRuleTree2::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeChainRuleTree2Walker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "34"
  end

  example "rewrite mode chain rule tree3" do
    lexer  = RewriteModeChainRuleTree3::Lexer.new( "boo abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeChainRuleTree3::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeChainRuleTree3Walker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "boo 34"
  end

  example "rewrite mode chain rule tree4" do
    lexer  = RewriteModeChainRuleTree4::Lexer.new( "boo abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeChainRuleTree4::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeChainRuleTree4Walker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(boo 34)"
  end

  example "rewrite mode chain rule tree5" do
    lexer  = RewriteModeChainRuleTree5::Lexer.new( "boo abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeChainRuleTree5::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeChainRuleTree5Walker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(boo 34)"
  end

  example "rewrite of rule ref" do
    lexer  = RewriteOfRuleRef::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteOfRuleRef::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteOfRuleRefWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc 34"
  end

  example "rewrite of rule ref root" do
    lexer  = RewriteOfRuleRefRoot::Lexer.new( "abc 12 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteOfRuleRefRoot::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteOfRuleRefRootWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(12 (abc 34))"
  end

  example "rewrite of rule ref root labeled" do
    lexer  = RewriteOfRuleRefRootLabeled::Lexer.new( "abc 12 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteOfRuleRefRootLabeled::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteOfRuleRefRootLabeledWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(12 (abc 34))"
  end

  example "rewrite of rule ref root list labeled" do
    lexer  = RewriteOfRuleRefRootListLabeled::Lexer.new( "abc 12 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteOfRuleRefRootListLabeled::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteOfRuleRefRootListLabeledWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(12 (abc 34))"
  end

  example "rewrite of rule ref child" do
    lexer  = RewriteOfRuleRefChild::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteOfRuleRefChild::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteOfRuleRefChildWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(34 34)"
  end

  example "rewrite of rule ref label" do
    lexer  = RewriteOfRuleRefLabel::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteOfRuleRefLabel::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteOfRuleRefLabelWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(34 34)"
  end

  example "rewrite of rule ref list label" do
    lexer  = RewriteOfRuleRefListLabel::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteOfRuleRefListLabel::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteOfRuleRefListLabelWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(34 34)"
  end
  
  example "rewrite mode with predicated rewrites" do
    lexer  = RewriteModeWithPredicatedRewrites::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = RewriteModeWithPredicatedRewrites::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = RewriteModeWithPredicatedRewritesWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(root (ick 34))"
  end
  
  example "wildcard single node" do
    lexer  = WildcardSingleNode::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = WildcardSingleNode::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = WildcardSingleNodeWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "34"
  end
  
  example "wildcard unlabeled single node" do
    lexer  = WildcardUnlabeledSingleNode::Lexer.new( "abc 34" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = WildcardUnlabeledSingleNode::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = WildcardUnlabeledSingleNodeWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "abc"
  end

  example "wildcard grabs subtree" do
    lexer  = WildcardGrabsSubtree::Lexer.new( "abc 1 2 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = WildcardGrabsSubtree::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = WildcardGrabsSubtreeWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(1 2 3)"
  end

  example "wildcard grabs subtree2" do
    lexer  = WildcardGrabsSubtree2::Lexer.new( "abc 1 2 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = WildcardGrabsSubtree2::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = WildcardGrabsSubtree2Walker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(1 2 3)"
  end

  example "wildcard list label" do
    lexer  = WildcardListLabel::Lexer.new( "1 2 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = WildcardListLabel::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = WildcardListLabelWalker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "1 2 3"
  end
  
  example "wildcard list label2" do
    lexer  = WildcardListLabel2::Lexer.new( "1 2 3" )
    tokens = ANTLR3::CommonTokenStream.new( lexer )
    parser = WildcardListLabel2::Parser.new( tokens )
    
    result = parser.a
    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
    nodes.token_stream = tokens
    walker = WildcardListLabel2Walker::TreeParser.new( nodes )
    result = walker.s
    stree = result.tree.nil? ? '' : result.tree.inspect
    stree.should == "(2 3) (2 3)"
  end
  
end