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_equal_of_two_constants(self): a = ConstantExpression(True) b = ConstantExpression(False) node_type = BinaryExpression.Equal 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_not_equal_expression_representation(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("((True != False) != None)", str(expr))
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_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_and_expression_representation(self): a = ConstantExpression(True) b = ConstantExpression(False) c = ConstantExpression(None) node_type = BinaryExpression.And expr = BinaryExpression(node_type, BinaryExpression(node_type, a, b), c) self.assertEquals("((True and False) and None)", 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_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_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_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_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_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_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_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_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_equal_of_two_constants_representation(self): a = ConstantExpression(["a", "b"]) node_type = UnaryExpression.CollectionLength expr = UnaryExpression(node_type, a) self.assertEquals("len(['a', 'b'])", str(expr))
def test_constant_expression_is_subtype_of_expression(self): expr = ConstantExpression(100) self.failUnless(isinstance(expr, Expression), "The ConstantExpression class instances must inherit from Expression.")
def test_expression_not_of_a_constant_representation(self): a = ConstantExpression(True) node_type = UnaryExpression.Not expr = UnaryExpression(node_type, a) self.assertEquals("(not True)", str(expr))
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))
def test_constant_expression_returns_informed_value_as_integer(self): int_expr = ConstantExpression(45) self.assertEquals(45, int_expr.evaluate())
def test_constant_expression_returns_informed_value_as_string(self): str_expr = ConstantExpression(u"str") self.assertEquals(u"str", str_expr.evaluate())
def nud(self): return ConstantExpression(self.value)