Changes in anticipation of stricter str vs. bytes enforcement.

Lib/test/test_bytes.py

@@ -75,8 +75,8 @@ class BytesTest(unittest.TestCase):
         self.assertEqual(repr(bytes([0])), "b'\\x00'")
         self.assertEqual(repr(bytes([0, 1, 254, 255])),
                          "b'\\x00\\x01\\xfe\\xff'")
-        self.assertEqual(repr(bytes('abc')), "b'abc'")
-        self.assertEqual(repr(bytes("'")), "b'\\''")
+        self.assertEqual(repr(b"abc"), "b'abc'")
+        self.assertEqual(repr(b"'"), "b'\\''")
 
     def test_compare(self):
         b1 = bytes([1, 2, 3])
@@ -329,7 +329,7 @@ class BytesTest(unittest.TestCase):
             self.assertEqual(b, bytes(sample.encode(enc)))
         self.assertRaises(UnicodeEncodeError, bytes, sample, "latin1")
         b = bytes(sample, "latin1", "ignore")
-        self.assertEqual(b, bytes(sample[:-4]))
+        self.assertEqual(b, bytes(sample[:-4], "utf-8"))
 
     def test_decode(self):
         sample = "Hello world\n\u1234\u5678\u9abc\def0\def0"
@@ -349,7 +349,7 @@ class BytesTest(unittest.TestCase):
 
     def test_to_str(self):
         sample = "Hello world\n\x80\x81\xfe\xff"
-        b = bytes(sample)
+        b = bytes(sample, "utf-8")
         self.assertEqual(str(b), sample)
 
     def test_from_int(self):
@@ -361,17 +361,17 @@ class BytesTest(unittest.TestCase):
         self.assertEqual(b, bytes([0]*10000))
 
     def test_concat(self):
-        b1 = bytes("abc")
-        b2 = bytes("def")
-        self.assertEqual(b1 + b2, bytes("abcdef"))
-        self.assertEqual(b1 + str8("def"), bytes("abcdef"))
-        self.assertEqual(str8("def") + b1, bytes("defabc"))
+        b1 = b"abc"
+        b2 = b"def"
+        self.assertEqual(b1 + b2, b"abcdef")
+        self.assertEqual(b1 + str8("def"), b"abcdef")
+        self.assertEqual(str8("def") + b1, b"defabc")
         self.assertRaises(TypeError, lambda: b1 + "def")
         self.assertRaises(TypeError, lambda: "abc" + b2)
 
     def test_repeat(self):
-        b = bytes("abc")
-        self.assertEqual(b * 3, bytes("abcabcabc"))
+        b = b"abc"
+        self.assertEqual(b * 3, b"abcabcabc")
         self.assertEqual(b * 0, bytes())
         self.assertEqual(b * -1, bytes())
         self.assertRaises(TypeError, lambda: b * 3.14)
@@ -379,13 +379,13 @@ class BytesTest(unittest.TestCase):
         self.assertRaises(MemoryError, lambda: b * sys.maxint)
 
     def test_repeat_1char(self):
-        self.assertEqual(bytes('x')*100, bytes('x'*100))
+        self.assertEqual(b'x'*100, bytes([ord('x')]*100))
 
     def test_iconcat(self):
-        b = bytes("abc")
+        b = b"abc"
         b1 = b
-        b += bytes("def")
-        self.assertEqual(b, bytes("abcdef"))
+        b += b"def"
+        self.assertEqual(b, b"abcdef")
         self.assertEqual(b, b1)
         self.failUnless(b is b1)
         b += str8("xyz")
@@ -398,23 +398,23 @@ class BytesTest(unittest.TestCase):
             self.fail("bytes += unicode didn't raise TypeError")
 
     def test_irepeat(self):
-        b = bytes("abc")
+        b = b"abc"
         b1 = b
         b *= 3
-        self.assertEqual(b, bytes("abcabcabc"))
+        self.assertEqual(b, b"abcabcabc")
         self.assertEqual(b, b1)
         self.failUnless(b is b1)
 
     def test_irepeat_1char(self):
-        b = bytes("x")
+        b = b"x"
         b1 = b
         b *= 100
-        self.assertEqual(b, bytes("x"*100))
+        self.assertEqual(b, bytes([ord("x")]*100))
         self.assertEqual(b, b1)
         self.failUnless(b is b1)
 
     def test_contains(self):
-        b = bytes("abc")
+        b = b"abc"
         self.failUnless(ord('a') in b)
         self.failUnless(int(ord('a')) in b)
         self.failIf(200 in b)
@@ -424,17 +424,17 @@ class BytesTest(unittest.TestCase):
         self.assertRaises(TypeError, lambda: None in b)
         self.assertRaises(TypeError, lambda: float(ord('a')) in b)
         self.assertRaises(TypeError, lambda: "a" in b)
-        self.failUnless(bytes("") in b)
-        self.failUnless(bytes("a") in b)
-        self.failUnless(bytes("b") in b)
-        self.failUnless(bytes("c") in b)
-        self.failUnless(bytes("ab") in b)
-        self.failUnless(bytes("bc") in b)
-        self.failUnless(bytes("abc") in b)
-        self.failIf(bytes("ac") in b)
-        self.failIf(bytes("d") in b)
-        self.failIf(bytes("dab") in b)
-        self.failIf(bytes("abd") in b)
+        self.failUnless(b"" in b)
+        self.failUnless(b"a" in b)
+        self.failUnless(b"b" in b)
+        self.failUnless(b"c" in b)
+        self.failUnless(b"ab" in b)
+        self.failUnless(b"bc" in b)
+        self.failUnless(b"abc" in b)
+        self.failIf(b"ac" in b)
+        self.failIf(b"d" in b)
+        self.failIf(b"dab" in b)
+        self.failIf(b"abd" in b)
 
     def test_alloc(self):
         b = bytes()
@@ -442,7 +442,7 @@ class BytesTest(unittest.TestCase):
         self.assert_(alloc >= 0)
         seq = [alloc]
         for i in range(100):
-            b += bytes("x")
+            b += b"x"
             alloc = b.__alloc__()
             self.assert_(alloc >= len(b))
             if alloc not in seq:
@@ -467,11 +467,10 @@ class BytesTest(unittest.TestCase):
     def test_join(self):
         self.assertEqual(b"".join([]), bytes())
         self.assertEqual(b"".join([bytes()]), bytes())
-        for part in [("abc",), ("a", "bc"), ("ab", "c"), ("a", "b", "c")]:
-            lst = list(map(bytes, part))
-            self.assertEqual(b"".join(lst), bytes("abc"))
-            self.assertEqual(b"".join(tuple(lst)), bytes("abc"))
-            self.assertEqual(b"".join(iter(lst)), bytes("abc"))
+        for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]:
+            self.assertEqual(b"".join(lst), b"abc")
+            self.assertEqual(b"".join(tuple(lst)), b"abc")
+            self.assertEqual(b"".join(iter(lst)), b"abc")
         self.assertEqual(b".".join([b"ab", b"cd"]), b"ab.cd")
         # XXX more...
 
@@ -691,8 +690,13 @@ class BytesTest(unittest.TestCase):
 class BytesAsStringTest(test.string_tests.BaseTest):
     type2test = bytes
 
+    def fixtype(self, obj):
+        if isinstance(obj, str):
+            return obj.encode("utf-8")
+        return super().fixtype(obj)
+
     def checkequal(self, result, object, methodname, *args):
-        object = bytes(object)
+        object = bytes(object, "utf-8")
         realresult = getattr(bytes, methodname)(object, *args)
         self.assertEqual(
             self.fixtype(result),
@@ -700,7 +704,7 @@ class BytesAsStringTest(test.string_tests.BaseTest):
         )
 
     def checkraises(self, exc, object, methodname, *args):
-        object = bytes(object)
+        object = bytes(object, "utf-8")
         self.assertRaises(
             exc,
             getattr(bytes, methodname),

Lib/test/test_ucn.py

@@ -124,7 +124,7 @@ class UnicodeNamesTest(unittest.TestCase):
         # long bogus character name
         self.assertRaises(
             UnicodeError,
-            str, bytes("\\N{%s}" % ("x" * 100000)), 'unicode-escape', 'strict'
+            str, bytes("\\N{%s}" % ("x" * 100000), "ascii"), 'unicode-escape', 'strict'
         )
         # missing closing brace
         self.assertRaises(

Lib/test/test_unicode.py

@@ -794,10 +794,10 @@ class UnicodeTest(
         self.assertEqual(b"\\N{foo}xx".decode("unicode-escape", "ignore"), "xx")
 
         # Error handling (truncated escape sequence)
-        self.assertRaises(UnicodeError, "\\".decode, "unicode-escape")
+        self.assertRaises(UnicodeError, b"\\".decode, "unicode-escape")
 
-        self.assertRaises(TypeError, "hello".decode, "test.unicode1")
-        self.assertRaises(TypeError, str, "hello", "test.unicode2")
+        self.assertRaises(TypeError, b"hello".decode, "test.unicode1")
+        self.assertRaises(TypeError, str, b"hello", "test.unicode2")
         self.assertRaises(TypeError, "hello".encode, "test.unicode1")
         self.assertRaises(TypeError, "hello".encode, "test.unicode2")
         # executes PyUnicode_Encode()

Lib/test/test_unicode_file.py

@@ -8,7 +8,7 @@ import unittest
 from test.test_support import run_unittest, TestSkipped, TESTFN_UNICODE
 from test.test_support import TESTFN_ENCODING, TESTFN_UNICODE_UNENCODEABLE
 try:
-    TESTFN_ENCODED = TESTFN_UNICODE
+    TESTFN_ENCODED = TESTFN_UNICODE.encode("utf-8") # XXX is this right?
     TESTFN_UNICODE.encode(TESTFN_ENCODING)
 except (UnicodeError, TypeError):
     # Either the file system encoding is None, or the file name

Lib/test/test_unicodedata.py

@@ -94,7 +94,7 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
                 str(self.db.mirrored(char)),
                 str(self.db.combining(char)),
             ]
-            h.update(''.join(data))
+            h.update(''.join(data).encode("ascii"))
         result = h.hexdigest()
         self.assertEqual(result, self.expectedchecksum)
 

Lib/test/test_univnewlines.py

@@ -36,7 +36,10 @@ class TestGenericUnivNewlines(unittest.TestCase):
 
     def setUp(self):
         fp = open(test_support.TESTFN, self.WRITEMODE)
-        fp.write(self.DATA)
+        data = self.DATA
+        if "b" in self.WRITEMODE:
+            data = data.encode("ascii")
+        fp.write(data)
         fp.close()
 
     def tearDown(self):

Lib/test/test_zipfile.py

@@ -17,7 +17,7 @@ FIXEDTEST_SIZE = 1000
 class TestsWithSourceFile(unittest.TestCase):
     def setUp(self):
         self.line_gen = (bytes("Zipfile test line %d. random float: %f" %
-                               (i, random()))
+                               (i, random()), "ascii")
                          for i in range(FIXEDTEST_SIZE))
         self.data = b'\n'.join(self.line_gen) + b'\n'
 
@@ -246,7 +246,7 @@ class TestsWithSourceFile(unittest.TestCase):
         # Test appending to an existing file that is not a zipfile
         # NOTE: this test fails if len(d) < 22 because of the first
         # line "fpin.seek(-22, 2)" in _EndRecData
-        d = 'I am not a ZipFile!'*10
+        d = b'I am not a ZipFile!'*10
         f = open(TESTFN2, 'wb')
         f.write(d)
         f.close()
@@ -301,7 +301,7 @@ class TestZip64InSmallFiles(unittest.TestCase):
         self._limit = zipfile.ZIP64_LIMIT
         zipfile.ZIP64_LIMIT = 5
 
-        line_gen = (bytes("Test of zipfile line %d." % i)
+        line_gen = (bytes("Test of zipfile line %d." % i, "ascii")
                     for i in range(0, FIXEDTEST_SIZE))
         self.data = b'\n'.join(line_gen)
 
@@ -806,7 +806,7 @@ class TestsWithMultipleOpens(unittest.TestCase):
 
 class UniversalNewlineTests(unittest.TestCase):
     def setUp(self):
-        self.line_gen = [bytes("Test of zipfile line %d." % i)
+        self.line_gen = [bytes("Test of zipfile line %d." % i, "ascii")
                          for i in range(FIXEDTEST_SIZE)]
         self.seps = ('\r', '\r\n', '\n')
         self.arcdata, self.arcfiles = {}, {}