Disable hypothesis on 2.6.9

pytest/test_fstring.py

@@ -1,15 +1,19 @@
 # std
-import os
 # test
-import pytest
-import hypothesis
-from hypothesis import strategies as st
-# uncompyle6
 from uncompyle6 import PYTHON_VERSION, deparse_code
+import pytest
+pytestmark = pytest.mark.skipif(PYTHON_VERSION <= 2.6,
+                                reason='hypothesis needs 2.7 or later')
+if PYTHON_VERSION > 2.6:
+
+    import hypothesis
+    from hypothesis import strategies as st
+
+    # uncompyle6
 
 
-@st.composite
-def expressions(draw):
+    @st.composite
+    def expressions(draw):
         # todo : would be nice to generate expressions using hypothesis however
         # this is pretty involved so for now just use a corpus of expressions
         # from which to select.
@@ -31,8 +35,8 @@ def expressions(draw):
         )))
 
 
-@st.composite
-def format_specifiers(draw):
+    @st.composite
+    def format_specifiers(draw):
         """
         Generate a valid format specifier using the rules:
 
@@ -81,8 +85,8 @@ def format_specifiers(draw):
         return ''.join((fill_align, sign, pound, zero, width, comma, precision, type_,))
 
 
-@st.composite
-def fstrings(draw):
+    @st.composite
+    def fstrings(draw):
         """
         Generate a valid f-string.
         See https://www.python.org/dev/peps/pep-0498/#specification
@@ -111,9 +115,9 @@ def fstrings(draw):
         return "f{}'{}'".format('r' if is_raw else '', content)
 
 
-@pytest.mark.skipif(PYTHON_VERSION < 3.6, reason='need at least python 3.6')
-@hypothesis.given(format_specifiers())
-def test_format_specifiers(format_specifier):
+    @pytest.mark.skipif(PYTHON_VERSION < 3.6, reason='need at least python 3.6')
+    @hypothesis.given(format_specifiers())
+    def test_format_specifiers(format_specifier):
         """Verify that format_specifiers generates valid specifiers"""
         try:
             exec('"{:' + format_specifier + '}".format(0)')
@@ -122,7 +126,7 @@ def test_format_specifiers(format_specifier):
                 raise
 
 
-def run_test(text):
+    def run_test(text):
         hypothesis.assume(len(text))
         hypothesis.assume("f'{" in text)
         expr = text + '\n'
@@ -133,18 +137,18 @@ def run_test(text):
             assert 'dis(' + deparsed.text.strip('\n') + ')' == 'dis(' + expr.strip('\n') + ')'
 
 
-@pytest.mark.skipif(PYTHON_VERSION < 3.6, reason='need at least python 3.6')
-@hypothesis.given(fstrings())
-def test_uncompyle_fstring(fstring):
+    @pytest.mark.skipif(PYTHON_VERSION < 3.6, reason='need at least python 3.6')
+    @hypothesis.given(fstrings())
+    def test_uncompyle_fstring(fstring):
         """Verify uncompyling fstring bytecode"""
         run_test(fstring)
 
 
-@pytest.mark.skipif(PYTHON_VERSION < 3.6, reason='need at least python 3.6')
-@pytest.mark.parametrize('fstring', [
+    @pytest.mark.skipif(PYTHON_VERSION < 3.6, reason='need at least python 3.6')
+    @pytest.mark.parametrize('fstring', [
         "f'{abc}{abc!s}'",
         "f'{abc}0'",
-])
-def test_uncompyle_direct(fstring):
+    ])
+    def test_uncompyle_direct(fstring):
         """useful for debugging"""
         run_test(fstring)

pytest/test_function_call.py

@@ -1,20 +1,21 @@
-# std
 import string
-# 3rd party
-from hypothesis import given, assume, example, settings, strategies as st
-import pytest
-# uncompyle
-from validate import validate_uncompyle
-from test_fstring import expressions
 from uncompyle6 import PYTHON_VERSION
+import pytest
+pytestmark = pytest.mark.skip(PYTHON_VERSION < 2.7,
+                              reason="need at least Python 2.7")
 
-alpha = st.sampled_from(string.ascii_lowercase)
-numbers = st.sampled_from(string.digits)
-alphanum = st.sampled_from(string.ascii_lowercase + string.digits)
+if PYTHON_VERSION > 2.6:
+    from hypothesis import given, assume, example, settings, strategies as st
+    from validate import validate_uncompyle
+    from test_fstring import expressions
+
+    alpha = st.sampled_from(string.ascii_lowercase)
+    numbers = st.sampled_from(string.digits)
+    alphanum = st.sampled_from(string.ascii_lowercase + string.digits)
 
 
-@st.composite
-def function_calls(draw,
+    @st.composite
+    def function_calls(draw,
                        min_keyword_args=0, max_keyword_args=5,
                        min_positional_args=0, max_positional_args=5,
                        min_star_args=0, max_star_args=1,
@@ -78,12 +79,12 @@ def function_calls(draw,
         return function_call
 
 
-def test_function_no_args():
+    def test_function_no_args():
         validate_uncompyle("fn()")
 
-@pytest.mark.skipif(PYTHON_VERSION < 2.7,
+    @pytest.mark.skipif(PYTHON_VERSION < 2.7,
                         reason="need at least Python 2.7")
-def isolated_function_calls(which):
+    def isolated_function_calls(which):
         """
         Returns a strategy for generating function calls, but isolated to
         particular types of arguments, for example only positional arguments.
@@ -107,7 +108,7 @@ def isolated_function_calls(which):
         return function_calls(**kwargs)
 
 
-with settings(max_examples=25):
+    with settings(max_examples=25):
 
         @pytest.mark.skipif(PYTHON_VERSION < 2.7,
                             reason="need at least Python 2.7")
@@ -138,47 +139,47 @@ with settings(max_examples=25):
             validate_uncompyle(expr)
 
 
-@pytest.mark.xfail()
-def test_BUILD_CONST_KEY_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_BUILD_CONST_KEY_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
         validate_uncompyle("fn(w=0,m=0,**v)")
 
 
-@pytest.mark.xfail()
-def test_BUILD_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_BUILD_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
         validate_uncompyle("fn(a=0,**g)")
 
 
-@pytest.mark.xfail()
-def test_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_CALL_FUNCTION_EX():
         validate_uncompyle("fn(*g,**j)")
 
 
-@pytest.mark.xfail()
-def test_BUILD_MAP_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_BUILD_MAP_CALL_FUNCTION_EX():
         validate_uncompyle("fn(*z,u=0)")
 
 
-@pytest.mark.xfail()
-def test_BUILD_TUPLE_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_BUILD_TUPLE_CALL_FUNCTION_EX():
         validate_uncompyle("fn(**a)")
 
 
-@pytest.mark.xfail()
-def test_BUILD_MAP_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_BUILD_MAP_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
         validate_uncompyle("fn(b,b,b=0,*a)")
 
 
-@pytest.mark.xfail()
-def test_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
         validate_uncompyle("fn(*c,v)")
 
 
-@pytest.mark.xfail()
-def test_BUILD_CONST_KEY_MAP_CALL_FUNCTION_EX():
+    @pytest.mark.xfail()
+    def test_BUILD_CONST_KEY_MAP_CALL_FUNCTION_EX():
         validate_uncompyle("fn(i=0,y=0,*p)")
 
 
-@pytest.mark.skip(reason='skipping property based test until all individual tests are passing')
-@given(function_calls())
-def test_function_call(function_call):
+    @pytest.mark.skip(reason='skipping property based test until all individual tests are passing')
+    @given(function_calls())
+    def test_function_call(function_call):
         validate_uncompyle(function_call)

pytest/test_single_compile.py

@@ -1,9 +1,10 @@
 import pytest
 from uncompyle6 import PYTHON_VERSION, deparse_code
-
-@pytest.mark.skip(PYTHON_VERSION < 2.7,
+pytestmark = pytest.mark.skip(PYTHON_VERSION < 2.7,
                               reason="need at least Python 2.7")
-def test_single_mode():
+
+if PYTHON_VERSION > 2.6:
+    def test_single_mode():
         single_expressions = (
             'i = 1',
             'i and (j or k)',