Example #1
0
    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)
Example #2
0
    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)
Example #3
0
    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
Example #4
0
    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
Example #5
0
    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
Example #6
0
    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
Example #7
0
    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
Example #8
0
    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
Example #9
0
 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
Example #10
0
 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
Example #11
0
 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
Example #12
0
 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
Example #13
0
 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)
Example #14
0
 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)
Example #15
0
 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
Example #16
0
 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
Example #17
0
 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
Example #18
0
 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
Example #19
0
    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
Example #20
0
    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
Example #21
0
    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
Example #22
0
    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
Example #23
0
    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
Example #24
0
    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
Example #25
0
 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
Example #26
0
 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
Example #27
0
    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
Example #28
0
    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
Example #29
0
    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
Example #30
0
    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
Example #31
0
    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
Example #32
0
    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
Example #33
0
    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
Example #34
0
    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
Example #35
0
    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
Example #36
0
    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
Example #37
0
    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
Example #38
0
    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
Example #39
0
    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
Example #40
0
    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