def testModifiers3(self):
        program = util.source('''
            sealed override def bork():
                pass
        ''')

        util.parseProgram(program)

    def testModifiers1(self):
        program = util.source('''
            static def bork():
                pass
        ''')

        util.parseProgram(program)

    def testReadProperty(self):
        program = util.source('''
            var o = TestClass.TestClass(2)
            print o.Property
        ''')

        util.runProgram('extern_read_property_test', program, ['mscorlib', 'bin/ClassLibrary1'])

    def testCompileString(self):
        program = util.source('''
            print 'Expect 9:'
            var count = 0
            if 1<9:
                count = count + 1
            else:
                count = count + 99

            if 1>9:
                pass
            else:
                count = count + 3

            if 1>9:
                pass
            elif 9>1:
                count = count + 4

            if 9<1:
                pass
            elif 9<1:
                pass
            else:
                count = count + 1

            print count

            if count == 9:
                print 'Looks like it passed.  Woohoo!'
            else:
                print 'Oh no it failed!!' ''')

        util.runProgram('if_test',program)

    def testRandomCharTests(self):
        # TODO:when this is all implemented this test should reflect that
        from tests import util

        program = util.source(
            """
            #var z as char='N' #char
            var y = '9' #string
            var x = "nine" #also string
            var z = y[0]
            
            #print "z = 'N':"
            #print z
            print "x = 'nine' starts with 'n':"
            print x
            print x[0]
            #print "see 'n' become 'N':"
            x[0]=z
            print x
            print "see three '9's:"
            print y
            print y[0]
            print y as char
        """
        )

        self.assertRaises(error.TypeError, lambda: util.runProgram("test_random_char_tests", program))

    def testParseNoExceptOrFinally(self):
        program = util.source('''
            try:
                pass
        ''')

        self.assertRaises(error.SyntaxError, lambda: util.parseProgram(program))

    def testEmitCode(self):
        program = util.source('''\
            var x as int
            print x
        ''')

        util.runProgram('variable_test', program, ['mscorlib'])

    def testCodeGen(self):
        program = util.source('''
            def foo(x as int, y as int):
                print x * y
        ''')

        util.buildProgram('functiondecl_codegen_test', program)

    def testEmptyInterface(self):
        program = util.source('''
            interface Foo:
                pass
        ''')

        util.buildProgram('interface_empty_test', program)

    def testReadAttribute(self):
        program = util.source('''
            var o = TestClass.TestClass()
            print o.x
        ''')

        util.runProgram('extern_read_attr_test', program, ['bin/ClassLibrary1'])

    def testReturnType(self):
        program = util.source('''
            def foo() as System.Object:
                pass
        ''')

        util.buildProgram('namespace_return_test', program, ['mscorlib'])

 def testTypes(self):
     util.runProgram('print_types', util.source('''
         print (27 as int)
         print (27 as float)
         print (27 as System.Double)
         print (true as boolean)
     '''), ['mscorlib'])

    def testValue(self):
        program = util.source('''
            var t as System.Reflection.Assembly
            print t
        ''')

        util.buildProgram('namespace_variable_test', program, ['mscorlib'])

    def testCodeGen(self):
        program = util.source('''
            var a = -9
            var b = -3.1415926535897931
            var c = +9
            var d = -c
            var e = ~0
            var f = ~(~1)

            print a
            print b
            print c
            print d
            print e
            print f

            var t1 = true
            var f1 = false
            var f2 = not t1
            var t2 = not f2
            var t3 = not f1

            print ''
            print 'Expect True, False, False, True, True'
            print t1
            print f1
            print f2
            print t2
            print t3
        ''')

        util.runProgram('unary_codegen_test', program)

    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 testParameter(self):
        program = util.source('''
            def foo(c as System.Type):
                pass
        ''')

        util.buildProgram('namespace_parameter_test', program, ['mscorlib'])

    def testReturnType(self):
        program = util.source('''
            def multiply(x as int, y as int) as int:
                pass
        ''')

        util.buildProgram('functiondecl_returntype_test', program)

    def testCreateType(self):
        program = util.source('''
            delegate MyDelegate(a as int) as string
            '''
        )

        util.runProgram('delegate_type_test', program, [])

    def testParseEmptIface(self):
        program = util.source('''
            interface Foo:
                pass
        ''')

        util.parseProgram(program)

    def testCallMethod(self):
        program = util.source('''
            var o = TestClass.TestClass()
            o.Method('Hello to C# from Nine!')
        ''')

        util.runProgram('extern_method_test', program, ['bin/ClassLibrary1'])