def test_ast_expression_left_operator_right_arithmeticcomparison_null( self): left_expr = ast.NullExpression(context) right_expr = ast.NullExpression(context) self.assertExpressionTests('ge', left_expr, right_expr, True) self.assertExpressionTests('gt', left_expr, right_expr, False) self.assertExpressionTests('le', left_expr, right_expr, True) self.assertExpressionTests('lt', left_expr, right_expr, False)
def test_ast_unconditional_comprehension(self): iterable = (None, ) iterable_expression = ast.LiteralExpressionBase.from_value( context, iterable) comprehension = ast.ComprehensionExpression( context, ast.NullExpression(context), 'test', iterable_expression) self.assertEqual(comprehension.evaluate(None), iterable)
def test_ast_conditional_comprehension_error(self): iterable_expression = ast.SymbolExpression(context, 'iterable') comprehension = ast.ComprehensionExpression( context, ast.NullExpression(context), 'member', iterable_expression) with self.assertRaises(errors.EvaluationError): comprehension.evaluate({'iterable': None})
def p_expression_decode(self, p): '''expression : expression COMMA expression ''' left, op, right, replacement = p[1], "==", ast.NullExpression( self.context), p[3] op_name = self.op_names[op] p[0] = NVLResolutionExpression(self.context, op_name, left, right, replacement).reduce()
def test_ast_expression_getitem_error(self): for container in self.containers.values(): member = ast.FloatExpression(context, 100.0) with self.assertRaises(errors.LookupError): ast.GetItemExpression(context, container, member).evaluate(None) member = ast.FloatExpression(context, 1.1) with self.assertRaises(errors.EvaluationError): ast.GetItemExpression(context, container, member).evaluate(None) member = ast.NullExpression(context) with self.assertRaises(errors.EvaluationError): ast.GetItemExpression(context, container, member)
def test_ast_expression_attribute_safe(self): symbol = ast.StringExpression(context, 'foo') expression = ast.GetAttributeExpression(context, symbol, 'undefined', safe=True) expression.evaluate(None) expression = ast.GetAttributeExpression(context, ast.NullExpression(context), 'undefined', safe=True) self.assertIsNone(expression.evaluate(None))
def test_ast_expression_left_operator_right_fuzzycomparison_nulls(self): darth = ast.StringExpression(context, 'Darth Vader') null = ast.NullExpression(context) for operation, left, right in itertools.product( ('eq_fzm', 'eq_fzs'), (darth, null), (darth, null)): self.assertExpressionTests(operation, left_value=left, right_value=right, equals_value=left is right) for operation, left, right in itertools.product( ('ne_fzm', 'ne_fzs'), (darth, null), (darth, null)): self.assertExpressionTests(operation, left_value=left, right_value=right, equals_value=left is not right)
def test_ast_comprehension_result_type(self): iterable = (None, ) iterable_expression = ast.LiteralExpressionBase.from_value( context, iterable) comprehension = ast.ComprehensionExpression( context, ast.NullExpression(context), 'test', iterable_expression) self.assertEqual(comprehension.result_type, types.DataType.ARRAY(types.DataType.NULL)) comprehension = ast.ComprehensionExpression( context, ast.FloatExpression(context, 1), 'test', iterable_expression) self.assertEqual(comprehension.result_type, types.DataType.ARRAY(types.DataType.FLOAT))
def test_ast_expression_literal_array(self): self.assertLiteralTests(ast.ArrayExpression, tuple(), tuple((ast.NullExpression(self.context), )))
def test_ast_expression_literal_null(self): expression = ast.NullExpression(self.context) self.assertIsNone(expression.evaluate(None))
import rule_engine.ast as ast import rule_engine.engine as engine __all__ = ('LiteralExpressionTests', ) context = engine.Context() context.builtins = engine.Builtins.from_defaults( {'test': { 'one': 1.0, 'two': 2.0 }}) # literal expressions which should evaluate to false falseish = (ast.ArrayExpression(context, tuple()), ast.BooleanExpression(context, False), ast.FloatExpression(context, 0.0), ast.NullExpression(context), ast.StringExpression(context, '')) # literal expressions which should evaluate to true trueish = (ast.ArrayExpression(context, tuple( (ast.NullExpression(context), ))), ast.ArrayExpression(context, tuple((ast.FloatExpression(context, 1.0), ))), ast.BooleanExpression(context, True), ast.DatetimeExpression(context, datetime.datetime.now()), ast.FloatExpression(context, float('-inf')), ast.FloatExpression(context, -1.0), ast.FloatExpression(context, 1.0), ast.FloatExpression(context, float('inf')), ast.StringExpression(context, 'non-empty')) class UnknownType(object):
import rule_engine.ast as ast import rule_engine.engine as engine __all__ = ('LiteralExpressionTests',) context = engine.Context() context.builtins = engine.Builtins.from_defaults( {'test': {'one': 1.0, 'two': 2.0}} ) # literal expressions which should evaluate to false falseish = ( ast.ArrayExpression(context, tuple()), ast.BooleanExpression(context, False), ast.FloatExpression(context, 0.0), ast.NullExpression(context), ast.StringExpression(context, '') ) # literal expressions which should evaluate to true trueish = ( ast.ArrayExpression(context, tuple((ast.NullExpression(context),))), ast.BooleanExpression(context, True), ast.DatetimeExpression(context, datetime.datetime.now()), ast.FloatExpression(context, float('-inf')), ast.FloatExpression(context, -1.0), ast.FloatExpression(context, 1.0), ast.FloatExpression(context, float('inf')), ast.StringExpression(context, 'non-empty') ) class UnknownType(object):