| import unittest |
| import textwrap |
| import antlr3 |
| import testbase |
| |
| class t042ast(testbase.ANTLRTest): |
| ## def lexerClass(self, base): |
| ## class TLexer(base): |
| ## def reportError(self, re): |
| ## # no error recovery yet, just crash! |
| ## raise re |
| |
| ## return TLexer |
| |
| |
| def parserClass(self, base): |
| class TParser(base): |
| def recover(self, input, re): |
| # no error recovery yet, just crash! |
| raise |
| |
| return TParser |
| |
| |
| def parse(self, text, method, rArgs=(), **kwargs): |
| self.compileGrammar() #options='-trace') |
| |
| cStream = antlr3.StringStream(text) |
| self.lexer = self.getLexer(cStream) |
| tStream = antlr3.CommonTokenStream(self.lexer) |
| self.parser = self.getParser(tStream) |
| |
| for attr, val in kwargs.items(): |
| setattr(self.parser, attr, val) |
| |
| return getattr(self.parser, method)(*rArgs) |
| |
| |
| def testR1(self): |
| r = self.parse("1 + 2", 'r1') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(+ 1 2)' |
| ) |
| |
| |
| def testR2a(self): |
| r = self.parse("assert 2+3;", 'r2') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(assert (+ 2 3))' |
| ) |
| |
| |
| def testR2b(self): |
| r = self.parse("assert 2+3 : 5;", 'r2') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(assert (+ 2 3) 5)' |
| ) |
| |
| |
| def testR3a(self): |
| r = self.parse("if 1 fooze", 'r3') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(if 1 fooze)' |
| ) |
| |
| |
| def testR3b(self): |
| r = self.parse("if 1 fooze else fooze", 'r3') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(if 1 fooze fooze)' |
| ) |
| |
| |
| def testR4a(self): |
| r = self.parse("while 2 fooze", 'r4') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(while 2 fooze)' |
| ) |
| |
| |
| def testR5a(self): |
| r = self.parse("return;", 'r5') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'return' |
| ) |
| |
| |
| def testR5b(self): |
| r = self.parse("return 2+3;", 'r5') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(return (+ 2 3))' |
| ) |
| |
| |
| def testR6a(self): |
| r = self.parse("3", 'r6') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '3' |
| ) |
| |
| |
| def testR6b(self): |
| r = self.parse("3 a", 'r6') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '3 a' |
| ) |
| |
| |
| def testR7(self): |
| r = self.parse("3", 'r7') |
| self.assertIsNone(r.tree) |
| |
| |
| def testR8(self): |
| r = self.parse("var foo:bool", 'r8') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(var bool foo)' |
| ) |
| |
| |
| def testR9(self): |
| r = self.parse("int foo;", 'r9') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(VARDEF int foo)' |
| ) |
| |
| |
| def testR10(self): |
| r = self.parse("10", 'r10') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '10.0' |
| ) |
| |
| |
| def testR11a(self): |
| r = self.parse("1+2", 'r11') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(EXPR (+ 1 2))' |
| ) |
| |
| |
| def testR11b(self): |
| r = self.parse("", 'r11') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'EXPR' |
| ) |
| |
| |
| def testR12a(self): |
| r = self.parse("foo", 'r12') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'foo' |
| ) |
| |
| |
| def testR12b(self): |
| r = self.parse("foo, bar, gnurz", 'r12') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'foo bar gnurz' |
| ) |
| |
| |
| def testR13a(self): |
| r = self.parse("int foo;", 'r13') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(int foo)' |
| ) |
| |
| |
| def testR13b(self): |
| r = self.parse("bool foo, bar, gnurz;", 'r13') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(bool foo bar gnurz)' |
| ) |
| |
| |
| def testR14a(self): |
| r = self.parse("1+2 int", 'r14') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(EXPR (+ 1 2) int)' |
| ) |
| |
| |
| def testR14b(self): |
| r = self.parse("1+2 int bool", 'r14') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(EXPR (+ 1 2) int bool)' |
| ) |
| |
| |
| def testR14c(self): |
| r = self.parse("int bool", 'r14') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(EXPR int bool)' |
| ) |
| |
| |
| def testR14d(self): |
| r = self.parse("fooze fooze int bool", 'r14') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(EXPR fooze fooze int bool)' |
| ) |
| |
| |
| def testR14e(self): |
| r = self.parse("7+9 fooze fooze int bool", 'r14') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(EXPR (+ 7 9) fooze fooze int bool)' |
| ) |
| |
| |
| def testR15(self): |
| r = self.parse("7", 'r15') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '7 7' |
| ) |
| |
| |
| def testR16a(self): |
| r = self.parse("int foo", 'r16') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(int foo)' |
| ) |
| |
| |
| def testR16b(self): |
| r = self.parse("int foo, bar, gnurz", 'r16') |
| |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(int foo) (int bar) (int gnurz)' |
| ) |
| |
| |
| def testR17a(self): |
| r = self.parse("for ( fooze ; 1 + 2 ; fooze ) fooze", 'r17') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(for fooze (+ 1 2) fooze fooze)' |
| ) |
| |
| |
| def testR18a(self): |
| r = self.parse("for", 'r18') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'BLOCK' |
| ) |
| |
| |
| def testR19a(self): |
| r = self.parse("for", 'r19') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'for' |
| ) |
| |
| |
| def testR20a(self): |
| r = self.parse("for", 'r20') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'FOR' |
| ) |
| |
| |
| def testR21a(self): |
| r = self.parse("for", 'r21') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'BLOCK' |
| ) |
| |
| |
| def testR22a(self): |
| r = self.parse("for", 'r22') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'for' |
| ) |
| |
| |
| def testR23a(self): |
| r = self.parse("for", 'r23') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'FOR' |
| ) |
| |
| |
| def testR24a(self): |
| r = self.parse("fooze 1 + 2", 'r24') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(fooze (+ 1 2))' |
| ) |
| |
| |
| def testR25a(self): |
| r = self.parse("fooze, fooze2 1 + 2", 'r25') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(fooze (+ 1 2))' |
| ) |
| |
| |
| def testR26a(self): |
| r = self.parse("fooze, fooze2", 'r26') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(BLOCK fooze fooze2)' |
| ) |
| |
| |
| def testR27a(self): |
| r = self.parse("fooze 1 + 2", 'r27') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(fooze (fooze (+ 1 2)))' |
| ) |
| |
| |
| def testR28(self): |
| r = self.parse("foo28a", 'r28') |
| self.assertIsNone(r.tree) |
| |
| |
| def testR29(self): |
| self.assertRaises(RuntimeError, self.parse, "", 'r29') |
| |
| |
| # FIXME: broken upstream? |
| ## def testR30(self): |
| ## try: |
| ## r = self.parse("fooze fooze", 'r30') |
| ## self.fail(r.tree.toStringTree()) |
| ## except RuntimeError: |
| ## pass |
| |
| |
| def testR31a(self): |
| r = self.parse("public int gnurz = 1 + 2;", 'r31', flag=0) |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(VARDEF gnurz public int (+ 1 2))' |
| ) |
| |
| |
| def testR31b(self): |
| r = self.parse("public int gnurz = 1 + 2;", 'r31', flag=1) |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(VARIABLE gnurz public int (+ 1 2))' |
| ) |
| |
| |
| def testR31c(self): |
| r = self.parse("public int gnurz = 1 + 2;", 'r31', flag=2) |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(FIELD gnurz public int (+ 1 2))' |
| ) |
| |
| |
| def testR32a(self): |
| r = self.parse("gnurz 32", 'r32', [1], flag=2) |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'gnurz' |
| ) |
| |
| |
| def testR32b(self): |
| r = self.parse("gnurz 32", 'r32', [2], flag=2) |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '32' |
| ) |
| |
| |
| def testR32c(self): |
| r = self.parse("gnurz 32", 'r32', [3], flag=2) |
| self.assertIsNone(r.tree) |
| |
| |
| def testR33a(self): |
| r = self.parse("public private fooze", 'r33') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'fooze' |
| ) |
| |
| |
| def testR34a(self): |
| r = self.parse("public class gnurz { fooze fooze2 }", 'r34') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(class gnurz public fooze fooze2)' |
| ) |
| |
| |
| def testR34b(self): |
| r = self.parse("public class gnurz extends bool implements int, bool { fooze fooze2 }", 'r34') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(class gnurz public (extends bool) (implements int bool) fooze fooze2)' |
| ) |
| |
| |
| def testR35(self): |
| self.assertRaises(RuntimeError, self.parse, "{ extends }", 'r35') |
| |
| |
| def testR36a(self): |
| r = self.parse("if ( 1 + 2 ) fooze", 'r36') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(if (EXPR (+ 1 2)) fooze)' |
| ) |
| |
| |
| def testR36b(self): |
| r = self.parse("if ( 1 + 2 ) fooze else fooze2", 'r36') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(if (EXPR (+ 1 2)) fooze fooze2)' |
| ) |
| |
| |
| def testR37(self): |
| r = self.parse("1 + 2 + 3", 'r37') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(+ (+ 1 2) 3)' |
| ) |
| |
| |
| def testR38(self): |
| r = self.parse("1 + 2 + 3", 'r38') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(+ (+ 1 2) 3)' |
| ) |
| |
| |
| def testR39a(self): |
| r = self.parse("gnurz[1]", 'r39') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(INDEX gnurz 1)' |
| ) |
| |
| |
| def testR39b(self): |
| r = self.parse("gnurz(2)", 'r39') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(CALL gnurz 2)' |
| ) |
| |
| |
| def testR39c(self): |
| r = self.parse("gnurz.gnarz", 'r39') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(FIELDACCESS gnurz gnarz)' |
| ) |
| |
| |
| def testR39d(self): |
| r = self.parse("gnurz.gnarz.gnorz", 'r39') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(FIELDACCESS (FIELDACCESS gnurz gnarz) gnorz)' |
| ) |
| |
| |
| def testR40(self): |
| r = self.parse("1 + 2 + 3;", 'r40') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(+ 1 2 3)' |
| ) |
| |
| |
| def testR41(self): |
| r = self.parse("1 + 2 + 3;", 'r41') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(3 (2 1))' |
| ) |
| |
| |
| def testR42(self): |
| r = self.parse("gnurz, gnarz, gnorz", 'r42') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'gnurz gnarz gnorz' |
| ) |
| |
| |
| def testR43(self): |
| r = self.parse("gnurz, gnarz, gnorz", 'r43') |
| self.assertIsNone(r.tree) |
| self.assertEqual( |
| r.res, |
| ['gnurz', 'gnarz', 'gnorz'] |
| ) |
| |
| |
| def testR44(self): |
| r = self.parse("gnurz, gnarz, gnorz", 'r44') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(gnorz (gnarz gnurz))' |
| ) |
| |
| |
| def testR45(self): |
| r = self.parse("gnurz", 'r45') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'gnurz' |
| ) |
| |
| |
| def testR46(self): |
| r = self.parse("gnurz, gnarz, gnorz", 'r46') |
| self.assertIsNone(r.tree) |
| self.assertEqual( |
| r.res, |
| ['gnurz', 'gnarz', 'gnorz'] |
| ) |
| |
| |
| def testR47(self): |
| r = self.parse("gnurz, gnarz, gnorz", 'r47') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'gnurz gnarz gnorz' |
| ) |
| |
| |
| def testR48(self): |
| r = self.parse("gnurz, gnarz, gnorz", 'r48') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'gnurz gnarz gnorz' |
| ) |
| |
| |
| def testR49(self): |
| r = self.parse("gnurz gnorz", 'r49') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(gnurz gnorz)' |
| ) |
| |
| |
| def testR50(self): |
| r = self.parse("gnurz", 'r50') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(1.0 gnurz)' |
| ) |
| |
| |
| def testR51(self): |
| r = self.parse("gnurza gnurzb gnurzc", 'r51') |
| self.assertEqual( |
| r.res.toStringTree(), |
| 'gnurzb' |
| ) |
| |
| |
| def testR52(self): |
| r = self.parse("gnurz", 'r52') |
| self.assertEqual( |
| r.res.toStringTree(), |
| 'gnurz' |
| ) |
| |
| |
| def testR53(self): |
| r = self.parse("gnurz", 'r53') |
| self.assertEqual( |
| r.res.toStringTree(), |
| 'gnurz' |
| ) |
| |
| |
| def testR54(self): |
| r = self.parse("gnurza 1 + 2 gnurzb", 'r54') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(+ 1 2)' |
| ) |
| |
| |
| def testR55a(self): |
| r = self.parse("public private 1 + 2", 'r55') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'public private (+ 1 2)' |
| ) |
| |
| |
| def testR55b(self): |
| r = self.parse("public fooze", 'r55') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'public fooze' |
| ) |
| |
| |
| def testR56(self): |
| r = self.parse("a b c d", 'r56') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'foo' |
| ) |
| |
| |
| def testR57(self): |
| r = self.parse("a b c d", 'r57') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| 'foo' |
| ) |
| |
| |
| def testR59(self): |
| r = self.parse("a b c fooze", 'r59') |
| self.assertEqual( |
| r.tree.toStringTree(), |
| '(a fooze) (b fooze) (c fooze)' |
| ) |
| |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
| |
