Marked bytestrings with b prefix. Refs #18269

This is a preparation for unicode literals general usage in
Django (Python 3 compatibility).

1 files changed, 44 insertions, 44 deletions

diff --git a/tests/regressiontests/requests/tests.py b/tests/regressiontests/requests/tests.py
index 5c49afbc35..3d2b196194 100644
--- a/tests/regressiontests/requests/tests.py
+++ b/tests/regressiontests/requests/tests.py
@@ -204,91 +204,91 @@ class RequestsTests(unittest.TestCase):
 
     def test_limited_stream(self):
         # Read all of a limited stream
-        stream = LimitedStream(StringIO('test'), 2)
-        self.assertEqual(stream.read(), 'te')
+        stream = LimitedStream(StringIO(b'test'), 2)
+        self.assertEqual(stream.read(), b'te')
         # Reading again returns nothing.
-        self.assertEqual(stream.read(), '')
+        self.assertEqual(stream.read(), b'')
 
         # Read a number of characters greater than the stream has to offer
-        stream = LimitedStream(StringIO('test'), 2)
-        self.assertEqual(stream.read(5), 'te')
+        stream = LimitedStream(StringIO(b'test'), 2)
+        self.assertEqual(stream.read(5), b'te')
         # Reading again returns nothing.
-        self.assertEqual(stream.readline(5), '')
+        self.assertEqual(stream.readline(5), b'')
 
         # Read sequentially from a stream
-        stream = LimitedStream(StringIO('12345678'), 8)
-        self.assertEqual(stream.read(5), '12345')
-        self.assertEqual(stream.read(5), '678')
+        stream = LimitedStream(StringIO(b'12345678'), 8)
+        self.assertEqual(stream.read(5), b'12345')
+        self.assertEqual(stream.read(5), b'678')
         # Reading again returns nothing.
-        self.assertEqual(stream.readline(5), '')
+        self.assertEqual(stream.readline(5), b'')
 
         # Read lines from a stream
-        stream = LimitedStream(StringIO('1234\n5678\nabcd\nefgh\nijkl'), 24)
+        stream = LimitedStream(StringIO(b'1234\n5678\nabcd\nefgh\nijkl'), 24)
         # Read a full line, unconditionally
-        self.assertEqual(stream.readline(), '1234\n')
+        self.assertEqual(stream.readline(), b'1234\n')
         # Read a number of characters less than a line
-        self.assertEqual(stream.readline(2), '56')
+        self.assertEqual(stream.readline(2), b'56')
         # Read the rest of the partial line
-        self.assertEqual(stream.readline(), '78\n')
+        self.assertEqual(stream.readline(), b'78\n')
         # Read a full line, with a character limit greater than the line length
-        self.assertEqual(stream.readline(6), 'abcd\n')
+        self.assertEqual(stream.readline(6), b'abcd\n')
         # Read the next line, deliberately terminated at the line end
-        self.assertEqual(stream.readline(4), 'efgh')
+        self.assertEqual(stream.readline(4), b'efgh')
         # Read the next line... just the line end
-        self.assertEqual(stream.readline(), '\n')
+        self.assertEqual(stream.readline(), b'\n')
         # Read everything else.
-        self.assertEqual(stream.readline(), 'ijkl')
+        self.assertEqual(stream.readline(), b'ijkl')
 
         # Regression for #15018
         # If a stream contains a newline, but the provided length
         # is less than the number of provided characters, the newline
         # doesn't reset the available character count
-        stream = LimitedStream(StringIO('1234\nabcdef'), 9)
-        self.assertEqual(stream.readline(10), '1234\n')
-        self.assertEqual(stream.readline(3), 'abc')
+        stream = LimitedStream(StringIO(b'1234\nabcdef'), 9)
+        self.assertEqual(stream.readline(10), b'1234\n')
+        self.assertEqual(stream.readline(3), b'abc')
         # Now expire the available characters
-        self.assertEqual(stream.readline(3), 'd')
+        self.assertEqual(stream.readline(3), b'd')
         # Reading again returns nothing.
-        self.assertEqual(stream.readline(2), '')
+        self.assertEqual(stream.readline(2), b'')
 
         # Same test, but with read, not readline.
-        stream = LimitedStream(StringIO('1234\nabcdef'), 9)
-        self.assertEqual(stream.read(6), '1234\na')
-        self.assertEqual(stream.read(2), 'bc')
-        self.assertEqual(stream.read(2), 'd')
-        self.assertEqual(stream.read(2), '')
-        self.assertEqual(stream.read(), '')
+        stream = LimitedStream(StringIO(b'1234\nabcdef'), 9)
+        self.assertEqual(stream.read(6), b'1234\na')
+        self.assertEqual(stream.read(2), b'bc')
+        self.assertEqual(stream.read(2), b'd')
+        self.assertEqual(stream.read(2), b'')
+        self.assertEqual(stream.read(), b'')
 
     def test_stream(self):
-        payload = 'name=value'
+        payload = b'name=value'
         request = WSGIRequest({'REQUEST_METHOD': 'POST',
                                'CONTENT_LENGTH': len(payload),
                                'wsgi.input': StringIO(payload)})
-        self.assertEqual(request.read(), 'name=value')
+        self.assertEqual(request.read(), b'name=value')
 
     def test_read_after_value(self):
         """
         Reading from request is allowed after accessing request contents as
         POST or body.
         """
-        payload = 'name=value'
+        payload = b'name=value'
         request = WSGIRequest({'REQUEST_METHOD': 'POST',
                                'CONTENT_LENGTH': len(payload),
                                'wsgi.input': StringIO(payload)})
         self.assertEqual(request.POST, {u'name': [u'value']})
-        self.assertEqual(request.body, 'name=value')
-        self.assertEqual(request.read(), 'name=value')
+        self.assertEqual(request.body, b'name=value')
+        self.assertEqual(request.read(), b'name=value')
 
     def test_value_after_read(self):
         """
         Construction of POST or body is not allowed after reading
         from request.
         """
-        payload = 'name=value'
+        payload = b'name=value'
         request = WSGIRequest({'REQUEST_METHOD': 'POST',
                                'CONTENT_LENGTH': len(payload),
                                'wsgi.input': StringIO(payload)})
-        self.assertEqual(request.read(2), 'na')
+        self.assertEqual(request.read(2), b'na')
         self.assertRaises(Exception, lambda: request.body)
         self.assertEqual(request.POST, {})
 
@@ -335,17 +335,17 @@ class RequestsTests(unittest.TestCase):
         self.assertEqual(request.POST, {})
 
     def test_read_by_lines(self):
-        payload = 'name=value'
+        payload = b'name=value'
         request = WSGIRequest({'REQUEST_METHOD': 'POST',
                                'CONTENT_LENGTH': len(payload),
                                'wsgi.input': StringIO(payload)})
-        self.assertEqual(list(request), ['name=value'])
+        self.assertEqual(list(request), [b'name=value'])
 
     def test_POST_after_body_read(self):
         """
         POST should be populated even if body is read first
         """
-        payload = 'name=value'
+        payload = b'name=value'
         request = WSGIRequest({'REQUEST_METHOD': 'POST',
                                'CONTENT_LENGTH': len(payload),
                                'wsgi.input': StringIO(payload)})
@@ -357,12 +357,12 @@ class RequestsTests(unittest.TestCase):
         POST should be populated even if body is read first, and then
         the stream is read second.
         """
-        payload = 'name=value'
+        payload = b'name=value'
         request = WSGIRequest({'REQUEST_METHOD': 'POST',
                                'CONTENT_LENGTH': len(payload),
                                'wsgi.input': StringIO(payload)})
         raw_data = request.body
-        self.assertEqual(request.read(1), u'n')
+        self.assertEqual(request.read(1), b'n')
         self.assertEqual(request.POST, {u'name': [u'value']})
 
     def test_POST_after_body_read_and_stream_read_multipart(self):
@@ -383,14 +383,14 @@ class RequestsTests(unittest.TestCase):
                                'wsgi.input': StringIO(payload)})
         raw_data = request.body
         # Consume enough data to mess up the parsing:
-        self.assertEqual(request.read(13), u'--boundary\r\nC')
+        self.assertEqual(request.read(13), b'--boundary\r\nC')
         self.assertEqual(request.POST, {u'name': [u'value']})
 
     def test_raw_post_data_returns_body(self):
         """
         HttpRequest.raw_post_body should be the same as HttpRequest.body
         """
-        payload = 'Hello There!'
+        payload = b'Hello There!'
         request = WSGIRequest({
             'REQUEST_METHOD': 'POST',
             'CONTENT_LENGTH': len(payload),
@@ -409,7 +409,7 @@ class RequestsTests(unittest.TestCase):
             def read(self, len=0):
                 raise IOError("kaboom!")
 
-        payload = 'name=value'
+        payload = b'name=value'
         request = WSGIRequest({'REQUEST_METHOD': 'POST',
                                'CONTENT_LENGTH': len(payload),
                                'wsgi.input': ExplodingStringIO(payload)})