def test_assign_evaluate(self):
"""Check Assign.evaluate()."""
# 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)
# Evaluate the add objects
#
env = dict([('x', Number(5.2)), ('y', Number(3.4))])
ae1e = ae1.evaluate(env)
ae2e = ae2.evaluate(env)
ae3e = ae3.evaluate(env)
ae4e = ae4.evaluate(env)
# check the results
#
self.assertEqual(Number(1 + 2), ae1e['a'])
self.assertEqual(Number(5.2 + 3.4), ae2e['b'])
self.assertEqual(Boolean(1 > 2), ae3e['c'])
self.assertEqual(Boolean(5.2 > 3.4), ae4e['d'])
def test_or_ft(self):
"""Test parsing logical or expression false || true."""
ast = parse("false || true", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("false || true", c)
self.assertEqual(Or(Boolean(False), Boolean(True)), e)
def test_and_tt(self):
"""Test parsing logical and expression true && true."""
ast = parse("true && true", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("true && true", c)
self.assertEqual(And(Boolean(True), Boolean(True)), e)
def test_boolean_to_python(self):
"""Check Boolean.to_python()."""
b1t = Boolean(True)
b1f = Boolean(False)
b1tp = b1t.to_python(0)
b1fp = b1f.to_python(0)
self.assertEqual("True", b1tp)
self.assertEqual("False", b1fp)
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_boolean_evaluate(self):
"""Check Boolean.evaluate()."""
env = {}
b1t = Boolean(True)
b1f = Boolean(False)
b1te = b1t.evaluate(env)
b1fe = b1f.evaluate(env)
self.assertEqual(b1t, b1te)
self.assertEqual(b1f, b1fe)
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_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_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_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_assign_nxt(self):
"""Test parsing assignment statement."""
ast = parse("x = !true;", p.Assign)
c = compose(ast, indent=" ", autoblank=False)
s = ast.to_simple()
self.assertEqual("x = !true;", c)
self.assertEqual(Assign('x', Not(Boolean(True))), s)
def test_or_xf(self):
"""Test parsing logical or expression x || false."""
ast = parse("x || false", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("x || false", c)
self.assertEqual(Or(Variable('x'), Boolean(False)), e)
def test_boolean_f(self):
"""Test parsing boolean literal value false."""
ast = parse("false", p.term_expression)
c = compose(ast, indent=" ", autoblank=False)
b = ast.to_simple()
self.assertEqual("false", c)
self.assertEqual(Boolean(False), b)
def test_not_false(self):
"""Test parsing logical negation expression !false."""
ast = parse("!false", p.Expression)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual("!false", c)
self.assertEqual(Not(Boolean(False)), e)
def test_while_tx1x2(self):
"""Test parsing while statement while (false) {x = 1;}."""
expected = "while (false)\n{\n x = 1;\n}"
ast = parse(expected, p.While)
c = compose(ast, indent=" ", autoblank=False)
e = ast.to_simple()
self.assertEqual(expected, c)
self.assertEqual(While(Boolean(False), Assign('x', Number(1))), e)
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_while_evaluate(self):
"""Check While.evaluate()."""
# 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)
# Evaluate the add objects
#
env = dict([('a', Number(0)), ('b', Number(0))])
sa1e = sa1.evaluate(env)
sa2e = sa2.evaluate(env)
sa3e = sa3.evaluate(env)
# check the results
#
self.assertIn('a', sa1e)
self.assertIn('b', sa1e)
self.assertEqual(Number(3), sa1e['a'])
self.assertEqual(Number(6), sa1e['b'])
self.assertIn('a', sa1e)
self.assertIn('b', sa1e)
self.assertEqual(Number(-3), sa2e['a'])
self.assertEqual(Number(-6), sa2e['b'])
self.assertIn('a', sa1e)
self.assertIn('b', sa1e)
self.assertEqual(Number(0), sa3e['a'])
self.assertEqual(Number(0), sa3e['b'])
def test_while_init(self):
"""Check While.__init__()."""
# 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 the initialization
#
self.assertEqual(e4, sa1.condition)
self.assertEqual(s4, sa1.body)
self.assertEqual(e5, sa2.condition)
self.assertEqual(s5, sa2.body)
self.assertEqual(Boolean(False), sa3.condition)
self.assertEqual(s4, sa3.body)
def test_while_to_python(self):
"""Check While.to_python()."""
# 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)
# Produce python code strings
#
sa1p = sa1.to_python(0)
sa2p = sa2.to_python(0)
sa3p = sa3.to_python(0)
# Check representations
#
self.assertEqual(
"while (e['a']) < (3):\n" + " e['a'] = (e['a']) + (1)\n" +
" e['b'] = (e['b']) + (e['a'])", sa1p)
self.assertEqual(
"while (e['a']) > (-3):\n" + " e['a'] = (e['a']) - (1)\n" +
" e['b'] = (e['b']) + (e['a'])", sa2p)
self.assertEqual(
"while False:\n" + " e['a'] = (e['a']) + (1)\n" +
" e['b'] = (e['b']) + (e['a'])", sa3p)
def test_if_to_python(self):
"""Check If.to_python()."""
# 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)
# Produce python code strings
#
sa1p = sa1.to_python(0)
sa2p = sa2.to_python(0)
sa3p = sa3.to_python(0)
sa4p = sa4.to_python(0)
sa5p = sa5.to_python(0)
sa6p = sa6.to_python(0)
# Check value strings
#
self.assertEqual(
"if (1) > (2):\n e['a'] = (1) + (2)\n"
"else:\n e['b'] = (e['x']) + (e['y'])", sa1p)
self.assertEqual(
"if (e['x']) > (e['y']):\n e['c'] = (1) > (2)\n" +
"else:\n e['d'] = (e['x']) > (e['y'])", sa2p)
self.assertEqual(
"if True:\n e['a'] = (1) + (2)\n" +
" e['b'] = (e['x']) + (e['y'])\n" +
"else:\n e['c'] = (1) > (2)\n" +
" e['d'] = (e['x']) > (e['y'])", sa3p)
self.assertEqual(
"if False:\n e['a'] = (1) + (2)\n" +
" e['b'] = (e['x']) + (e['y'])\n" +
"else:\n e['c'] = (1) > (2)\n" +
" e['d'] = (e['x']) > (e['y'])", sa4p)
self.assertEqual(
"if (1) > (2):\n e['a'] = (1) + (2)\n" +
" e['b'] = (e['x']) + (e['y'])\n" +
"else:\n e['c'] = (1) > (2)\n" +
" e['d'] = (e['x']) > (e['y'])", sa5p)
self.assertEqual(
"if (e['x']) > (e['y']):\n" + " if (1) > (2):\n" +
" e['a'] = (1) + (2)\n" + " else:\n" +
" e['b'] = (e['x']) + (e['y'])\n" + "else:\n" +
" if (e['x']) > (e['y']):\n" + " e['c'] = (1) > (2)\n" +
" else:\n" + " e['d'] = (e['x']) > (e['y'])", sa6p)
