renaming

mytests/test_boolean.py

@@ -0,0 +1,71 @@
+import py
+
+from simpleparser import parse
+from objmodel import W_NormalObject, W_Integer
+from interpreter import Interpreter
+
+
+def test_boolean_assignment():
+    ast = parse("""
+x = true
+y = false
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_Boolean)
+    assert w_model.getvalue("x").istrue() is True
+    assert isinstance(w_model.getvalue("y"), W_Boolean)
+    assert w_model.getvalue("y").istrue() is False
+
+
+def test_boolean_operations():
+    ast = parse("""
+x = true and(false)
+y = true or(false)
+z = not(true)
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_Boolean)
+    assert w_model.getvalue("x").istrue() is False
+    assert isinstance(w_model.getvalue("y"), W_Boolean)
+    assert w_model.getvalue("y").istrue() is True
+    assert isinstance(w_model.getvalue("z"), W_Boolean)
+    assert w_model.getvalue("z").istrue() is False
+
+
+def test_boolean_result():
+    ast = parse("""
+x = 1 eq(2)
+y = 1 leq(2)
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_Boolean)
+    assert w_model.getvalue("x").istrue() is False
+    assert isinstance(w_model.getvalue("y"), W_Boolean)
+    assert w_model.getvalue("y").istrue() is True
+
+
+def test_boolean_conversion():
+    ast = parse("""
+x = 1 toboolean
+y = true toint
+z = false toint
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_Boolean)
+    assert w_model.getvalue("x").istrue() is True
+    assert isinstance(w_model.getvalue("y"), W_Integer)
+    assert w_model.getvalue("y").value == 1
+    assert isinstance(w_model.getvalue("z"), W_Integer)
+    assert w_model.getvalue("z").value == 0

mytests/test_double.py

@@ -0,0 +1,51 @@
+from simpleparser import parse
+from objmodel import W_Integer
+from interpreter import Interpreter
+
+
+def test_double_assignment():
+    ast = parse("""
+x = 1.5
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_Double)
+    assert w_model.getvalue("x").value == 1.5
+
+
+def test_double_operations():
+    ast = parse("""
+x = 3 div(2)
+y = 3 div(2.0)
+z = 3.0 div(2.0)
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_Integer)
+    assert w_model.getvalue("x").value == 1
+    assert isinstance(w_model.getvalue("y"), W_Integer)
+    assert w_model.getvalue("y").value == 1
+    assert isinstance(w_model.getvalue("z"), W_Double)
+    assert w_model.getvalue("z").value == 1.5
+
+
+def test_double_conversion():
+    ast = parse("""
+x = 1.5 toint
+y = 2.0 toint
+z = 3 todouble
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_Integer)
+    assert w_model.getvalue("x").value == 1
+    assert isinstance(w_model.getvalue("y"), W_Integer)
+    assert w_model.getvalue("y").value == 2
+    assert isinstance(w_model.getvalue("z"), W_Double)
+    assert w_model.getvalue("z").value == 3.0

mytests/test_gc.py

@@ -0,0 +1,106 @@
+from simpleparser import parse
+from interpreter import Interpreter
+
+
+def test_reassignment_gc():
+    ast = parse("""
+x = 2
+y = 3
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    x = w_model.getvalue("x")
+    y = w_model.getvalue("y")
+    assert x in interpreter.space.realm  # Wo alle Objekte leben
+    assert y in interpreter.space.realm
+
+    ast = parse("""
+x = y
+""")
+    interpreter.eval(ast, w_model)
+    interpreter.space.gc()
+    assert x not in interpreter.space.realm
+    assert y in interpreter.space.realm
+
+    ast = parse("""
+x = 0
+""")
+    interpreter.eval(ast, w_model)
+    interpreter.space.gc()
+    assert x not in interpreter.space.realm
+    assert y not in interpreter.space.realm
+
+
+def test_chain_gc():
+    ast = parse("""
+x = 1
+y = x
+z = y
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    x = w_model.getvalue("x")
+    assert x in interpreter.space.realm
+
+    ast = parse("""
+x = 0
+""")
+    interpreter.eval(ast, w_model)
+    interpreter.space.gc()
+    assert x in interpreter.space.realm
+
+    ast = parse("""
+y = x
+z = y
+""")
+    interpreter.eval(ast, w_model)
+    interpreter.space.gc()
+    assert x not in interpreter.space.realm
+
+
+def test_while_gc():
+    ast = parse("""
+x = 10
+while x:
+    x = x $int_add(-1)
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    count = len(interpreter.space.realm)
+    interpreter.space.gc()
+
+    assert count - len(interpreter.space.realm) == 10
+
+
+def test_object_gc():
+    ast = parse("""
+object x:
+    a = 1
+    b = 2
+    c = 3
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    a = w_model.getvalue("x").getvalue("a")
+    b = w_model.getvalue("x").getvalue("b")
+    c = w_model.getvalue("x").getvalue("c")
+    assert a in interpreter.space.realm
+    assert b in interpreter.space.realm
+    assert c in interpreter.space.realm
+
+    ast = parse("""
+x = 0
+""")
+    interpreter.eval(ast, w_model)
+    interpreter.space.gc()
+    assert a not in interpreter.space.realm
+    assert b not in interpreter.space.realm
+    assert c not in interpreter.space.realm

mytests/test_string.py

@@ -0,0 +1,35 @@
+import py
+
+from simpleparser import parse
+from objmodel import W_NormalObject, W_Integer
+from interpreter import Interpreter
+
+
+def test_string_assignment():
+    ast = parse("""
+x = "Hallo"
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_String)
+    assert w_model.getvalue("x").value == "Hallo"
+
+
+def test_string_operations():
+    ast = parse("""
+x = "Hallo" add("ollaH")
+y = "Hallo" rev
+z = "Hallo" len
+""")
+    interpreter = Interpreter()
+    w_model = interpreter.make_module()
+    interpreter.eval(ast, w_model)
+
+    assert isinstance(w_model.getvalue("x"), W_String)
+    assert w_model.getvalue("x").value == "HalloollaH"
+    assert isinstance(w_model.getvalue("y"), W_String)
+    assert w_model.getvalue("y").value == "ollaH"
+    assert isinstance(w_model.getvalue("z"), W_Integer)
+    assert w_model.getvalue("z").value == 5

mytests/test_sugar.py

@@ -0,0 +1,58 @@
+import py
+
+from simpleparser import parse
+from objmodel import W_NormalObject
+from interpreter import Interpreter
+
+
+def sugar_test_helper(expr):
+    ast = parse("x = " + expr)
+    interpreter = Interpreter()
+    w_module = interpreter.make_module()
+    interpreter.eval(ast, w_module)
+
+    return w_module.getvalue("x").value
+
+
+def test_plus():
+    assert sugar_test_helper("1 + 1 + 1") == 3
+    assert sugar_test_helper("1 + 1") == 2
+
+
+def test_minus():
+    assert sugar_test_helper("2 - 1") == 1
+    assert sugar_test_helper("3 - 1 - 1") == 1
+
+
+def test_mult():
+    assert sugar_test_helper("2 * 5") == 10
+    assert sugar_test_helper("2 * 3 * 4") == 24
+
+
+def test_div():
+    assert sugar_test_helper("10 / 2") == 5
+    assert sugar_test_helper("24 / 3 / 2") == 4
+
+
+def test_mod():
+    assert sugar_test_helper("11 % 2") == 1
+
+
+def test_inc():
+    assert sugar_test_helper("1 ++") == 2
+    assert sugar_test_helper("1 ++ + 1") == 3  # Is this allowed?
+    assert sugar_test_helper("2 * 2 ++") == 6
+
+
+def test_mixed_precedence():
+    assert sugar_test_helper("2 * 3 / 2") == 3
+    assert sugar_test_helper("1 + 2 + 3 - 5") == 1
+    assert sugar_test_helper("10 - 2 * 5") == 0
+    assert sugar_test_helper("1 + 2 * 2 * 3 - 3 * 4") == 1
+
+
+def test_parenthesis():
+    assert sugar_test_helper("2 * (2 + 3)") == 10
+    assert sugar_test_helper("(2 + 5)") == 7
+    assert sugar_test_helper("(3 + 3) % 2") == 0
+    assert sugar_test_helper("(2 * 2) ++") == 5

mytests/test_sugar_lex.py

@@ -0,0 +1,13 @@
+from rply import Token
+from simplelexer import lex
+
+
+def test_lexing():
+    token = lex("+ - * / ++ %")
+
+    assert Token("Plus", "+") == token[0]
+    assert Token("Minus", "-") == token[1]
+    assert Token("Multiply", "*") == token[2]
+    assert Token("Divide", "/") == token[3]
+    assert Token("Increment", "++") == token[4]
+    assert Token("Modulo", "%") == token[5]

mytests/test_sugar_parse.py

@@ -0,0 +1,15 @@
+from simpleparser import parse
+
+
+def test_parsing():
+    assert parse("1 + 2") == parse("1 $int_add(2)")
+    assert parse("1 + 2 + 3") == parse("1 $int_add(2) $int_add(3)")
+    assert parse("1 + 2 * 3") == parse("1 $int_add(2 $int_mul(3))")
+    assert parse("1 - 2 - 3") == parse("1 $int_sub(2) $int_sub(3)")
+    assert parse("1 + 2 % 3 / 4 - 5 * 6 + 7++") \
+           == parse("1 $int_add(2 $int_mod(3) $int_div(4)) $int_sub(5 $int_mul(6)) $int_add(7 $int_inc)")
+
+
+def test_parsing_parenthesis():
+    assert parse("(1 + 2)") == parse("1 $int_add(2)")
+    assert parse("1 * (2 + 3)") == parse("1 $int_mul(2 $int_add(3))")