Update property based tests

Add tests for constant folding

Author: dflook

hypo_test/expressions.py

@@ -240,12 +240,14 @@ def arguments(draw, for_lambda=False) -> ast.arguments:
     allow_annotation = False if for_lambda else True
 
     args = draw(lists(arg(allow_annotation), max_size=2))
+    posonlyargs = draw(lists(arg(allow_annotation), max_size=2))
     kwonlyargs = draw(lists(arg(allow_annotation), max_size=2))
     vararg = draw(none() | arg(allow_annotation))
     kwarg = draw(none() | arg(allow_annotation))
     defaults=[]
     kw_defaults=draw(lists(none() | expression(), max_size=len(kwonlyargs), min_size=len(kwonlyargs)))
     return ast.arguments(
+        posonlyargs=posonlyargs,
         args=args,
         vararg=vararg,
         kwonlyargs=kwonlyargs,

hypo_test/folding.py

@@ -0,0 +1,44 @@
+from hypothesis import assume
+from hypothesis.strategies import integers, lists, binary, sampled_from, recursive, dictionaries, booleans, SearchStrategy, text, composite, one_of, floats, complex_numbers, characters, none
+import ast
+
+from expressions import NameConstant, Num
+
+leaves = NameConstant() | Num()
+
+@composite
+def BinOp(draw, expression) -> ast.BinOp:
+    op = draw(sampled_from([
+        ast.Add(),
+        ast.Sub(),
+        ast.Mult(),
+        ast.Div(),
+        ast.FloorDiv(),
+        ast.Mod(),
+        ast.Pow(),
+        ast.LShift(),
+        ast.RShift(),
+        ast.BitOr(),
+        ast.BitXor(),
+        ast.BitAnd(),
+        ast.MatMult()
+    ]))
+
+    le = draw(lists(expression, min_size=2, max_size=2))
+
+    return ast.BinOp(le[0], op, le[1])
+
+
+def expression() -> SearchStrategy:
+    return recursive(
+        leaves,
+        lambda expression:
+        BinOp(expression),
+        max_leaves=150
+    )
+
+@composite
+def FoldableExpression(draw) -> ast.Expression:
+    """ An eval expression """
+    e = draw(expression())
+    return ast.Expression(e)

hypo_test/module.py

@@ -269,4 +269,4 @@ def suite() -> SearchStrategy:
 @composite
 def Module(draw) -> ast.Module:
     b = draw(lists(suite(), min_size=1, max_size=10))
-    return ast.Module(body=b)
+    return ast.Module(body=b, type_ignores=[])

hypo_test/test.py

@@ -0,0 +1,74 @@
+import ast
+
+from datetime import timedelta
+from hypothesis import given, settings, Verbosity, note, HealthCheck
+
+from folding import FoldableExpression
+from patterns import Pattern
+from python_minifier import ModulePrinter
+from python_minifier.ast_compare import compare_ast
+from python_minifier.ast_printer import print_ast
+from python_minifier.expression_printer import ExpressionPrinter
+from expressions import Expression
+from module import Module
+from python_minifier.rename.mapper import add_parent
+from python_minifier.transforms.constant_folding import FoldConstants
+
+
+@given(node=Expression())
+@settings(report_multiple_bugs=False, deadline=timedelta(seconds=1), max_examples=100, suppress_health_check=[HealthCheck.too_slow]) #verbosity=Verbosity.verbose
+def test_expression(node):
+    assert isinstance(node, ast.AST)
+
+    note(ast.dump(node))
+    printer = ExpressionPrinter()
+    code = printer(node)
+    note(code)
+    compare_ast(node, ast.parse(code, 'test_expression', 'eval'))
+
+
+@given(node=Module())
+@settings(report_multiple_bugs=False, deadline=timedelta(seconds=1), max_examples=100, suppress_health_check=[HealthCheck.too_slow]) #verbosity=Verbosity.verbose
+def test_module(node):
+    assert isinstance(node, ast.Module)
+
+    note(ast.dump(node))
+    printer = ModulePrinter()
+    code = printer(node)
+    note(code)
+    compare_ast(node, ast.parse(code, 'test_module'))
+
+
+@given(node=Pattern())
+@settings(report_multiple_bugs=False, deadline=timedelta(seconds=2), max_examples=100, verbosity=Verbosity.verbose)
+def test_pattern(node):
+
+    module = ast.Module(
+        body=[ast.Match(subject=ast.Constant(value=None),
+                        cases=[
+                            ast.match_case(
+                                pattern=node,
+                                guard=None,
+                                body=[ast.Pass()]
+                            )
+                        ])],
+        type_ignores=[]
+    )
+
+    printer = ModulePrinter()
+    code = printer(module)
+    note(code)
+    compare_ast(module, ast.parse(code, 'test_pattern'))
+
+@given(node=FoldableExpression())
+@settings(report_multiple_bugs=False, deadline=timedelta(seconds=1), max_examples=100000, suppress_health_check=[HealthCheck.too_slow]) #verbosity=Verbosity.verbose
+def test_folding(node):
+    assert isinstance(node, ast.AST)
+    note(print_ast(node))
+
+    add_parent(node)
+
+    constant_folder = FoldConstants()
+
+    # The constant folder asserts the value is correct
+    constant_folder(node)