import unittest
import textwrap
import antlr3
import antlr3.tree
import testbase
import sys

class TestRewriteAST(testbase.ANTLRTest):
    def parserClass(self, base):
        class TParser(base):
            def __init__(self, *args, **kwargs):
                base.__init__(self, *args, **kwargs)

                self._errors = []
                self._output = ""


            def capture(self, t):
                self._output += t


            def traceIn(self, ruleName, ruleIndex):
                self.traces.append('>'+ruleName)


            def traceOut(self, ruleName, ruleIndex):
                self.traces.append('<'+ruleName)


            def emitErrorMessage(self, msg):
                self._errors.append(msg)


        return TParser


    def lexerClass(self, base):
        class TLexer(base):
            def __init__(self, *args, **kwargs):
                base.__init__(self, *args, **kwargs)

                self._output = ""


            def capture(self, t):
                self._output += t


            def traceIn(self, ruleName, ruleIndex):
                self.traces.append('>'+ruleName)


            def traceOut(self, ruleName, ruleIndex):
                self.traces.append('<'+ruleName)


            def recover(self, input, re):
                # no error recovery yet, just crash!
                raise

        return TLexer


    def execParser(self, grammar, grammarEntry, input, expectErrors=False):
        lexerCls, parserCls = self.compileInlineGrammar(grammar)

        cStream = antlr3.StringStream(input)
        lexer = lexerCls(cStream)
        tStream = antlr3.CommonTokenStream(lexer)
        parser = parserCls(tStream)
        r = getattr(parser, grammarEntry)()

        if not expectErrors:
            self.assertEquals(len(parser._errors), 0, parser._errors)

        result = ""

        if r is not None:
            if hasattr(r, 'result'):
                result += r.result

            if r.tree is not None:
                result += r.tree.toStringTree()

        if not expectErrors:
            return result

        else:
            return result, parser._errors


    def execTreeParser(self, grammar, grammarEntry, treeGrammar, treeEntry, input):
        lexerCls, parserCls = self.compileInlineGrammar(grammar)
        walkerCls = self.compileInlineGrammar(treeGrammar)

        cStream = antlr3.StringStream(input)
        lexer = lexerCls(cStream)
        tStream = antlr3.CommonTokenStream(lexer)
        parser = parserCls(tStream)
        r = getattr(parser, grammarEntry)()
        nodes = antlr3.tree.CommonTreeNodeStream(r.tree)
        nodes.setTokenStream(tStream)
        walker = walkerCls(nodes)
        r = getattr(walker, treeEntry)()

        if r is not None:
            return r.tree.toStringTree()

        return ""


    def testDelete(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT -> ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc 34")
        self.assertEquals("", found)


    def testSingleToken(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID -> ID;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("abc", found)


    def testSingleTokenToNewNode(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID -> ID["x"];
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("x", found)


    def testSingleTokenToNewNodeRoot(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID -> ^(ID["x"] INT);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("(x INT)", found)


    def testSingleTokenToNewNode2(self):
        # Allow creation of new nodes w/o args.
        grammar = textwrap.dedent(
            r'''
            grammar TT;
            options {language=Python;output=AST;}
            a : ID -> ID[ ];
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("ID", found)


    def testSingleCharLiteral(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'c' -> 'c';
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "c")
        self.assertEquals("c", found)


    def testSingleStringLiteral(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'ick' -> 'ick';
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "ick")
        self.assertEquals("ick", found)


    def testSingleRule(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : b -> b;
            b : ID ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("abc", found)


    def testReorderTokens(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT -> INT ID;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc 34")
        self.assertEquals("34 abc", found)


    def testReorderTokenAndRule(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : b INT -> INT b;
            b : ID ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc 34")
        self.assertEquals("34 abc", found)


    def testTokenTree(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT -> ^(INT ID);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc 34")
        self.assertEquals("(34 abc)", found)


    def testTokenTreeAfterOtherStuff(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'void' ID INT -> 'void' ^(INT ID);
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "void abc 34")
        self.assertEquals("void (34 abc)", found)


    def testNestedTokenTreeWithOuterLoop(self):
        # verify that ID and INT both iterate over outer index variable
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {DUH;}
            a : ID INT ID INT -> ^( DUH ID ^( DUH INT) )+ ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a 1 b 2")
        self.assertEquals("(DUH a (DUH 1)) (DUH b (DUH 2))", found)


    def testOptionalSingleToken(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID -> ID? ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("abc", found)


    def testClosureSingleToken(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID ID -> ID* ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testPositiveClosureSingleToken(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID ID -> ID+ ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testOptionalSingleRule(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : b -> b?;
            b : ID ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("abc", found)


    def testClosureSingleRule(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : b b -> b*;
            b : ID ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testClosureOfLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : x+=b x+=b -> $x*;
            b : ID ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testOptionalLabelNoListLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : (x=ID)? -> $x?;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a")
        self.assertEquals("a", found)


    def testPositiveClosureSingleRule(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : b b -> b+;
            b : ID ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testSinglePredicateT(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID -> {True}? ID -> ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("abc", found)


    def testSinglePredicateF(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID -> {False}? ID -> ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc")
        self.assertEquals("", found)


    def testMultiplePredicate(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT -> {False}? ID
                       -> {True}? INT
                       ->
              ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a 2")
        self.assertEquals("2", found)


    def testMultiplePredicateTrees(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID INT -> {False}? ^(ID INT)
                       -> {True}? ^(INT ID)
                       -> ID
              ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a 2")
        self.assertEquals("(2 a)", found)


    def testSimpleTree(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : op INT -> ^(op INT);
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "-34")
        self.assertEquals("(- 34)", found)


    def testSimpleTree2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : op INT -> ^(INT op);
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "+ 34")
        self.assertEquals("(34 +)", found)



    def testNestedTrees(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'var' (ID ':' type ';')+ -> ^('var' ^(':' ID type)+) ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "var a:int; b:float;")
        self.assertEquals("(var (: a int) (: b float))", found)


    def testImaginaryTokenCopy(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {VAR;}
            a : ID (',' ID)*-> ^(VAR ID)+ ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a,b,c")
        self.assertEquals("(VAR a) (VAR b) (VAR c)", found)


    def testTokenUnreferencedOnLeftButDefined(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {VAR;}
            a : b -> ID ;
            b : ID ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a")
        self.assertEquals("ID", found)


    def testImaginaryTokenCopySetText(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {VAR;}
            a : ID (',' ID)*-> ^(VAR["var"] ID)+ ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a,b,c")
        self.assertEquals("(var a) (var b) (var c)", found)


    def testImaginaryTokenNoCopyFromToken(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "{a b c}")
        self.assertEquals("({ a b c)", found)


    def testImaginaryTokenNoCopyFromTokenSetText(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : lc='{' ID+ '}' -> ^(BLOCK[$lc,"block"] ID+) ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "{a b c}")
        self.assertEquals("(block a b c)", found)


    def testMixedRewriteAndAutoAST(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : b b^ ; // 2nd b matches only an INT; can make it root
            b : ID INT -> INT ID
              | INT
              ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a 1 2")
        self.assertEquals("(2 1 a)", found)


    def testSubruleWithRewrite(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : b b ;
            b : (ID INT -> INT ID | INT INT -> INT+ )
              ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a 1 2 3")
        self.assertEquals("1 a 2 3", found)


    def testSubruleWithRewrite2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {TYPE;}
            a : b b ;
            b : 'int'
                ( ID -> ^(TYPE 'int' ID)
                | ID '=' INT -> ^(TYPE 'int' ID INT)
                )
                ';'
              ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "int a; int b=3;")
        self.assertEquals("(TYPE int a) (TYPE int b 3)", found)


    def testNestedRewriteShutsOffAutoAST(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : b b ;
            b : ID ( ID (last=ID -> $last)+ ) ';' // get last ID
              | INT // should still get auto AST construction
              ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b c d; 42")
        self.assertEquals("d 42", found)


    def testRewriteActions(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : atom -> ^({self.adaptor.create(INT,"9")} atom) ;
            atom : INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "3")
        self.assertEquals("(9 3)", found)


    def testRewriteActions2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : atom -> {self.adaptor.create(INT,"9")} atom ;
            atom : INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "3")
        self.assertEquals("9 3", found)


    def testRefToOldValue(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : (atom -> atom) (op='+' r=atom -> ^($op $a $r) )* ;
            atom : INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "3+4+5")
        self.assertEquals("(+ (+ 3 4) 5)", found)


    def testCopySemanticsForRules(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : atom -> ^(atom atom) ; // NOT CYCLE! (dup atom)
            atom : INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "3")
        self.assertEquals("(3 3)", found)


    def testCopySemanticsForRules2(self):
        # copy type as a root for each invocation of (...)+ in rewrite
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : type ID (',' ID)* ';' -> ^(type ID)+ ;
            type : 'int' ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "int a,b,c;")
        self.assertEquals("(int a) (int b) (int c)", found)


    def testCopySemanticsForRules3(self):
        # copy type *and* modifier even though it's optional
        # for each invocation of (...)+ in rewrite
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : modifier? type ID (',' ID)* ';' -> ^(type modifier? ID)+ ;
            type : 'int' ;
            modifier : 'public' ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "public int a,b,c;")
        self.assertEquals("(int public a) (int public b) (int public c)", found)


    def testCopySemanticsForRules3Double(self):
        # copy type *and* modifier even though it's optional
        # for each invocation of (...)+ in rewrite
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : modifier? type ID (',' ID)* ';' -> ^(type modifier? ID)+ ^(type modifier? ID)+ ;
            type : 'int' ;
            modifier : 'public' ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "public int a,b,c;")
        self.assertEquals("(int public a) (int public b) (int public c) (int public a) (int public b) (int public c)", found)


    def testCopySemanticsForRules4(self):
        # copy type *and* modifier even though it's optional
        # for each invocation of (...)+ in rewrite
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {MOD;}
            a : modifier? type ID (',' ID)* ';' -> ^(type ^(MOD modifier)? ID)+ ;
            type : 'int' ;
            modifier : 'public' ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "public int a,b,c;")
        self.assertEquals("(int (MOD public) a) (int (MOD public) b) (int (MOD public) c)", found)


    def testCopySemanticsLists(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {MOD;}
            a : ID (',' ID)* ';' -> ID+ ID+ ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a,b,c;")
        self.assertEquals("a b c a b c", found)


    def testCopyRuleLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x=b -> $x $x;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a")
        self.assertEquals("a a", found)


    def testCopyRuleLabel2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x=b -> ^($x $x);
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a")
        self.assertEquals("(a a)", found)


    def testQueueingOfTokens(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'int' ID (',' ID)* ';' -> ^('int' ID+) ;
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "int a,b,c;")
        self.assertEquals("(int a b c)", found)


    def testCopyOfTokens(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'int' ID ';' -> 'int' ID 'int' ID ;
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "int a;")
        self.assertEquals("int a int a", found)


    def testTokenCopyInLoop(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'int' ID (',' ID)* ';' -> ^('int' ID)+ ;
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "int a,b,c;")
        self.assertEquals("(int a) (int b) (int c)", found)


    def testTokenCopyInLoopAgainstTwoOthers(self):
        # must smear 'int' copies across as root of multiple trees
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : 'int' ID ':' INT (',' ID ':' INT)* ';' -> ^('int' ID INT)+ ;
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "int a:1,b:2,c:3;")
        self.assertEquals("(int a 1) (int b 2) (int c 3)", found)


    def testListRefdOneAtATime(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID+ -> ID ID ID ; // works if 3 input IDs
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b c")
        self.assertEquals("a b c", found)


    def testSplitListWithLabels(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {VAR;}
            a : first=ID others+=ID* -> $first VAR $others+ ;
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b c")
        self.assertEquals("a VAR b c", found)


    def testComplicatedMelange(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : A A b=B B b=B c+=C C c+=C D {s=$D.text} -> A+ B+ C+ D ;
            type : 'int' | 'float' ;
            A : 'a' ;
            B : 'b' ;
            C : 'c' ;
            D : 'd' ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a a b b b c c c d")
        self.assertEquals("a a b b b c c c d", found)


    def testRuleLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x=b -> $x;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a")
        self.assertEquals("a", found)


    def testAmbiguousRule(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID a -> a | INT ;
            ID : 'a'..'z'+ ;
            INT: '0'..'9'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar,
				    "a", "abc 34")
        self.assertEquals("34", found)


    def testRuleListLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x+=b x+=b -> $x+;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testRuleListLabel2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x+=b x+=b -> $x $x*;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testOptional(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x=b (y=b)? -> $x $y?;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a")
        self.assertEquals("a", found)


    def testOptional2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x=ID (y=b)? -> $x $y?;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testOptional3(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x=ID (y=b)? -> ($x $y)?;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testOptional4(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x+=ID (y=b)? -> ($x $y)?;
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("a b", found)


    def testOptional5(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : ID -> ID? ; // match an ID to optional ID
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a")
        self.assertEquals("a", found)


    def testArbitraryExprType(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : x+=b x+=b -> {CommonTree(None)};
            b : ID ;
            ID : 'a'..'z'+ ;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "a b")
        self.assertEquals("", found)


    def testSet(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a: (INT|ID)+ -> INT+ ID+ ;
            INT: '0'..'9'+;
            ID : 'a'..'z'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "2 a 34 de")
        self.assertEquals("2 34 a de", found)


    def testSet2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a: (INT|ID) -> INT? ID? ;
            INT: '0'..'9'+;
            ID : 'a'..'z'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "2")
        self.assertEquals("2", found)


    @testbase.broken("http://www.antlr.org:8888/browse/ANTLR-162",
                     antlr3.tree.RewriteEmptyStreamException)
    def testSetWithLabel(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : x=(INT|ID) -> $x ;
            INT: '0'..'9'+;
            ID : 'a'..'z'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "2")
        self.assertEquals("2", found)


    def testRewriteAction(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens { FLOAT; }
            r
                : INT -> {CommonTree(CommonToken(type=FLOAT, text=$INT.text+".0"))}
                ;
            INT : '0'..'9'+;
            WS: (' ' | '\n' | '\t')+ {$channel = HIDDEN;};
            ''')

        found = self.execParser(grammar, "r", "25")
        self.assertEquals("25.0", found)


    def testOptionalSubruleWithoutRealElements(self):
        # copy type *and* modifier even though it's optional
        # for each invocation of (...)+ in rewrite
        grammar = textwrap.dedent(
            r"""
            grammar T;
            options {language=Python;output=AST;}
            tokens {PARMS;}

            modulo
             : 'modulo' ID ('(' parms+ ')')? -> ^('modulo' ID ^(PARMS parms+)?)
             ;
            parms : '#'|ID;
            ID : ('a'..'z' | 'A'..'Z')+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            """)

        found = self.execParser(grammar, "modulo", "modulo abc (x y #)")
        self.assertEquals("(modulo abc (PARMS x y #))", found)


    ## C A R D I N A L I T Y  I S S U E S

    def testCardinality(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            tokens {BLOCK;}
            a : ID ID INT INT INT -> (ID INT)+;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        try:
            self.execParser(grammar, "a", "a b 3 4 5")
            self.fail()
        except antlr3.tree.RewriteCardinalityException:
            pass


    def testCardinality2(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID+ -> ID ID ID ; // only 2 input IDs
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        try:
            self.execParser(grammar, "a", "a b")
            self.fail()
        except antlr3.tree.RewriteCardinalityException:
            pass


    def testCardinality3(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID? INT -> ID INT ;
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        try:
            self.execParser(grammar, "a", "3")
            self.fail()
        except antlr3.tree.RewriteEmptyStreamException:
            pass


    def testLoopCardinality(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID? INT -> ID+ INT ;
            op : '+'|'-' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        try:
            self.execParser(grammar, "a", "3")
            self.fail()
        except antlr3.tree.RewriteEarlyExitException:
            pass


    def testWildcard(self):
        grammar = textwrap.dedent(
            r'''
            grammar T;
            options {language=Python;output=AST;}
            a : ID c=. -> $c;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found = self.execParser(grammar, "a", "abc 34")
        self.assertEquals("34", found)


    # E R R O R S

    def testExtraTokenInSimpleDecl(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            tokens {EXPR;}
            decl : type ID '=' INT ';' -> ^(EXPR type ID INT) ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "decl", "int 34 x=1;",
                                        expectErrors=True)
        self.assertEquals(["line 1:4 extraneous input u'34' expecting ID"],
                          errors)
        self.assertEquals("(EXPR int x 1)", found) # tree gets correct x and 1 tokens


    #@testbase.broken("FIXME", AssertionError)
    def testMissingIDInSimpleDecl(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            tokens {EXPR;}
            decl : type ID '=' INT ';' -> ^(EXPR type ID INT) ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "decl", "int =1;",
                                        expectErrors=True)
        self.assertEquals(["line 1:4 missing ID at u'='"], errors)
        self.assertEquals("(EXPR int <missing ID> 1)", found) # tree gets invented ID token


    def testMissingSetInSimpleDecl(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            tokens {EXPR;}
            decl : type ID '=' INT ';' -> ^(EXPR type ID INT) ;
            type : 'int' | 'float' ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "decl", "x=1;",
                                        expectErrors=True)
        self.assertEquals(["line 1:0 mismatched input u'x' expecting set None"],
                          errors);
        self.assertEquals("(EXPR <error: x> x 1)", found) # tree gets invented ID token


    def testMissingTokenGivesErrorNode(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            a : ID INT -> ID INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "a", "abc",
                                        expectErrors=True)
        self.assertEquals(["line 1:3 missing INT at '<EOF>'"], errors)
        # doesn't do in-line recovery for sets (yet?)
        self.assertEquals("abc <missing INT>", found)


    def testExtraTokenGivesErrorNode(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            a : b c -> b c;
            b : ID -> ID ;
            c : INT -> INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "a", "abc ick 34",
                                        expectErrors=True)
        self.assertEquals(["line 1:4 extraneous input u'ick' expecting INT"],
                          errors)
        self.assertEquals("abc 34", found)


    #@testbase.broken("FIXME", AssertionError)
    def testMissingFirstTokenGivesErrorNode(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            a : ID INT -> ID INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "a", "34", expectErrors=True)
        self.assertEquals(["line 1:0 missing ID at u'34'"], errors)
        self.assertEquals("<missing ID> 34", found)


    #@testbase.broken("FIXME", AssertionError)
    def testMissingFirstTokenGivesErrorNode2(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            a : b c -> b c;
            b : ID -> ID ;
            c : INT -> INT ;
            ID : 'a'..'z'+ ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "a", "34", expectErrors=True)
        # finds an error at the first token, 34, and re-syncs.
        # re-synchronizing does not consume a token because 34 follows
        # ref to rule b (start of c). It then matches 34 in c.
        self.assertEquals(["line 1:0 missing ID at u'34'"], errors)
        self.assertEquals("<missing ID> 34", found)


    def testNoViableAltGivesErrorNode(self):
        grammar = textwrap.dedent(
            r'''
            grammar foo;
            options {language=Python;output=AST;}
            a : b -> b | c -> c;
            b : ID -> ID ;
            c : INT -> INT ;
            ID : 'a'..'z'+ ;
            S : '*' ;
            INT : '0'..'9'+;
            WS : (' '|'\n') {$channel=HIDDEN;} ;
            ''')

        found, errors = self.execParser(grammar, "a", "*", expectErrors=True)
        # finds an error at the first token, 34, and re-syncs.
        # re-synchronizing does not consume a token because 34 follows
        # ref to rule b (start of c). It then matches 34 in c.
        self.assertEquals(["line 1:0 no viable alternative at input u'*'"],
                          errors);
        self.assertEquals("<unexpected: [@0,0:0=u'*',<6>,1:0], resync=*>",
                          found)


if __name__ == '__main__':
    unittest.main()