def testNewParser(self):
        program = lex(
            "print 'Hello World!'\n"
            "print 42"
        )

        ast = parse(program)

    def testBadParse(self):
        program = 'if 1<2\n    pass\n'
        tokens = lex(program)
        def ifParse():
            IfStatement.parse(tokens)

        self.failUnlessRaises(error.SyntaxError, ifParse)

    def testIndentation(self):
        result = lex(util.source('''
            0
                4

                4
                    8

            0
              2
                  6'''))

        EOS = END_OF_STATEMENT
        BB = BEGIN_BLOCK
        EB = END_BLOCK
        EOF = END_OF_FILE

        expected = [
            '0', EOS,  BB, '4',  EOS, '4', EOS,
             BB, '8', EOS,  EB,   EB, EOS, '0', EOS,
             BB, '2', EOS,  BB,  '6', EOS,  EB,  EB, EOS, EOF
        ]

        self.failUnlessEqual(len(result), len(expected))
        self.failUnlessEqual(result, expected)

    def testSemantic(self):
        '''Also tests variable declaration/expression things.
        The basic jist is that, once semantic testing has been done,
        an Identifier should no longer be an Identifier; it should be
        a VariableExpression.
        '''
        from ast.vardecl import VarDecl
        from ast.variableexpression import VariableExpression

        decl = VarDecl('testvar', (0, '<test>'), vartypes.IntType)

        scope = Scope(parent=None)
        scope['testvar'] = decl

        tokens = lex('testvar nonexist')
        expr1 = Identifier.parse(tokens)
        expr2 = Identifier.parse(tokens)

        result = expr1.semantic(scope)

        self.failUnlessEqual(type(result), VariableExpression)
        self.failUnlessEqual(result.variable, decl)

        self.failUnlessRaises(
            error.NameError,
            lambda: expr2.semantic(scope)
        )

    def testBadParse(self):
        tokens = lex('()')

        self.failUnlessRaises(
            error.SyntaxError,
            lambda: ParenthExpression.parse(tokens)
        )

    def testBadSemantic(self):
        program = "var x = 5 * 'bork'\n"

        self.failUnlessRaises(
            error.TypeError,
            lambda: semantic(parse(lex(program)))
        )

    def testGoodStringParse(self):
        tokens = lex("'print' \"print\"")

        result = LiteralExpression.parse(tokens)
        self.failUnless(isinstance(result, StringLiteral))

        result2 = LiteralExpression.parse(tokens)
        self.failUnless(isinstance(result, StringLiteral))

    def testGoodParse(self):
        program = util.source('''
            def foo():
                pass
        ''')

        result = FunctionDecl.parse(lex(program))
        assert isinstance(result, FunctionDecl), result

    def testComments(self):
        result = lex(util.source('''
            this is tokens!
            # this is a comment
            this is not
        '''))

        assert '#' not in result

    def testGoodProgram(self):
        source = lex(
            "print 'Hello World!'"
        )

        ast = parse(source)

        result = semantic.semantic(ast)

 def testTypeMismatch2(self):
     program = util.source('''
         def foo(i as int) as void:
             return i
     ''')
     self.failUnlessRaises(
         error.TypeError,
         lambda: semantic(parse(lex(program)))
     )

    def testBadParse(self):
        program = util.source('''
            def foo():
        ''')

        self.failUnlessRaises(
            error.SyntaxError,
            lambda: FunctionDecl.parse(lex(program))
        )

    def testTypeMismatch(self):
        ast = parse(lex('var x as string = 42'))

        assert ast is not None

        self.failUnlessRaises(
            error.TypeError,
            lambda: semantic(ast)
        )

        def doIt():
            result = lex(util.source('''
                    0
                        4

                        4
                      2
                ''')
            )

 def testLexKeyword(self):
     result = lex('int print abc string char if 0')
     self.failUnlessEqual(result[0].type, 'keyword')
     self.failUnlessEqual(result[1].type, 'keyword')
     self.failUnlessEqual(result[2].type, 'identifier')
     self.failUnlessEqual(result[3].type, 'keyword')
     self.failUnlessEqual(result[4].type, 'keyword')
     self.failUnlessEqual(result[5].type, 'keyword')
     self.failUnlessEqual(result[6].type, 'literal')

    def testABugAndyFound(self):
        from nine.lexer import lex
        from nine.parser import parse
        from nine.semantic import semantic

        result = semantic(parse(lex(util.source('''
            if true:
                print 'True!'
            print 'This caused a spurious syntax error because there is no END_OF_STATEMENT after the dedent!'
        '''))))

    def testParseAttributeNoParameters(self):
        source = '[Thingie]'
        tok = lexer.lex(source)

        result = Attribute.parse(tok)

        self.assertTrue(isinstance(result, Attribute))
        self.assertTrue(isinstance(result.className, Identifier))
        self.assertEqual(result.className.name, 'Thingie')
        self.assertEqual(result.params, [])

    def testParseArgs(self):
        tokens = lex(util.source('''
            def foo(x as string, y as int, z as boolean):
                print x
                print y
                print z
        '''))

        result = FunctionDecl.parse(tokens)
        assert isinstance(result, FunctionDecl), tokens.peek()

    def testMissingCloseBrace(self):
        source = util.source('''
            hey look we forgot to close this (!
            oops!
        ''')

        self.assertRaises(
            error.LexError,
            lambda: lex(source)
        )

    def testRenameIdentifier(self):
        from nine.lexer import lex
        from ast.qualifiedname import QualifiedName

        name = QualifiedName.parse(lex('Foo.Bar.Baz'))

        newName = Attribute.renameIdentifier(name)

        self.assertEqual(newName.lhs, name.lhs)
        self.assertEqual(newName.lhs.rhs.name, name.lhs.rhs.name)
        self.assertEqual(newName.rhs.name, 'BazAttribute')