Comment out PEP 461 tests for now

Python 2.x doesn't support bytes % characters like '%b'

Author: edschofield

src/future/tests/base.py

@@ -377,11 +377,6 @@ def expectedFailurePY3(func):
         return func
     return unittest.expectedFailure(func)
 
-def expectedFailurePY33_and_PY34(func):
-    if sys.version_info[:2] not in {(3, 3), (3, 4)}:
-        return func
-    return unittest.expectedFailure(func)
-
 def expectedFailurePY26(func):
     if not PY26:
         return func

tests/test_future/test_bytes.py

@@ -8,7 +8,7 @@
 from future import utils
 
 from numbers import Integral
-from future.tests.base import unittest, expectedFailurePY2, expectedFailurePY33_and_PY34
+from future.tests.base import unittest, expectedFailurePY2
 
 
 TEST_UNICODE_STR = u'ℝεα∂@ßʟ℮ ☂ℯṧт υηḯ¢☺ḓ℮'
@@ -552,106 +552,103 @@ def test_maketrans(self):
         self.assertRaises(ValueError, bytes.maketrans, b'abc', b'xyzq')
         self.assertRaises(TypeError, bytes.maketrans, 'abc', 'def')
 
-    @expectedFailurePY33_and_PY34
-    def test_mod(self):
-        """
-        From Py3.5 test suite (post-PEP 461).
-
-        The bytes mod code is in _PyBytes_Format() in bytesobject.c in Py3.5.
-        """
-        b = b'hello, %b!'
-        orig = b
-        b = b % b'world'
-        self.assertEqual(b, b'hello, world!')
-        self.assertEqual(orig, b'hello, %b!')
-        self.assertFalse(b is orig)
-        b = b'%s / 100 = %d%%'
-        a = b % (b'seventy-nine', 79)
-        self.assertEqual(a, b'seventy-nine / 100 = 79%')
-
-    @expectedFailurePY33_and_PY34
-    def test_imod(self):
-        """
-        From Py3.5 test suite (post-PEP 461)
-        """
-        # if (3, 0) <= sys.version_info[:2] < (3, 5):
-        #     raise unittest.SkipTest('bytes % not yet implemented on Py3.0-3.4')
-        b = bytes(b'hello, %b!')
-        orig = b
-        b %= b'world'
-        self.assertEqual(b, b'hello, world!')
-        self.assertEqual(orig, b'hello, %b!')
-        self.assertFalse(b is orig)
-        b = bytes(b'%s / 100 = %d%%')
-        b %= (b'seventy-nine', 79)
-        self.assertEqual(b, b'seventy-nine / 100 = 79%')
-
-    @expectedFailurePY33_and_PY34
-    def test_mod_pep_461(self):
-        """
-        Test for the PEP 461 functionality (resurrection of %s formatting for
-        bytes).
-        """
-        b1 = bytes(b'abc%b')
-        b2 = b1 % b'def'
-        self.assertEqual(b2, b'abcdef')
-        self.assertTrue(isinstance(b2, bytes))
-        self.assertEqual(type(b2), bytes)
-        b3 = b1 % bytes(b'def')
-        self.assertEqual(b3, b'abcdef')
-        self.assertTrue(isinstance(b3, bytes))
-        self.assertEqual(type(b3), bytes)
-
-        # %s is supported for backwards compatibility with Py2's str
-        b4 = bytes(b'abc%s')
-        b5 = b4 % b'def'
-        self.assertEqual(b5, b'abcdef')
-        self.assertTrue(isinstance(b5, bytes))
-        self.assertEqual(type(b5), bytes)
-        b6 = b4 % bytes(b'def')
-        self.assertEqual(b6, b'abcdef')
-        self.assertTrue(isinstance(b6, bytes))
-        self.assertEqual(type(b6), bytes)
-
-        self.assertEqual(bytes(b'%c') % 48, b'0')
-        self.assertEqual(bytes(b'%c') % b'a', b'a')
-
-        # For any numeric code %x, formatting of
-        #     b"%x" % val
-        # is supposed to be equivalent to
-        #     ("%x" % val).encode("ascii")
-        for code in b'xdiouxXeEfFgG':
-            bytechar = bytes([code])
-            pct_str = u"%" + bytechar.decode('ascii')
-            for val in range(300):
-                self.assertEqual(bytes(b"%" + bytechar) % val,
-                                 (pct_str % val).encode("ascii"))
-
-        with self.assertRaises(TypeError):
-            bytes(b'%b') % 3.14
-            # Traceback (most recent call last):
-            # ...
-            # TypeError: b'%b' does not accept 'float'
-
-        with self.assertRaises(TypeError):
-            bytes(b'%b') % 'hello world!'
-            # Traceback (most recent call last):
-            # ...
-            # TypeError: b'%b' does not accept 'str'
-
-        self.assertEqual(bytes(b'%a') % 3.14, b'3.14')
-
-        self.assertEqual(bytes(b'%a') % b'abc', b"b'abc'")
-        self.assertEqual(bytes(b'%a') % bytes(b'abc'), b"b'abc'")
-
-        self.assertEqual(bytes(b'%a') % 'def', b"'def'")
-
-        # PEP 461 was updated after an Py3.5 alpha release to specify that %r is now supported
-        # for compatibility: http://legacy.python.org/dev/peps/pep-0461/#id16
-        assert bytes(b'%r' % b'abc') == bytes(b'%a' % b'abc')
-
-        # with self.assertRaises(TypeError):
-        #     bytes(b'%r' % 'abc')
+    # def test_mod(self):
+    #     """
+    #     From Py3.5 test suite (post-PEP 461).
+    #
+    #     The bytes mod code is in _PyBytes_Format() in bytesobject.c in Py3.5.
+    #     """
+    #     b = b'hello, %b!'
+    #     orig = b
+    #     b = b % b'world'
+    #     self.assertEqual(b, b'hello, world!')
+    #     self.assertEqual(orig, b'hello, %b!')
+    #     self.assertFalse(b is orig)
+    #     b = b'%s / 100 = %d%%'
+    #     a = b % (b'seventy-nine', 79)
+    #     self.assertEqual(a, b'seventy-nine / 100 = 79%')
+
+    # def test_imod(self):
+    #     """
+    #     From Py3.5 test suite (post-PEP 461)
+    #     """
+    #     # if (3, 0) <= sys.version_info[:2] < (3, 5):
+    #     #     raise unittest.SkipTest('bytes % not yet implemented on Py3.0-3.4')
+    #     b = bytes(b'hello, %b!')
+    #     orig = b
+    #     b %= b'world'
+    #     self.assertEqual(b, b'hello, world!')
+    #     self.assertEqual(orig, b'hello, %b!')
+    #     self.assertFalse(b is orig)
+    #     b = bytes(b'%s / 100 = %d%%')
+    #     b %= (b'seventy-nine', 79)
+    #     self.assertEqual(b, b'seventy-nine / 100 = 79%')
+
+    # def test_mod_pep_461(self):
+    #     """
+    #     Test for the PEP 461 functionality (resurrection of %s formatting for
+    #     bytes).
+    #     """
+    #     b1 = bytes(b'abc%b')
+    #     b2 = b1 % b'def'
+    #     self.assertEqual(b2, b'abcdef')
+    #     self.assertTrue(isinstance(b2, bytes))
+    #     self.assertEqual(type(b2), bytes)
+    #     b3 = b1 % bytes(b'def')
+    #     self.assertEqual(b3, b'abcdef')
+    #     self.assertTrue(isinstance(b3, bytes))
+    #     self.assertEqual(type(b3), bytes)
+    #
+    #     # %s is supported for backwards compatibility with Py2's str
+    #     b4 = bytes(b'abc%s')
+    #     b5 = b4 % b'def'
+    #     self.assertEqual(b5, b'abcdef')
+    #     self.assertTrue(isinstance(b5, bytes))
+    #     self.assertEqual(type(b5), bytes)
+    #     b6 = b4 % bytes(b'def')
+    #     self.assertEqual(b6, b'abcdef')
+    #     self.assertTrue(isinstance(b6, bytes))
+    #     self.assertEqual(type(b6), bytes)
+    #
+    #     self.assertEqual(bytes(b'%c') % 48, b'0')
+    #     self.assertEqual(bytes(b'%c') % b'a', b'a')
+    #
+    #     # For any numeric code %x, formatting of
+    #     #     b"%x" % val
+    #     # is supposed to be equivalent to
+    #     #     ("%x" % val).encode("ascii")
+    #     for code in b'xdiouxXeEfFgG':
+    #         bytechar = bytes([code])
+    #         pct_str = u"%" + bytechar.decode('ascii')
+    #         for val in range(300):
+    #             self.assertEqual(bytes(b"%" + bytechar) % val,
+    #                              (pct_str % val).encode("ascii"))
+    #
+    #     with self.assertRaises(TypeError):
+    #         bytes(b'%b') % 3.14
+    #         # Traceback (most recent call last):
+    #         # ...
+    #         # TypeError: b'%b' does not accept 'float'
+    #
+    #     with self.assertRaises(TypeError):
+    #         bytes(b'%b') % 'hello world!'
+    #         # Traceback (most recent call last):
+    #         # ...
+    #         # TypeError: b'%b' does not accept 'str'
+    #
+    #     self.assertEqual(bytes(b'%a') % 3.14, b'3.14')
+    #
+    #     self.assertEqual(bytes(b'%a') % b'abc', b"b'abc'")
+    #     self.assertEqual(bytes(b'%a') % bytes(b'abc'), b"b'abc'")
+    #
+    #     self.assertEqual(bytes(b'%a') % 'def', b"'def'")
+    #
+    #     # PEP 461 was updated after an Py3.5 alpha release to specify that %r is now supported
+    #     # for compatibility: http://legacy.python.org/dev/peps/pep-0461/#id16
+    #     assert bytes(b'%r' % b'abc') == bytes(b'%a' % b'abc')
+    #
+    #     # with self.assertRaises(TypeError):
+    #     #     bytes(b'%r' % 'abc')
 
     @expectedFailurePY2
     def test_multiple_inheritance(self):