def test_expression_for_modulus_of_two_constants_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
node_type = BinaryExpression.Modulo
expr = BinaryExpression(node_type, a, b)
self.assertEquals("(10 % 20)", str(expr))
def test_binary_expression_only_accepts_expressions_for_arguments(self):
a = 10
a_expr = ConstantExpression(10)
b = "20"
b_expr = ConstantExpression(20)
node_type = BinaryExpression.Add
self.assertRaisesEx(
ValueError,
BinaryExpression,
node_type,
a,
b_expr,
exc_pattern=re.compile(
"Lhs must be an expression \(an instance of a class that inherits from pynq.Expression\)"
))
self.assertRaisesEx(
ValueError,
BinaryExpression,
node_type,
a_expr,
b,
exc_pattern=re.compile(
"Rhs must be an expression \(an instance of a class that inherits from pynq.Expression\)"
))
self.assertRaisesEx(ValueError,
BinaryExpression,
None,
a_expr,
b_expr,
exc_pattern=re.compile(
"The BinaryExpression node type is required"))
def test_expression_for_addition_of_two_constants_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
node_type = BinaryExpression.Add
expr = BinaryExpression(node_type, a, b)
self.assertEquals("(10 + 20)", str(expr))
def test_expression_less_than_or_equal_of_two_constants_representation(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
node_type = BinaryExpression.LessThanOrEqual
expr = BinaryExpression(node_type, a, b)
self.assertEquals("(True <= False)", str(expr))
def test_expression_not_equal_of_two_constants_representation(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
node_type = BinaryExpression.NotEqual
expr = BinaryExpression(node_type, a, b)
self.assertEquals("(True != False)", str(expr))
def test_expression_greater_than_of_two_constants_representation(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
node_type = BinaryExpression.GreaterThan
expr = BinaryExpression(node_type, a, b)
self.assertEquals("(True > False)", str(expr))
def test_expression_for_multiplication_of_two_constants_representation(
self):
a = ConstantExpression(10)
b = ConstantExpression(20)
node_type = BinaryExpression.Multiply
expr = BinaryExpression(node_type, a, b)
self.assertEquals("(10 * 20)", str(expr))
def test_expression_not_equal_of_two_constants(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
node_type = BinaryExpression.NotEqual
expr = BinaryExpression(node_type, a, b)
self.assertEquals(expr.node_type, node_type)
self.assertEquals(expr.lhs, a)
self.assertEquals(expr.rhs, b)
def test_nested_equal_expression_representation(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
c = ConstantExpression(None)
node_type = BinaryExpression.Equal
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b), c)
self.assertEquals("((True == False) == None)", str(expr))
def test_nested_less_than_or_equal_expression_representation(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
c = ConstantExpression(None)
node_type = BinaryExpression.LessThanOrEqual
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b), c)
self.assertEquals("((True <= False) <= None)", str(expr))
def test_expression_greater_than_or_equal_of_two_constants(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
node_type = BinaryExpression.GreaterThanOrEqual
expr = BinaryExpression(node_type, a, b)
self.assertEquals(expr.node_type, node_type)
self.assertEquals(expr.lhs, a)
self.assertEquals(expr.rhs, b)
def test_expression_less_than_of_two_constants(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
node_type = BinaryExpression.LessThan
expr = BinaryExpression(node_type, a, b)
self.assertEquals(expr.node_type, node_type)
self.assertEquals(expr.lhs, a)
self.assertEquals(expr.rhs, b)
def test_nested_greater_than_expression_representation(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
c = ConstantExpression(None)
node_type = BinaryExpression.GreaterThan
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b), c)
self.assertEquals("((True > False) > None)", str(expr))
def test_expression_for_addition_of_two_constants(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
node_type = BinaryExpression.Add
expr = BinaryExpression(node_type, a, b)
self.assertEquals(expr.node_type, node_type)
self.assertEquals(expr.lhs, a)
self.assertEquals(expr.rhs, b)
def test_nested_power_expression_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
c = ConstantExpression(30)
node_type = BinaryExpression.Power
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b),
c)
self.assertEquals("((10 ** 20) ** 30)", str(expr))
def test_nested_division_expression_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
c = ConstantExpression(30)
node_type = BinaryExpression.Divide
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b),
c)
self.assertEquals("((10 / 20) / 30)", str(expr))
def test_nested_addition_expression_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
c = ConstantExpression(30)
node_type = BinaryExpression.Add
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b),
c)
self.assertEquals("((10 + 20) + 30)", str(expr))
def test_nested_modulus_expression_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
c = ConstantExpression(30)
node_type = BinaryExpression.Modulo
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b),
c)
self.assertEquals("((10 % 20) % 30)", str(expr))
def test_nested_subtraction_expression_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
c = ConstantExpression(30)
node_type = BinaryExpression.Subtract
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b),
c)
self.assertEquals("((10 - 20) - 30)", str(expr))
def test_nested_multiplication_expression_representation(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
c = ConstantExpression(30)
node_type = BinaryExpression.Multiply
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b),
c)
self.assertEquals("((10 * 20) * 30)", str(expr))
def test_nested_not_equal_expression(self):
a = ConstantExpression(True)
b = ConstantExpression(False)
c = ConstantExpression(None)
node_type = BinaryExpression.NotEqual
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b), c)
self.assertEquals(expr.node_type, node_type)
self.failUnless(isinstance(expr.lhs, BinaryExpression), "The left-hand side of the binary expression should be a binary expression as well, but is %s" % expr.lhs.__class__)
self.assertEquals(expr.lhs.node_type, node_type)
self.assertEquals(expr.lhs.lhs, a)
self.assertEquals(expr.lhs.rhs, b)
self.assertEquals(expr.rhs, c)
def test_nested_negate_expression_representation(self):
a = ConstantExpression(10)
node_type = UnaryExpression.Negate
expr = UnaryExpression(node_type, UnaryExpression(node_type, a))
self.assertEquals("negate(negate(10))", str(expr))
def test_expression_negate_of_a_constant(self):
a = ConstantExpression(10)
node_type = UnaryExpression.Negate
expr = UnaryExpression(node_type, a)
self.assertEquals(expr.node_type, node_type)
self.assertEquals(expr.rhs, a)
def test_expression_length_of_constant(self):
a = ConstantExpression(["a", "b"])
node_type = UnaryExpression.CollectionLength
expr = UnaryExpression(node_type, a)
self.assertEquals(expr.node_type, node_type)
self.assertEquals(expr.rhs, a)
def test_nested_not_expression_representation(self):
a = ConstantExpression(True)
node_type = UnaryExpression.Not
expr = UnaryExpression(node_type, UnaryExpression(node_type, a))
self.assertEquals("(not (not True))", str(expr))
def test_expression_not_of_a_constant(self):
a = ConstantExpression(True)
node_type = UnaryExpression.Not
expr = UnaryExpression(node_type, a)
self.assertEquals(expr.node_type, node_type)
self.assertEquals(expr.rhs, a)
def test_nested_addition_expression(self):
a = ConstantExpression(10)
b = ConstantExpression(20)
c = ConstantExpression(30)
node_type = BinaryExpression.Add
expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b),
c)
self.assertEquals(expr.node_type, node_type)
self.failUnless(
isinstance(expr.lhs, BinaryExpression),
"The left-hand side of the binary expression should be a binary expression as well, but is %s"
% expr.lhs.__class__)
self.assertEquals(expr.lhs.node_type, node_type)
self.assertEquals(expr.lhs.lhs, a)
self.assertEquals(expr.lhs.rhs, b)
self.assertEquals(expr.rhs, c)
def test_nested_negate_expression(self):
a = ConstantExpression(10)
node_type = UnaryExpression.Negate
expr = UnaryExpression(node_type, UnaryExpression(node_type, a))
self.assertEquals(expr.node_type, node_type)
self.failUnless(
isinstance(expr.rhs, UnaryExpression),
"The right-hand side of the unary expression should be an unary expression as well, but is %s"
% expr.rhs.__class__)
self.assertEquals(expr.rhs.node_type, node_type)
self.assertEquals(expr.rhs.rhs, a)
def test_expression_length_can_only_accept_constant_expression_of_list_types(
self):
a = ConstantExpression(["a", "b"])
b = ConstantExpression("b")
node_type = UnaryExpression.CollectionLength
expr = UnaryExpression(node_type, a)
self.assertRaisesEx(
ValueError,
UnaryExpression,
node_type,
"some string",
exc_pattern=re.compile(
"The CollectionLength unary expression can only take ConstantExpressions that hold tuples or lists as parameters."
))
self.assertRaisesEx(
ValueError,
UnaryExpression,
node_type,
b,
exc_pattern=re.compile(
"The CollectionLength unary expression can only take ConstantExpressions that hold tuples or lists as parameters."
))
def test_expression_negate_of_a_constant_representation(self):
a = ConstantExpression(10)
node_type = UnaryExpression.Negate
expr = UnaryExpression(node_type, a)
self.assertEquals("negate(10)", str(expr))
