def test_assign_init(self):
"""Check Assign.__init__()."""
# Initialize some numbers, bools, variables, expressions
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
# Initialize some statements
#
ae1 = Assign('a', e1)
ae2 = Assign('b', e2)
ae3 = Assign('c', e3)
ae4 = Assign('d', e4)
# Check the initialization
#
self.assertEqual('a', ae1.name)
self.assertEqual(e1, ae1.expression)
self.assertEqual('b', ae2.name)
self.assertEqual(e2, ae2.expression)
self.assertEqual('c', ae3.name)
self.assertEqual(e3, ae3.expression)
self.assertEqual('d', ae4.name)
self.assertEqual(e4, ae4.expression)
def test_assign_to_python(self):
"""Check Assign.to_python()."""
# Initialize some numbers, bools, variables, expressions
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
# Initialize some statements
#
ae1 = Assign('a', e1)
ae2 = Assign('b', e2)
ae3 = Assign('c', e3)
ae4 = Assign('d', e4)
# Produce python code strings
#
ae1p = ae1.to_python(0)
ae2p = ae2.to_python(0)
ae3p = ae3.to_python(0)
ae4p = ae4.to_python(0)
# Check python code strings
#
self.assertEqual("e['a'] = (1) + (2)", ae1p)
self.assertEqual("e['b'] = (e['x']) + (e['y'])", ae2p)
self.assertEqual("e['c'] = (1) > (2)", ae3p)
self.assertEqual("e['d'] = (e['x']) > (e['y'])", ae4p)
def test_assign_str(self):
"""Check Assign.__str__()."""
# Initialize some numbers, bools, variables, expressions
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
# Initialize some statements
#
ae1 = Assign('a', e1)
ae2 = Assign('b', e2)
ae3 = Assign('c', e3)
ae4 = Assign('d', e4)
# Check value string
#
self.assertEqual("a = 1 + 2;", str(ae1))
self.assertEqual("b = x + y;", str(ae2))
self.assertEqual("c = 1 > 2;", str(ae3))
self.assertEqual("d = x > y;", str(ae4))
def test_sequence_init(self):
"""Check Sequence.__init__()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('c', e3)
s4 = Assign('d', e4)
# Initialize some statements
#
sa1 = Sequence(s1, s2)
sa2 = Sequence(Sequence(s1, s2), s3)
sa3 = Sequence(Sequence(Sequence(s1, s2), s3), s4)
# Check the initialization
#
self.assertEqual(s1, sa1.first)
self.assertEqual(s2, sa1.second)
self.assertEqual(s1, sa2.first.first)
self.assertEqual(s2, sa2.first.second)
self.assertEqual(s3, sa2.second)
self.assertEqual(s1, sa3.first.first.first)
self.assertEqual(s2, sa3.first.first.second)
self.assertEqual(s3, sa3.first.second)
self.assertEqual(s4, sa3.second)
def test_while_str(self):
"""Check While.__str__()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n3 = Number(3)
n3m = Number(-3)
va = Variable('a')
vb = Variable('b')
e1 = Add(va, n1)
e2 = Add(vb, va)
e3 = Subtract(va, n1)
e4 = LessThan(va, n3)
e5 = GreaterThan(va, n3m)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('a', e3)
s4 = Sequence(s1, s2)
s5 = Sequence(s3, s2)
# Initialize some statements
#
sa1 = While(e4, s4)
sa2 = While(e5, s5)
sa3 = While(Boolean(False), s4)
# Check value strings
#
self.assertEqual("while (a < 3) { a = a + 1; b = b + a; }", str(sa1))
self.assertEqual("while (a > -3) { a = a - 1; b = b + a; }", str(sa2))
self.assertEqual("while (false) { a = a + 1; b = b + a; }", str(sa3))
def test_sequence_str(self):
"""Check Sequence.__str__()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('c', e3)
s4 = Assign('d', e4)
# Initialize some statements
#
sa1 = Sequence(s1, s2)
sa2 = Sequence(Sequence(s1, s2), s3)
sa3 = Sequence(Sequence(Sequence(s1, s2), s3), s4)
# Check value strings
#
self.assertEqual("a = 1 + 2; b = x + y;", str(sa1))
self.assertEqual("a = 1 + 2; b = x + y; c = 1 > 2;", str(sa2))
self.assertEqual("a = 1 + 2; b = x + y; c = 1 > 2; d = x > y;",
str(sa3))
def test_lessthan_2m1m(self):
"""Test parsing less than expression -2 - -1."""
ast = parse("-2 < -1", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("-2 < -1", c)
self.assertEqual(LessThan(Number(-2), Number(-1)), e)
def test_lessthan_1525(self):
"""Test parsing less than expression 1.5 < 2.5."""
ast = parse("1.5 < 2.5", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("1.5 < 2.5", c)
self.assertEqual(LessThan(Number(1.5), Number(2.5)), e)
def test_subtraction_2m1m(self):
"""Test parsing subtraction expression -2 - -1."""
ast = parse("-2 - -1", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("-2 - -1", c)
self.assertEqual(Subtract(Number(-2), Number(-1)), e)
def test_subtraction_1525(self):
"""Test parsing subtraction expression 1.5 - 2.5."""
ast = parse("1.5 - 2.5", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("1.5 - 2.5", c)
self.assertEqual(Subtract(Number(1.5), Number(2.5)), e)
def test_multiplication_m2m1(self):
"""Test parsing multiplication expression -2 * -1."""
ast = parse("-2 * -1", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("-2 * -1", c)
self.assertEqual(Multiply(Number(-2), Number(-1)), e)
def test_multiplication_1525(self):
"""Test parsing multiplication expression 1.5 * 2.5."""
ast = parse("1.5 * 2.5", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("1.5 * 2.5", c)
self.assertEqual(Multiply(Number(1.5), Number(2.5)), e)
def test_division_m2m1(self):
"""Test parsing division expression -2 / -1."""
ast = parse("-2 / -1", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("-2 / -1", c)
self.assertEqual(Divide(Number(-2), Number(-1)), e)
def test_assign_x12(self):
"""Test parsing assignment statement."""
ast = parse("x = 1 + 2;", p.Assign)
c = compose(ast, indent=" ", autoblank=False)
s = ast.to_simple()
self.assertEqual("x = 1 + 2;", c)
self.assertEqual(Assign('x', Add(Number(1), Number(2))), s)
def test_sequence_evaluate(self):
"""Check Sequence.evaluate()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('c', e3)
s4 = Assign('d', e4)
# Initialize some statements
#
sa1 = Sequence(s1, s2)
sa2 = Sequence(Sequence(s1, s2), s3)
sa3 = Sequence(Sequence(Sequence(s1, s2), s3), s4)
# Evaluate the add objects
#
env = dict([('x', Number(5.2)), ('y', Number(3.4))])
sa1e = sa1.evaluate(env)
sa2e = sa2.evaluate(env)
sa3e = sa3.evaluate(env)
# check the results
#
self.assertIn('a', sa1e)
self.assertIn('b', sa1e)
self.assertNotIn('c', sa1e)
self.assertNotIn('d', sa1e)
self.assertEqual(Number(1 + 2), sa1e['a'])
self.assertEqual(Number(5.2 + 3.4), sa1e['b'])
self.assertIn('a', sa2e)
self.assertIn('b', sa2e)
self.assertIn('c', sa2e)
self.assertNotIn('d', sa2e)
self.assertEqual(Number(1 + 2), sa2e['a'])
self.assertEqual(Number(5.2 + 3.4), sa2e['b'])
self.assertEqual(Boolean(1 > 2), sa2e['c'])
self.assertIn('a', sa3e)
self.assertIn('b', sa3e)
self.assertIn('c', sa3e)
self.assertIn('d', sa3e)
self.assertEqual(Number(1 + 2), sa3e['a'])
self.assertEqual(Number(5.2 + 3.4), sa3e['b'])
self.assertEqual(Boolean(1 > 2), sa3e['c'])
self.assertEqual(Boolean(5.2 > 3.4), sa3e['d'])
def test_if_init(self):
"""Check If.__init__()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('c', e3)
s4 = Assign('d', e4)
s5 = Sequence(s1, s2)
s6 = Sequence(s3, s4)
# Initialize some statements
#
sa1 = If(e3, s1, s2)
sa2 = If(e4, s3, s4)
sa3 = If(Boolean(True), s5, s6)
sa4 = If(Boolean(False), s5, s6)
sa5 = If(e3, s5, s6)
sa6 = If(e4, sa1, sa2)
# Check the initialization
#
self.assertEqual(e3, sa1.condition)
self.assertEqual(s1, sa1.consequence)
self.assertEqual(s2, sa1.alternative)
self.assertEqual(e4, sa2.condition)
self.assertEqual(s3, sa2.consequence)
self.assertEqual(s4, sa2.alternative)
self.assertEqual(Boolean(True), sa3.condition)
self.assertEqual(s5, sa3.consequence)
self.assertEqual(s6, sa3.alternative)
self.assertEqual(Boolean(False), sa4.condition)
self.assertEqual(s5, sa4.consequence)
self.assertEqual(s6, sa4.alternative)
self.assertEqual(e3, sa5.condition)
self.assertEqual(s5, sa5.consequence)
self.assertEqual(s6, sa5.alternative)
self.assertEqual(e4, sa6.condition)
self.assertEqual(sa1, sa6.consequence)
self.assertEqual(sa2, sa6.alternative)
def test_if_tx1x2(self):
"""Test parsing if statement if (true) {x = 1;} else {x = 2;}."""
expected = "if (true)\n{\n x = 1;\n}\n"
expected += "else\n{\n x = 2;\n}"
ast = parse(expected, p.If)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual(expected, c)
self.assertEqual(
If(Boolean(True), Assign('x', Number(1)), Assign('x', Number(2))),
e)
def test_if_ne(self):
"""Check If.__ne__()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('c', e3)
s4 = Assign('d', e4)
s5 = Sequence(s1, s2)
s6 = Sequence(s3, s4)
# Initialize some statements
#
sa1 = If(e3, s1, s2)
sa2 = If(e4, s5, s6)
sa3 = If(e3, sa1, sa2)
sa4 = If(e4, sa1, sa2)
sb1 = If(e3, s1, s2)
sb2 = If(e4, s5, s6)
sb3 = If(e3, sb1, sb2)
sb4 = If(e4, sb1, sb2)
# Check equality with itself
#
self.assertFalse(sa1 != sa1)
self.assertFalse(sa2 != sa2)
self.assertFalse(sa3 != sa3)
self.assertFalse(sa4 != sa4)
# Check equality with same value but different objects
#
self.assertFalse(sa1 != sb1)
self.assertFalse(sa2 != sb2)
self.assertFalse(sa3 != sb3)
self.assertFalse(sa4 != sb4)
# Check equality with different value
#
self.assertTrue(sa1 != sa4)
self.assertTrue(sa2 != sa1)
self.assertTrue(sa3 != sa2)
self.assertTrue(sa4 != sa3)
def test_program_diff_env(self):
"""Test simple 2 line program with different initial conditions."""
simple_lines = \
"""
y = x + 3;
z = y + 5;
"""
ast = parse(simple_lines, p.Program)
prog = ast.to_simple()
env_expected = dict(x=Number(2), y=Number(5), z=Number(10))
env = dict(x=Number(2))
env2 = prog.evaluate(env)
self.assertEqual(len(env_expected), len(env2))
for x in env_expected.keys():
self.assertEqual(env_expected[x], env2[x])
# show that we can reuse the program
env_expected = dict(x=Number(9), y=Number(12), z=Number(17))
env2['x'] = Number(9)
env3 = prog.evaluate(env2)
self.assertEqual(len(env_expected), len(env3))
for x in env_expected.keys():
self.assertEqual(env_expected[x], env3[x])
def test_if_repr(self):
"""Check If.__repr__()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n2 = Number(2)
vx = Variable('x')
vy = Variable('y')
e1 = Add(n1, n2)
e2 = Add(vx, vy)
e3 = GreaterThan(n1, n2)
e4 = GreaterThan(vx, vy)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('c', e3)
s4 = Assign('d', e4)
s5 = Sequence(s1, s2)
s6 = Sequence(s3, s4)
# Initialize some statements
#
sa1 = If(e3, s1, s2)
sa2 = If(e4, s3, s4)
sa3 = If(Boolean(True), s5, s6)
sa4 = If(Boolean(False), s5, s6)
sa5 = If(e3, s5, s6)
sa6 = If(e4, sa1, sa2)
# Check value strings
#
self.assertEqual("«if (1 > 2) { a = 1 + 2; } else { b = x + y; }»",
repr(sa1))
self.assertEqual("«if (x > y) { c = 1 > 2; } else { d = x > y; }»",
repr(sa2))
self.assertEqual(
"«if (true) { a = 1 + 2; b = x + y; } " +
"else { c = 1 > 2; d = x > y; }»", repr(sa3))
self.assertEqual(
"«if (false) { a = 1 + 2; b = x + y; } " +
"else { c = 1 > 2; d = x > y; }»", repr(sa4))
self.assertEqual(
"«if (1 > 2) { a = 1 + 2; b = x + y; } " +
"else { c = 1 > 2; d = x > y; }»", repr(sa5))
self.assertEqual(
"«if (x > y) { if (1 > 2) { a = 1 + 2; } else { b = x + y; } } " +
"else { if (x > y) { c = 1 > 2; } else { d = x > y; } }»",
repr(sa6))
def test_while_ne(self):
"""Check While.__ne__()."""
# Initialize some numbers, bools, variables, expressions,
# statements
#
n1 = Number(1)
n3 = Number(3)
n3m = Number(-3)
va = Variable('a')
vb = Variable('b')
e1 = Add(va, n1)
e2 = Add(vb, va)
e3 = Subtract(va, n1)
e4 = LessThan(va, n3)
e5 = GreaterThan(va, n3m)
s1 = Assign('a', e1)
s2 = Assign('b', e2)
s3 = Assign('a', e3)
s4 = Sequence(s1, s2)
s5 = Sequence(s3, s2)
# Initialize some statements
#
sa1 = While(e4, s4)
sa2 = While(e5, s5)
sa3 = While(Boolean(False), s4)
sb1 = While(e4, s4)
sb2 = While(e5, s5)
sb3 = While(Boolean(False), s4)
# Check equality with itself
#
self.assertFalse(sa1 != sa1)
self.assertFalse(sa2 != sa2)
self.assertFalse(sa3 != sa3)
# Check equality with same value but different objects
#
self.assertFalse(sa1 != sb1)
self.assertFalse(sa2 != sb2)
self.assertFalse(sa3 != sb3)
# Check equality with different value
#
self.assertTrue(sa1 != sa3)
self.assertTrue(sa2 != sa1)
self.assertTrue(sa3 != sa2)
def test_greaterthan_x25(self):
"""Test parsing greater than expression x > 2.5."""
ast = parse("x > 2.5", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("x > 2.5", c)
self.assertEqual(GreaterThan(Variable('x'), Number(2.5)), e)
def test_greaterthan_15x(self):
"""Test parsing greater than expression 1.5 > x."""
ast = parse("1.5 > x", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("1.5 > x", c)
self.assertEqual(GreaterThan(Number(1.5), Variable('x')), e)
def test_number_fp_1(self):
"""Test parsing floating point literal value 1.23."""
ast = parse("1.23", p.term_expression)
c = compose(ast, indent=" ", autoblank=False)
n = ast.to_simple()
self.assertEqual("1.23", c)
self.assertEqual(Number(1.23), n)
def test_number_int_2(self):
"""Test parsing integer literal value -123."""
ast = parse("-123", p.term_expression)
c = compose(ast, indent=" ", autoblank=False)
n = ast.to_simple()
self.assertEqual("-123", c)
self.assertEqual(Number(-123), n)
def test_while_tx1yx2y(self):
"""Test parsing while statement whil (x > y) {...}."""
expected = "while (x > y)\n"
expected += "{\n"
expected += " x = 1;\n"
expected += " y = x * 3;\n"
expected += "}"
ast = parse(expected, p.While)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual(expected, c)
self.assertEqual(
While(
GreaterThan(Variable('x'), Variable('y')),
Sequence(Assign('x', Number(1)),
Assign('y', Multiply(Variable('x'), Number(3))))), e)
def test_division_x25(self):
"""Test parsing division expression x / 2.5."""
ast = parse("x / 2.5", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("x / 2.5", c)
self.assertEqual(Divide(Variable('x'), Number(2.5)), e)
def test_division_15x(self):
"""Test parsing division expression 1.5 / x."""
ast = parse("1.5 / x", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("1.5 / x", c)
self.assertEqual(Divide(Number(1.5), Variable('x')), e)
def test_not_1p1(self):
"""Test parsing logical negation expression !1.1."""
ast = parse("!1.1", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("!1.1", c)
self.assertEqual(Not(Number(1.1)), e)
def test_or_1my(self):
"""Test parsing logical or expression -1 || y."""
ast = parse("-1 || y", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("-1 || y", c)
self.assertEqual(Or(Number(-1), Variable('y')), e)
