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_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_litset_eval(self): s = ast.LiteralSet([ast.Constant(True), ast.Literal('a'), ast.Literal('b')]) ctx = ast.EvalContext(MockPred(), {'a': 2, 'b': False}) res = s.eval(ctx) assert isinstance(res, frozenset) assert True in res assert False in res assert 2 in res
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_litset_static(self): s = ast.LiteralSet([ast.Constant(True), ast.Literal('\"a\"')]) pred = MockPred() s.static_resolve(pred) ctx = ast.EvalContext(pred, {'a': 2, 'b': False}) res = s.eval(ctx) assert s.static assert isinstance(res, set) assert True in res assert "a" in res
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_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_empty_set(self): "Test removing an empty literal set" s = ast.LiteralSet([]) c, r = optimizer.optimization_pass(s) assert c == 1 assert isinstance(r, ast.Empty)
def test_set_comparison_valid_args(self, type): a = ast.SetComparisonOperator(type, ast.Literal("foo"), ast.LiteralSet([ast.Literal("bar")])) valid, info = a.validate() assert valid