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.SetComparisonOperator("contains", s1, l) c2 = ast.SetComparisonOperator("contains", s2, l) c3 = ast.SetComparisonOperator("contains", s3, l) c4 = ast.SetComparisonOperator("contains", s4, l) c5 = ast.SetComparisonOperator("contains", 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.SetComparisonOperator) assert len(r.left.left.value) assert ast.Number(1) in r.left.left.value
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.SetComparisonOperator("contains", s1, l) c2 = ast.SetComparisonOperator("contains", 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_contains_all_valid(self): l = ast.Literal("l") r = ast.Literal("r") a = ast.SetComparisonOperator("all", l, r) d = {"l": [40, 41, 42], "r": [41, 42]} res, ctx = a.analyze(MockPred(), d) assert res assert ctx.literals["l"] == [40, 41, 42] assert ctx.literals["r"] == [41, 42]
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.SetComparisonOperator("contains", 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_is_any_valid(self): l = ast.Literal("l") r = ast.Literal("r") a = ast.SetComparisonOperator("is_any", l, r) d = {"l": 42, "r": [42]} res, ctx = a.analyze(MockPred(), d) assert res assert ctx.literals["l"] == 42 assert ctx.literals["r"] == [42]
def test_undef_contains(self, type): "Tests removing an Empty contains X" u = ast.Undefined() v = ast.Literal('foo') cn = ast.SetComparisonOperator(type, u, v) c, r = optimizer.optimization_pass(cn) assert c == 1 assert isinstance(r, ast.Constant) assert r.value == False
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.SetComparisonOperator("contains", 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_is_any_empty(self): l = ast.Literal("l") r = ast.Literal("r") a = ast.SetComparisonOperator("is_any", l, r) d = {"l": 5, "r": []} res, ctx = a.analyze(MockPred(), d) assert not res assert "not in right side" in ctx.failed[0] assert ctx.literals["l"] == 5 assert ctx.literals["r"] == []
def test_contains_all_empty(self): l = ast.Literal("l") r = ast.Literal("r") a = ast.SetComparisonOperator("all", l, r) d = {"l": [], "r": [5]} res, ctx = a.analyze(MockPred(), d) assert not res assert "not in left side" in ctx.failed[0] assert ctx.literals["l"] == [] assert ctx.literals["r"] == [5]
def test_contains_any_undef(self): l = ast.Literal("l") r = ast.Literal("r") a = ast.SetComparisonOperator("any", l, r) d = {"r": [5]} res, ctx = a.analyze(MockPred(), d) assert not res assert "none of [5] items in left side" in ctx.failed[0] assert ctx.literals["l"] == ast.Undefined() assert ctx.literals["r"] == [5]
def test_set_comparison_iter_invalid(self, type): l = ast.Literal("l") r = ast.Literal("r") a = ast.SetComparisonOperator(type, l, r) d = {"l": [1, 2], "r": 2} res, ctx = a.analyze(MockPred(), d) assert not res assert "is not iterable" in ctx.failed[0] assert ctx.literals["l"] == [1, 2] assert ctx.literals["r"] == 2
def test_set_compasrison_contains_invalid(self, type): l = ast.Literal("l") r = ast.Literal("r") a = ast.SetComparisonOperator(type, l, r) d = {"l": 1, "r": 1} res, ctx = a.analyze(MockPred(), d) assert not res assert "does not support contains" in ctx.failed[0] assert ctx.literals["l"] == 1 assert ctx.literals["r"] == 1
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.SetComparisonOperator("contains", s1, l) c2 = ast.SetComparisonOperator("contains", s2, l) c3 = ast.SetComparisonOperator("contains", s3, l) name = merge.node_name(c1, True) select = contains.select_rewrite_expression(settings, name, [c1, c2, c3]) assert select is c1
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.SetComparisonOperator("contains", n1, n2) n10_name = merge.node_name(n10) assert ("SetComparisonOperator", "contains", ("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") == compact.node_name(n1) n2 = ast.Number(12) assert ("Number", 12) == compact.node_name(n2) n3 = ast.Constant(True) assert ("Constant", True) == compact.node_name(n3) n4 = ast.Regex("^tubez$") assert ("Regex", "^tubez$") == compact.node_name(n4) n5 = ast.Undefined() assert "Undefined" == compact.node_name(n5) n6 = ast.Empty() assert "Empty" == compact.node_name(n6) n7 = ast.NegateOperator(n3) assert ("NegateOperator", ("Constant", True)) == compact.node_name(n7) n8 = ast.CompareOperator('=', n1, n2) n8_name = compact.node_name(n8) assert ("CompareOperator", "=", ("Literal", "foo"), ("Number", 12)) == n8_name n9 = ast.MatchOperator(n1, n4) n9_name = compact.node_name(n9) assert ("MatchOperator", ("Literal", "foo"), ("Regex", "^tubez$")) == n9_name n10 = ast.SetComparisonOperator("contains", n1, n2) n10_name = compact.node_name(n10) assert ("SetComparisonOperator", "contains", ("Literal", "foo"), ("Number", 12.0)) == n10_name n11 = ast.LogicalOperator('and', n1, n3) n11_name = compact.node_name(n11) assert ("LogicalOperator", "and", ("Literal", "foo"), ("Constant", True)) == n11_name
def test_set_comparison_bad(self, type): a = ast.SetComparisonOperator(type, ast.Literal("foo"), ast.Literal("bar")) valid, info = a.validate() assert not valid assert "must take a set" in info["errors"][0]
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
def test_contains_bad(self): a = ast.SetComparisonOperator("contains", ast.Literal("foo"), ast.Empty()) valid, info = a.validate() assert not valid assert "must take a literal or constant" in info["errors"][0]
def test_contains_valid_args(self): a = ast.SetComparisonOperator("contains", ast.Literal("foo"), ast.Literal("bar")) valid, info = a.validate() assert valid