def test_order_rewrite_literal(self): "Tests rewrite of literal values" # Model the predicate: # foo < bar or foo >= bar or foo > zip or foo <= zip l = ast.Literal('foo') v = ast.Literal('bar') v2 = ast.Literal('zip') cmp1 = ast.CompareOperator('<', l, v) cmp2 = ast.CompareOperator('>=', l, v) cmp3 = ast.CompareOperator('>', l, v2) cmp4 = ast.CompareOperator('<=', l, v2) or1 = ast.LogicalOperator('or', cmp1, cmp2) or2 = ast.LogicalOperator('or', cmp3, cmp4) or3 = ast.LogicalOperator('or', or1, or2) # Rewrite foo < bar as True name = merge.node_name(cmp1, True) r = compare.order_rewrite(ast.dup(or3), name, cmp1, True) assert isinstance(r.left.left, ast.Constant) assert r.left.left.value == True assert isinstance(r.left.right, ast.Constant) assert r.left.right.value == False assert ASTPattern(or2).matches(r.right) # Rewrite foo < bar as False name = merge.node_name(cmp1, True) r = compare.order_rewrite(ast.dup(or3), name, cmp1, False) assert isinstance(r.left.left, ast.Constant) assert r.left.left.value == False assert isinstance(r.left.right, ast.Constant) assert r.left.right.value == True assert ASTPattern(or2).matches(r.right)
def test_contains_rewrite(self): s1 = ast.LiteralSet([ast.Number(1), ast.Number(2), ast.Number(3)]) s2 = ast.LiteralSet([ast.Number(1)]) s3 = ast.LiteralSet([ ast.Number(1), ast.Number(2), ast.Number(3), ast.Number(4), ast.Number(5) ]) s4 = ast.LiteralSet([ast.Number(6)]) s5 = ast.LiteralSet([ast.Number(2), ast.Number(3), ast.Number(4)]) l = ast.Literal('foo') c1 = ast.ContainsOperator(s1, l) c2 = ast.ContainsOperator(s2, l) c3 = ast.ContainsOperator(s3, l) c4 = ast.ContainsOperator(s4, l) c5 = ast.ContainsOperator(s5, l) # Rewrite set1 as True, s3 is super set, should be True name = merge.node_name(c1, True) r = contains.contains_rewrite(c3, name, c1, True) assert isinstance(r, ast.Constant) and r.value == True # Rewrite set1 as False, s3 is super set, should be trimed name = merge.node_name(c1, True) r = contains.contains_rewrite(c3, name, c1, False) assert len(r.left.value) == 2 assert ast.Number(4) in r.left.value assert ast.Number(5) in r.left.value # Rewrite set1 as True, s2 is sub set, should check value r = contains.contains_rewrite(c2, name, c1, True) assert len(r.left.value) == 1 # Rewrite set1 as False, s2 is subset, should be false r = contains.contains_rewrite(c2, name, c1, False) assert isinstance(r, ast.Constant) and r.value == False # Rewrite set1 as True, s4 has no overlap, should be false r = contains.contains_rewrite(c4, name, c1, True) assert isinstance(r, ast.Constant) and r.value == False # Rewrite set1 as False, s4 is no overlap, should check r = contains.contains_rewrite(c4, name, c1, False) assert len(r.left.value) == 1 assert ast.Number(6) in r.left.value # Rewrite set1 as True, s5 is has mostly overlap, should check # the negation of s1 - s5 r = contains.contains_rewrite(c5, name, c1, True) assert isinstance(r, ast.NegateOperator) assert isinstance(r.left, ast.ContainsOperator) assert len(r.left.left.value) assert ast.Number(1) in r.left.left.value
def test_equality_rewrite_diff_static(self): "Test an equality rewrite with different static values" l = ast.Literal('foo') s = ast.Literal('"test"') s.static = True s.static_val = "test" s1 = ast.Literal('"other"') s1.static = True s1.static_val = "other" cmp1 = ast.CompareOperator('=', l, s) cmp2 = ast.CompareOperator('=', l, s1) or1 = ast.LogicalOperator('or', cmp1, cmp2) # Rewrite foo = "test" as True # Left should be True, right should be False name = merge.node_name(cmp1, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp1, True) assert isinstance(r.left, ast.Constant) assert r.left.value == True assert isinstance(r.right, ast.Constant) assert r.right.value == False # Rewrite foo = "test" as False # Left should be False, right should be same name = merge.node_name(cmp1, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp1, False) assert isinstance(r.left, ast.Constant) assert r.left.value == False assert ASTPattern(cmp2).matches(r.right) # Rewrite foo = "other" as True # Left should be False, right should be True name = merge.node_name(cmp2, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp2, True) assert isinstance(r.left, ast.Constant) assert r.left.value == False assert isinstance(r.right, ast.Constant) assert r.right.value == True # Rewrite foo = "other" as False # Left should be same, right should be False name = merge.node_name(cmp2, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp2, False) assert ASTPattern(cmp1).matches(r.left) assert isinstance(r.right, ast.Constant) assert r.right.value == False
def test_equality_rewrite_static(self): "Test an equality rewrite with static values" l = ast.Literal('foo') s = ast.Literal('"test"') s.static = True s.static_val = "test" cmp1 = ast.CompareOperator('=', l, s) cmp2 = ast.CompareOperator('!=', l, s) or1 = ast.LogicalOperator('or', cmp1, cmp2) # Rewrite foo = "test" as True # Left should be True, right should be False name = merge.node_name(cmp1, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp1, True) assert isinstance(r.left, ast.Constant) assert r.left.value == True assert isinstance(r.right, ast.Constant) assert r.right.value == False # Rewrite foo = "test" as False # Left should be False, right should be True name = merge.node_name(cmp1, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp1, False) assert isinstance(r.left, ast.Constant) assert r.left.value == False assert isinstance(r.right, ast.Constant) assert r.right.value == True # Rewrite foo != "test" as True # Left should be False, right should be True name = merge.node_name(cmp2, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp2, True) assert isinstance(r.left, ast.Constant) assert r.left.value == False assert isinstance(r.right, ast.Constant) assert r.right.value == True # Rewrite foo != "test" as False # Left should be False, right should be True name = merge.node_name(cmp2, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp2, False) assert isinstance(r.left, ast.Constant) assert r.left.value == True assert isinstance(r.right, ast.Constant) assert r.right.value == False
def test_contains_rewrite(self): s1 = ast.LiteralSet([ast.Number(1), ast.Number(2), ast.Number(3)]) s2 = ast.LiteralSet([ast.Number(1)]) s3 = ast.LiteralSet([ast.Number(1), ast.Number(2), ast.Number(3), ast.Number(4), ast.Number(5)]) s4 = ast.LiteralSet([ast.Number(6)]) s5 = ast.LiteralSet([ast.Number(2), ast.Number(3), ast.Number(4)]) l = ast.Literal("foo") c1 = ast.ContainsOperator(s1, l) c2 = ast.ContainsOperator(s2, l) c3 = ast.ContainsOperator(s3, l) c4 = ast.ContainsOperator(s4, l) c5 = ast.ContainsOperator(s5, l) # Rewrite set1 as True, s3 is super set, should be True name = merge.node_name(c1, True) r = contains.contains_rewrite(c3, name, c1, True) assert isinstance(r, ast.Constant) and r.value == True # Rewrite set1 as False, s3 is super set, should be trimed name = merge.node_name(c1, True) r = contains.contains_rewrite(c3, name, c1, False) assert len(r.left.value) == 2 assert ast.Number(4) in r.left.value assert ast.Number(5) in r.left.value # Rewrite set1 as True, s2 is sub set, should check value r = contains.contains_rewrite(c2, name, c1, True) assert len(r.left.value) == 1 # Rewrite set1 as False, s2 is subset, should be false r = contains.contains_rewrite(c2, name, c1, False) assert isinstance(r, ast.Constant) and r.value == False # Rewrite set1 as True, s4 has no overlap, should be false r = contains.contains_rewrite(c4, name, c1, True) assert isinstance(r, ast.Constant) and r.value == False # Rewrite set1 as False, s4 is no overlap, should check r = contains.contains_rewrite(c4, name, c1, False) assert len(r.left.value) == 1 assert ast.Number(6) in r.left.value # Rewrite set1 as True, s5 is has mostly overlap, should check # the negation of s1 - s5 r = contains.contains_rewrite(c5, name, c1, True) assert isinstance(r, ast.NegateOperator) assert isinstance(r.left, ast.ContainsOperator) assert len(r.left.left.value) assert ast.Number(1) in r.left.left.value
def test_select_expr_negate(self): "Checks that a negate operation is not selected" l = ast.Literal('foo') n = ast.NegateOperator(l) name = merge.node_name(n) expr = merge.select_rewrite_expression(DEEP, name, [n]) assert expr == l
def test_select_expr_negate(self): "Checks that a negate operation is not selected" l = ast.Literal('foo') n = ast.NegateOperator(l) name = merge.node_name(n) expr = merge.select_rewrite_expression(name, [n]) assert expr == l
def test_select_expr_first(self): "Checks that first expression is selected" l = ast.Literal('foo') r = ast.Literal('bar') name = merge.node_name(l) expr = merge.select_rewrite_expression(name, [l, r]) assert expr == l
def test_select_expr_first(self): "Checks that first expression is selected" l = ast.Literal('foo') r = ast.Literal('bar') name = merge.node_name(l) expr = merge.select_rewrite_expression(DEEP, name, [l, r]) assert expr == l
def test_rewrite_norm(self): "Test a simple re-write" l = ast.Literal('foo') r = ast.Literal('bar') c = ast.LogicalOperator('or', l, r) name = merge.node_name(c) merge.rewrite_ast(c, name, l, True) assert isinstance(c.left, ast.Constant)
def test_rewrite_compare(self): "Checks that a compare rewrite uses compare module" l = ast.Literal('foo') r = ast.Literal('bar') n = ast.CompareOperator('>', l, r) name = merge.node_name(n) with patch('pypred.merge.compare.compare_rewrite') as c: merge.rewrite_ast(n, name, n, True) assert c.called
def test_rewrite_contains(self): "Checks that a contain rewrite uses contains module" l = ast.LiteralSet([ast.Number(1), ast.Number(2)]) r = ast.Literal('bar') c = ast.ContainsOperator(l, r) name = merge.node_name(c) with patch('pypred.merge.contains.contains_rewrite') as cr: merge.rewrite_ast(c, name, c, True) assert cr.called
def test_equality_rewrite_literals(self): "Test an equality rewrite with different literals" l = ast.Literal('foo') v = ast.Literal('bar') v2 = ast.Literal('baz') cmp1 = ast.CompareOperator('=', l, v) cmp2 = ast.CompareOperator('=', l, v2) or1 = ast.LogicalOperator('or', cmp1, cmp2) # Rewrite foo = bar as True # Left should be True, right should be unchanged name = merge.node_name(cmp1, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp1, True) assert isinstance(r.left, ast.Constant) assert r.left.value == True assert ASTPattern(cmp2).matches(r.right) # Rewrite foo = bar as False # Left should be False, right should be same name = merge.node_name(cmp1, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp1, False) assert isinstance(r.left, ast.Constant) assert r.left.value == False assert ASTPattern(cmp2).matches(r.right) # Rewrite foo = baz as True # Left should be same, right should be True name = merge.node_name(cmp2, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp2, True) assert ASTPattern(cmp1).matches(r.left) assert isinstance(r.right, ast.Constant) assert r.right.value == True # Rewrite foo = baz as False # Left should be same, right should be False name = merge.node_name(cmp2, True) r = compare.equality_rewrite(ast.dup(or1), name, cmp2, False) assert ASTPattern(cmp1).matches(r.left) assert isinstance(r.right, ast.Constant) assert r.right.value == False
def test_select_expr_compare(self): "Checks that a compare operation uses compare module" l = ast.Literal('foo') r = ast.Literal('bar') n = ast.CompareOperator('>', l, r) name = merge.node_name(n) with patch('pypred.merge.compare.select_rewrite_expression') as c: merge.select_rewrite_expression(DEEP, name, [n]) assert c.called
def test_select_expr_contains(self): "Checks that a contains operation uses contains module" l = ast.LiteralSet([ast.Number(1), ast.Number(2)]) r = ast.Literal('bar') c = ast.ContainsOperator(l, r) name = merge.node_name(c) with patch('pypred.merge.contains.select_rewrite_expression') as cr: merge.select_rewrite_expression(DEEP, name, [c]) assert cr.called
def test_select_expr_compare(self): "Checks that a compare operation uses compare module" l = ast.Literal('foo') r = ast.Literal('bar') n = ast.CompareOperator('>', l, r) name = merge.node_name(n) with patch('pypred.merge.compare.select_rewrite_expression') as c: merge.select_rewrite_expression(name, [n]) assert c.called
def test_select_expr_logical(self): "Checks that a logical operation is not selected" l = ast.Literal('foo') r = ast.Literal('bar') n = ast.LogicalOperator('or', l, r) name = merge.node_name(n) expr = merge.select_rewrite_expression(DEEP, name, [n]) assert expr == l n.left = None expr = merge.select_rewrite_expression(DEEP, name, [n]) assert expr == r
def test_select_expr_logical(self): "Checks that a logical operation is not selected" l = ast.Literal('foo') r = ast.Literal('bar') n = ast.LogicalOperator('or', l, r) name = merge.node_name(n) expr = merge.select_rewrite_expression(name, [n]) assert expr == l n.left = None expr = merge.select_rewrite_expression(name, [n]) assert expr == r
def test_select_rewrite_ord_literals(self): "Test rewrite selection for ordered with literals" l = ast.Literal('foo') v = ast.Literal('bar') v2 = ast.Literal('baz') cmp1 = ast.CompareOperator('>', l, v2) cmp2 = ast.CompareOperator('<', l, v) cmp3 = ast.CompareOperator('>', l, v) name = merge.node_name(cmp1, True) select = compare.select_rewrite_expression(name, [cmp1,cmp2,cmp3]) assert select is cmp2
def test_select_rewrite_eq(self): "Test rewrite selection for equality" l = ast.Literal('foo') v = ast.Number(42) v2 = ast.Number(11) cmp1 = ast.CompareOperator('=', l, v2) cmp2 = ast.CompareOperator('=', l, v) cmp3 = ast.CompareOperator('=', l, v) name = merge.node_name(cmp1, True) select = compare.select_rewrite_expression(name, [cmp1, cmp2, cmp3]) assert select is cmp2
def test_select_rewrite_ord_literals(self): "Test rewrite selection for ordered with literals" l = ast.Literal('foo') v = ast.Literal('bar') v2 = ast.Literal('baz') cmp1 = ast.CompareOperator('>', l, v2) cmp2 = ast.CompareOperator('<', l, v) cmp3 = ast.CompareOperator('>', l, v) name = merge.node_name(cmp1, True) select = compare.select_rewrite_expression(name, [cmp1, cmp2, cmp3]) assert select is cmp2
def test_select_rewrite_eq(self): "Test rewrite selection for equality" l = ast.Literal('foo') v = ast.Number(42) v2 = ast.Number(11) cmp1 = ast.CompareOperator('=', l, v2) cmp2 = ast.CompareOperator('=', l, v) cmp3 = ast.CompareOperator('=', l, v) name = merge.node_name(cmp1, True) select = compare.select_rewrite_expression(name, [cmp1,cmp2,cmp3]) assert select is cmp2
def test_select_rewrite_ord_numeric(self): "Test rewrite selection for ordered with numerics" l = ast.Literal('foo') v = ast.Number(42) v2 = ast.Number(11) v3 = ast.Number(100) cmp1 = ast.CompareOperator('>', l, v) cmp2 = ast.CompareOperator('<', l, v2) cmp3 = ast.CompareOperator('>', l, v3) name = merge.node_name(cmp1, True) select = compare.select_rewrite_expression(name, [cmp1,cmp2,cmp3]) assert select is cmp1
def test_select_rewrite_ord_numeric(self): "Test rewrite selection for ordered with numerics" l = ast.Literal('foo') v = ast.Number(42) v2 = ast.Number(11) v3 = ast.Number(100) cmp1 = ast.CompareOperator('>', l, v) cmp2 = ast.CompareOperator('<', l, v2) cmp3 = ast.CompareOperator('>', l, v3) name = merge.node_name(cmp1, True) select = compare.select_rewrite_expression(name, [cmp1, cmp2, cmp3]) assert select is cmp1
def test_select_rewrite(self): "Test rewrite selection" settings = merge.RefactorSettings.deep() s1 = ast.LiteralSet([ast.Number(1), ast.Number(2), ast.Number(3)]) s2 = ast.LiteralSet([ast.Number(1)]) s3 = ast.LiteralSet([ast.Number(1), ast.Number(2), ast.Number(3), ast.Number(4), ast.Number(5)]) l = ast.Literal("foo") c1 = ast.ContainsOperator(s1, l) c2 = ast.ContainsOperator(s2, l) c3 = ast.ContainsOperator(s3, l) name = merge.node_name(c1, True) select = contains.select_rewrite_expression(settings, name, [c1, c2, c3]) assert select is c1
def test_select_rewrite(self): "Test rewrite selection" settings = merge.RefactorSettings.deep() s1 = ast.LiteralSet([ast.Number(1), ast.Number(2), ast.Number(3)]) s2 = ast.LiteralSet([ast.Number(1)]) s3 = ast.LiteralSet([ast.Number(1), ast.Number(2), ast.Number(3), ast.Number(4), ast.Number(5)]) l = ast.Literal('foo') c1 = ast.ContainsOperator(s1, l) c2 = ast.ContainsOperator(s2, l) c3 = ast.ContainsOperator(s3, l) name = merge.node_name(c1, True) select = contains.select_rewrite_expression(settings, name, [c1, c2, c3]) assert select is c1
def test_select_rewrite_low_density(self): "Test rewrite selection" settings = merge.RefactorSettings.deep() nums = [ast.Number(x) for x in range(100)] s1 = ast.LiteralSet(nums) nums = [ast.Number(x) for x in range(100, 200)] s2 = ast.LiteralSet(nums) l = ast.Literal("foo") c1 = ast.ContainsOperator(s1, l) c2 = ast.ContainsOperator(s2, l) name = merge.node_name(c1, True) select = contains.select_rewrite_expression(settings, name, [c1, c2]) # Density is too low assert select is None
def test_select_rewrite_low_density(self): "Test rewrite selection" settings = merge.RefactorSettings.deep() nums = [ast.Number(x) for x in range(100)] s1 = ast.LiteralSet(nums) nums = [ast.Number(x) for x in range(100, 200)] s2 = ast.LiteralSet(nums) l = ast.Literal('foo') c1 = ast.ContainsOperator(s1, l) c2 = ast.ContainsOperator(s2, l) name = merge.node_name(c1, True) select = contains.select_rewrite_expression(settings, name, [c1, c2]) # Density is too low assert select is None
def test_order_rewrite_numeric(self): "Tests rewrite of numeric values" # Model the predicate: # foo < 25 or foo >= 50 or foo > 75 or foo <= 100 l = ast.Literal('foo') v = ast.Number(25) v1 = ast.Number(50) v2 = ast.Number(75) v3 = ast.Number(100) cmp1 = ast.CompareOperator('<', l, v) cmp2 = ast.CompareOperator('>=', l, v1) cmp3 = ast.CompareOperator('>', l, v2) cmp4 = ast.CompareOperator('<=', l, v3) or1 = ast.LogicalOperator('or', cmp1, cmp2) or2 = ast.LogicalOperator('or', cmp3, cmp4) or3 = ast.LogicalOperator('or', or1, or2) # Rewrite foo < 25 as true name = merge.node_name(cmp1, True) r = compare.order_rewrite(ast.dup(or3), name, cmp1, True) assert isinstance(r.left.left, ast.Constant) assert r.left.left.value == True assert isinstance(r.left.right, ast.Constant) assert r.left.right.value == False assert isinstance(r.right.left, ast.Constant) assert r.right.left.value == False assert isinstance(r.right.right, ast.Constant) assert r.right.right.value == True # Rewrite foo < 25 as false name = merge.node_name(cmp1, True) r = compare.order_rewrite(ast.dup(or3), name, cmp1, False) assert isinstance(r.left.left, ast.Constant) assert r.left.left.value == False # other cmps unchanges assert ASTPattern(cmp2).matches(r.left.right) assert ASTPattern(cmp3).matches(r.right.left) assert ASTPattern(cmp4).matches(r.right.right) # Rewrite foo >= 50 as true name = merge.node_name(cmp2, True) r = compare.order_rewrite(ast.dup(or3), name, cmp2, True) assert isinstance(r.left.left, ast.Constant) assert r.left.left.value == False assert isinstance(r.left.right, ast.Constant) assert r.left.right.value == True assert ASTPattern(cmp3).matches(r.right.left) assert ASTPattern(cmp4).matches(r.right.right) # Rewrite foo >= 50 as false name = merge.node_name(cmp2, True) r = compare.order_rewrite(ast.dup(or3), name, cmp2, False) assert ASTPattern(cmp1).matches(r.left.left) assert isinstance(r.left.right, ast.Constant) assert r.left.right.value == False assert isinstance(r.right.left, ast.Constant) assert r.right.left.value == False assert isinstance(r.right.right, ast.Constant) assert r.right.right.value == True # Rewrite foo > 75 as true name = merge.node_name(cmp3, True) r = compare.order_rewrite(ast.dup(or3), name, cmp3, True) assert isinstance(r.left.left, ast.Constant) assert r.left.left.value == False assert isinstance(r.left.right, ast.Constant) assert r.left.right.value == True assert isinstance(r.right.left, ast.Constant) assert r.right.left.value == True assert ASTPattern(cmp4).matches(r.right.right) # Rewrite foo > 75 as False name = merge.node_name(cmp3, True) r = compare.order_rewrite(ast.dup(or3), name, cmp3, False) assert ASTPattern(cmp1).matches(r.left.left) assert ASTPattern(cmp2).matches(r.left.right) assert isinstance(r.right.left, ast.Constant) assert r.right.left.value == False assert isinstance(r.right.right, ast.Constant) assert r.right.right.value == True # Rewrite foo <= 100 as True name = merge.node_name(cmp4, True) r = compare.order_rewrite(ast.dup(or3), name, cmp4, True) assert ASTPattern(cmp1).matches(r.left.left) assert ASTPattern(cmp2).matches(r.left.right) assert ASTPattern(cmp3).matches(r.right.left) assert isinstance(r.right.right, ast.Constant) assert r.right.right.value == True # Rewrite foo <= 100 as False name = merge.node_name(cmp4, True) r = compare.order_rewrite(ast.dup(or3), name, cmp4, False) assert isinstance(r.left.left, ast.Constant) assert r.left.left.value == False assert isinstance(r.left.right, ast.Constant) assert r.left.right.value == True assert isinstance(r.right.left, ast.Constant) assert r.right.left.value == True assert isinstance(r.right.right, ast.Constant) assert r.right.right.value == False
def test_names(self): n1 = ast.Literal("foo") assert ("Literal", "foo") == merge.node_name(n1) n2 = ast.Number(12) assert ("Number", 12) == merge.node_name(n2) n3 = ast.Constant(True) assert ("Constant", True) == merge.node_name(n3) n4 = ast.Regex("^tubez$") assert ("Regex", "^tubez$") == merge.node_name(n4) n5 = ast.Undefined() assert "Undefined" == merge.node_name(n5) n6 = ast.Empty() assert "Empty" == merge.node_name(n6) # Negate does not emit the operator! n7 = ast.NegateOperator(n3) assert ("Constant", True) == merge.node_name(n7) n8 = ast.CompareOperator('=', n1, n2) n8_name = merge.node_name(n8) assert ("CompareOperator", "=", ("Literal", "foo"), ("Number", 12)) == n8_name n8_static = merge.node_name(n8, True) assert ("CompareOperator", "equality", ("Literal", "foo"), ("Number", "static")) == n8_static n9 = ast.MatchOperator(n1, n4) n9_name = merge.node_name(n9) assert ("MatchOperator", ("Literal", "foo"), ("Regex", "^tubez$")) == n9_name n10 = ast.ContainsOperator(n1, n2) n10_name = merge.node_name(n10) assert ("ContainsOperator", ("Literal", "foo"), ("Number", 12.0)) == n10_name # Logical operator returns literal! n11 = ast.LogicalOperator('and', n1, n3) n11_name = merge.node_name(n11) assert ("Literal", "foo") == n11_name # Literal set just uses name n12 = ast.LiteralSet([n1, n2]) n12_name = merge.node_name(n12) assert "LiteralSet" == n12_name
def test_names(self): n1 = ast.Literal("foo") assert ("Literal", "foo") == merge.node_name(n1) n2 = ast.Number(12) assert ("Number", 12) == merge.node_name(n2) n3 = ast.Constant(True) assert ("Constant", True) == merge.node_name(n3) n4 = ast.Regex("^tubez$") assert ("Regex", "^tubez$") == merge.node_name(n4) n5 = ast.Undefined() assert "Undefined" == merge.node_name(n5) n6 = ast.Empty() assert "Empty" == merge.node_name(n6) # Negate does not emit the operator! n7 = ast.NegateOperator(n3) assert ("Constant", True) == merge.node_name(n7) n8 = ast.CompareOperator('=', n1, n2) n8_name = merge.node_name(n8) assert ("CompareOperator", "=", ("Literal", "foo"), ("Number", 12)) == n8_name n8_static = merge.node_name(n8, True) assert ("CompareOperator", "equality", ("Literal", "foo"), ("Number", "static")) == n8_static n9 = ast.MatchOperator(n1, n4) n9_name = merge.node_name(n9) assert ("MatchOperator", ("Literal", "foo"), ("Regex", "^tubez$")) == n9_name n10 = ast.ContainsOperator(n1, n2) n10_name = merge.node_name(n10) assert ("ContainsOperator", ("Literal", "foo"), ("Number", 12.0)) == n10_name # Logical operator returns literal! n11 = ast.LogicalOperator('and', n1, n3) n11_name = merge.node_name(n11) assert ("Literal", "foo") == n11_name