<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<title>t042ast</title>

<!-- ANTLR includes -->
<script type="text/javascript" src="../../lib/antlr3-all.js"></script>
<script type="text/javascript" src="t042astLexer.js"></script>
<script type="text/javascript" src="t042astParser.js"></script>


<!-- JsUnit include -->
<script type="text/javascript" src="../jsunit/app/jsUnitCore.js"></script>

<!-- Test Code -->
<script type="text/javascript">
    var TLexer = function() {
        TLexer.superclass.constructor.apply(this, arguments);
    };
    org.antlr.lang.extend(TLexer, t042astLexer, {
        recover: function(re) {
            /* don't recover, just crash */
            throw re;
        }
    });

    var TParser = function() {
        TParser.superclass.constructor.apply(this, arguments);
    };
    org.antlr.lang.extend(TParser, t042astParser, {
        recover: function(re) {
            /* don't recover, just crash */
            throw re;
        }
    });


    function parse(text, method, rArgs, kwargs) {
        var cstream = new org.antlr.runtime.ANTLRStringStream(text),
            lexer = new TLexer(cstream),
            tstream = new org.antlr.runtime.CommonTokenStream(lexer),
            parser = new TParser(tstream);

            rArgs = rArgs || [];
            kwargs = kwargs || {};

            org.antlr.lang.augmentObject(parser, kwargs);
            return parser[method].apply(parser, rArgs);
    }

    function testR1() {
        var r = parse("1 + 2", "r1");
        assertEquals(r.tree.toStringTree(), "(+ 1 2)");
    }

    function testR2a() {
        var r = parse("assert 2+3;", "r2");
        assertEquals(r.tree.toStringTree(), "(assert (+ 2 3))");
    }

    function testR2b() {
        var r = parse("assert 2+3 : 5;", "r2");
        assertEquals(r.tree.toStringTree(), "(assert (+ 2 3) 5)");
    }

    function testR3a() {
        var r = parse("if 1 fooze", "r3");
        assertEquals(r.tree.toStringTree(), "(if 1 fooze)");
    }

    function testR3b() {
        var r = parse("if 1 fooze else fooze", "r3");
        assertEquals(r.tree.toStringTree(), "(if 1 fooze fooze)");
    }

    function testR4a() {
        var r = parse("while 2 fooze", "r4");
        assertEquals(r.tree.toStringTree(), "(while 2 fooze)");
    }

    function testR4b() {
        var r = parse("while 2 fooze", "r4");
        assertEquals(r.tree.toStringTree(), "(while 2 fooze)");
    }

    function testR5a() {
        var r = parse("return;", "r5");
        assertEquals(r.tree.toStringTree(), "return");
    }

    function testR5b() {
        var r = parse("return 2+3;", "r5");
        assertEquals(r.tree.toStringTree(), "(return (+ 2 3))");
    }

    function testR6a() {
        var r = parse("3", "r6");
        assertEquals(r.tree.toStringTree(), "3");
    }

    function testR6b() {
        var r = parse("3 a", "r6");
        assertEquals(r.tree.toStringTree(), "3 a");
    }

    function testR7() {
        var r = parse("3", "r7");
        assertNull(r.tree);
    }

    function testR8() {
        var r = parse("var foo:bool", "r8");
        assertEquals(r.tree.toStringTree(), "(var bool foo)");
    }

    function testR9() {
        var r = parse("int foo;", "r9");
        assertEquals(r.tree.toStringTree(), "(VARDEF int foo)");
    }

    function testR10() {
        var r = parse("10", "r10");
        assertEquals(r.tree.toStringTree(), "10.0");
    }

    function testR11a() {
        var r = parse("1+2", "r11");
        assertEquals(r.tree.toStringTree(), "(EXPR (+ 1 2))");
    }

    function testR11b() {
        var r = parse("", "r11");
        assertEquals(r.tree.toStringTree(), "EXPR");
    }

    function testR12a() {
        var r = parse("foo", "r12");
        assertEquals(r.tree.toStringTree(), "foo");
    }

    function testR12b() {
        var r = parse("foo, bar, gnurz", "r12");
        assertEquals(r.tree.toStringTree(), "foo bar gnurz");
    }
   
    function testR13a() {
        var r = parse("int foo;", "r13");
        assertEquals(r.tree.toStringTree(), "(int foo)");
    }
   
    function testR13b() {
        var r = parse("bool foo, bar, gnurz;", "r13");
        assertEquals(r.tree.toStringTree(), "(bool foo bar gnurz)");
    }

    function testR14a() {
        var r = parse("1+2 int", "r14");
        assertEquals(r.tree.toStringTree(), "(EXPR (+ 1 2) int)");
    }

    function testR14b() {
        var r = parse("1+2 int bool", "r14");
        assertEquals(r.tree.toStringTree(), "(EXPR (+ 1 2) int bool)");
    }

    function testR14c() {
        var r = parse("int bool", "r14");
        assertEquals(r.tree.toStringTree(), "(EXPR int bool)");
    }

    function testR14d() {
        var r = parse("fooze fooze int bool", "r14");
        assertEquals(r.tree.toStringTree(), "(EXPR fooze fooze int bool)");
    }

    function testR14e() {
        var r = parse("7+9 fooze fooze int bool", "r14");
        assertEquals(r.tree.toStringTree(), "(EXPR (+ 7 9) fooze fooze int bool)");
    }

    function testR15() {
        var r = parse("7", "r15");
        assertEquals(r.tree.toStringTree(), "7 7");
    }

    function testR16a() {
        var r = parse("int foo", "r16");
        assertEquals(r.tree.toStringTree(), "(int foo)");
    }

    function testR16b() {
        var r = parse("int foo, bar, gnurz", "r16");
        assertEquals(r.tree.toStringTree(), "(int foo) (int bar) (int gnurz)");
    }

    function testR17a() {
        var r = parse("for ( fooze ; 1 + 2 ; fooze ) fooze", "r17");
        assertEquals(r.tree.toStringTree(), "(for fooze (+ 1 2) fooze fooze)");
    }

    function testR18a() {
        var r = parse("for", "r18");
        assertEquals(r.tree.toStringTree(), "BLOCK");
    }

    function testR19a() {
        var r = parse("for", "r19");
        assertEquals(r.tree.toStringTree(), "for");
    }

    function testR20a() {
        var r = parse("for", "r20");
        assertEquals(r.tree.toStringTree(), "FOR");
    }
  
    function testR21a() {
        var r = parse("for", "r21");
        assertEquals(r.tree.toStringTree(), "BLOCK");
    }

    function testR22a() {
        var r = parse("for", "r22");
        assertEquals(r.tree.toStringTree(), "for");
    }

    function testR23a() {
        var r = parse("for", "r23");
        assertEquals(r.tree.toStringTree(), "FOR");
    }

    function testR24a() {
        var r = parse("fooze 1 + 2", "r24");
        assertEquals(r.tree.toStringTree(), "(fooze (+ 1 2))");
    }

    function testR25a() {
        var r = parse("fooze, fooze 1 + 2", "r25");
        assertEquals(r.tree.toStringTree(), "(fooze (+ 1 2))");
    }

    function testR26a() {
        var r = parse("fooze, fooze2", "r26");
        assertEquals(r.tree.toStringTree(), "(BLOCK fooze fooze2)");
    }

    function testR27a() {
        var r = parse("fooze 1 + 2", "r27");
        assertEquals(r.tree.toStringTree(), "(fooze (fooze (+ 1 2)))");
    }

    function testR28() {
        var r = parse("foo28a", "r28");
        assertNull(r.getTree());
    }

    function testR29() {
        try {
            var r = parse("", "r29");
            fail("should not reach here");
        } catch(e) {}
    }

    function testR31a() {
        var r = parse("public int gnurz = 1 + 2;", "r31", null, {flag:0});
        assertEquals(r.tree.toStringTree(), '(VARDEF gnurz public int (+ 1 2))');
    }

    function testR31b() {
        var r = parse("public int gnurz = 1 + 2;", "r31", null, {flag:1});
        assertEquals(r.tree.toStringTree(), '(VARIABLE gnurz public int (+ 1 2))');
    }

    function testR31c() {
        var r = parse("public int gnurz = 1 + 2;", "r31", null, {flag:2});
        assertEquals(r.tree.toStringTree(), '(FIELD gnurz public int (+ 1 2))');
    }

    function testR32a() {
        var r = parse("gnurz 32", "r32", [1], {flag:2});
        assertEquals(r.tree.toStringTree(), 'gnurz');
    }

    function testR32b() {
        var r = parse("gnurz 32", "r32", [2], {flag:2});
        assertEquals(r.tree.toStringTree(), '32');
    }

    function testR32c() {
        var r = parse("gnurz 32", "r32", [3], {flag:2});
        assertNull(r.tree);
    }

    function testR33a() {
        var r = parse("public private fooze", "r33", [2], {flag:2});
        assertEquals(r.tree.toStringTree(), 'fooze');
    }

    function testR34a() {
        var r = parse("public class gnurz { fooze fooze2 }", "r34");
        assertEquals(r.tree.toStringTree(), "(class gnurz public fooze fooze2)");
    }

    function testR34b() {
        var r = parse("public class gnurz extends bool implements int, bool { fooze fooze2 }", "r34");
        assertEquals(r.tree.toStringTree(), "(class gnurz public (extends bool) (implements int bool) fooze fooze2)");
    }

    function testR35() {
        try {
            var r = parse("{ extends }", "r35");
            fail("should not reach here");
        } catch(e) {}
    }

    function testR36a() {
        var r = parse("if ( 1 + 2 ) fooze", "r36");
        assertEquals(r.tree.toStringTree(), "(if (EXPR (+ 1 2)) fooze)");
    }

    function testR36b() {
        var r = parse("if ( 1 + 2 ) fooze else fooze2", "r36");
        assertEquals(r.tree.toStringTree(), "(if (EXPR (+ 1 2)) fooze fooze2)");
    }

    function testR37() {
        var r = parse("1 + 2 + 3", "r37");
        assertEquals(r.tree.toStringTree(), "(+ (+ 1 2) 3)");
    }

    function testR38() {
        var r = parse("1 + 2 + 3", "r38");
        assertEquals(r.tree.toStringTree(), "(+ (+ 1 2) 3)");
    }

    function testR39a() {
        var r = parse("gnurz[1]", "r39");
        assertEquals(r.tree.toStringTree(), "(INDEX gnurz 1)");
    }

    function testR39b() {
        var r = parse("gnurz(2)", "r39");
        assertEquals(r.tree.toStringTree(), "(CALL gnurz 2)");
    }

    function testR39c() {
        var r = parse("gnurz.gnurz", "r39");
        assertEquals(r.tree.toStringTree(), "(FIELDACCESS gnurz gnurz)");
    }
 
    function testR39d() {
        var r = parse("gnurz.gnarz.gnorz", "r39");
        assertEquals(r.tree.toStringTree(), "(FIELDACCESS (FIELDACCESS gnurz gnarz) gnorz)");
    }

    function testR40() {
        var r = parse("1 + 2 + 3;", "r40");
        assertEquals(r.tree.toStringTree(), "(+ 1 2 3)");
    }

    function testR41() {
        var r = parse("1 + 2 + 3;", "r41");
        assertEquals(r.tree.toStringTree(), "(3 (2 1))");
    }

    function testR42() {
        var r = parse("gnurz, gnarz, gnorz", "r42");
        assertEquals(r.tree.toStringTree(), "gnurz gnarz gnorz");
    }

    function testR43() {
        var r = parse("gnurz, gnarz, gnorz", "r43");
        assertNull(r.tree);
        assertArrayEquals(r.res, ["gnurz", "gnarz", "gnorz"]);
    }

    function testR44() {
        var r = parse("gnurz, gnarz, gnorz", "r44");
        assertEquals(r.tree.toStringTree(), "(gnorz (gnarz gnurz))");
    }

    function testR45() {
        var r = parse("gnurz", "r45");
        assertEquals(r.tree.toStringTree(), "gnurz");
    }

    function testR46() {
        var r = parse("gnurz, gnarz, gnorz", "r46");
        assertNull(r.tree);
        assertArrayEquals(r.res, ["gnurz", "gnarz", "gnorz"]);
    }

    function testR47() {
        var r = parse("gnurz, gnarz, gnorz", "r47");
        assertEquals(r.tree.toStringTree(), "gnurz gnarz gnorz");
    }

    function testR48() {
        var r = parse("gnurz, gnarz, gnorz", "r48");
        assertEquals(r.tree.toStringTree(), "gnurz gnarz gnorz");
    }

    function testR49() {
        var r = parse("gnurz gnorz", "r49");
        assertEquals(r.tree.toStringTree(), "(gnurz gnorz)");
    }

    function testR50() {
        var r = parse("gnurz", "r50");
        assertEquals(r.tree.toStringTree(), "(1.0 gnurz)");
    }

    function testR51() {
        var r = parse("gnurza gnurzb gnurzc", "r51");
        assertEquals(r.res.toStringTree(), "gnurzb");
    }

    function testR52() {
        var r = parse("gnurz", "r52");
        assertEquals(r.res.toStringTree(), "gnurz");
    }

    function testR53() {
        var r = parse("gnurz", "r53");
        assertEquals(r.res.toStringTree(), "gnurz");
    }

    function testR54() {
        var r = parse("gnurza 1 + 2 gnurzb", "r54");
        assertEquals(r.tree.toStringTree(), "(+ 1 2)");
    }

    function testR55a() {
        var r = parse("public private 1 + 2", "r55");
        assertEquals(r.tree.toStringTree(), "public private (+ 1 2)");
    }

    function testR55b() {
        var r = parse("public fooze", "r55");
        assertEquals(r.tree.toStringTree(), "public fooze"); 
    }

    function testR56() {
        var r = parse("a b c d", "r56");
        assertEquals(r.tree.toStringTree(), "foo"); 
    }

    function testR57() {
        var r = parse("a b c d", "r57");
        assertEquals(r.tree.toStringTree(), "foo"); 
    }

    function testR59() {
        var r = parse("a b c fooze", "r59");
        assertEquals(r.tree.toStringTree(), "(a fooze) (b fooze) (c fooze)"); 
    }
</script>

</head>
<body>
    <h1>t042ast</h1>
</body>
</html>