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'])
def testWriteProperty(self):
program = util.source('''
var o = TestClass.TestClass(2)
o.Property = 'Nine!'
print o.Property
''')
util.runProgram('extern_write_property_test', program, ['mscorlib', 'bin/ClassLibrary1'])
def testParse(self):
program = util.source('''
interface Foo:
def A(a as int) as void
def B() as int
''')
util.parseProgram(program)
def testIndexValueTypeMethod(self):
program = util.source('''
var things = array(int, 1)
print things[0].ToString()
''')
util.runProgram('array_index_value_type_method_test', program)
def testComments(self):
result = lex(util.source('''
this is tokens!
# this is a comment
this is not
'''))
assert '#' not in result
def testCallValueTypeMember(self):
program = util.source('''
var pi = 3.1415926535897931
print 'Pi:'
print pi.ToString()
''')
util.runProgram('extern_call_value_type_member_test', program)
def testResolveOverload(self):
program = util.source('''
var o = TestClass.TestClass(2)
o.Method(9)
#o.Method('String!')
''')
util.runProgram('extern_overload_test', program, ['mscorlib', 'bin/ClassLibrary1'])
def testWriteAttribute(self):
program = util.source('''
var o = TestClass.TestClass()
o.x = 999
print o.x
''')
util.runProgram('extern_write_attr_test', program, ['bin/ClassLibrary1'])
def testGoodParse(self):
program = util.source('''
def foo():
pass
''')
result = FunctionDecl.parse(lex(program))
assert isinstance(result, FunctionDecl), result
def testTypeMismatch(self):
program = util.source('''
print 5 or 2
''')
self.failUnlessRaises(
error.TypeError,
lambda: util.semanticProgram(program)
)
def testBuildInterface(self):
program = util.source('''
interface TestIface:
def foo() as int
def bar(a as int)
def baz(b as string) as string
''')
util.buildProgram('interface_build_test', program)
