Nearly done.

4 files changed, 101 insertions, 104 deletions

diff --git a/python/subunit/tests/test_chunked.py b/python/subunit/tests/test_chunked.py
index 6323b02..e0742f1 100644
--- a/python/subunit/tests/test_chunked.py
+++ b/python/subunit/tests/test_chunked.py
@@ -17,7 +17,7 @@
 
 import unittest
 
-from testtools.compat import StringIO
+from testtools.compat import _b, BytesIO
 
 import subunit.chunked
 
@@ -32,121 +32,121 @@ class TestDecode(unittest.TestCase):
 
     def setUp(self):
         unittest.TestCase.setUp(self)
-        self.output = StringIO()
+        self.output = BytesIO()
         self.decoder = subunit.chunked.Decoder(self.output)
 
     def test_close_read_length_short_errors(self):
         self.assertRaises(ValueError, self.decoder.close)
 
     def test_close_body_short_errors(self):
-        self.assertEqual(None, self.decoder.write('2\r\na'))
+        self.assertEqual(None, self.decoder.write(_b('2\r\na')))
         self.assertRaises(ValueError, self.decoder.close)
 
     def test_close_body_buffered_data_errors(self):
-        self.assertEqual(None, self.decoder.write('2\r'))
+        self.assertEqual(None, self.decoder.write(_b('2\r')))
         self.assertRaises(ValueError, self.decoder.close)
 
     def test_close_after_finished_stream_safe(self):
-        self.assertEqual(None, self.decoder.write('2\r\nab'))
-        self.assertEqual('', self.decoder.write('0\r\n'))
+        self.assertEqual(None, self.decoder.write(_b('2\r\nab')))
+        self.assertEqual(_b(''), self.decoder.write(_b('0\r\n')))
         self.decoder.close()
 
     def test_decode_nothing(self):
-        self.assertEqual('', self.decoder.write('0\r\n'))
-        self.assertEqual('', self.output.getvalue())
+        self.assertEqual(_b(''), self.decoder.write(_b('0\r\n')))
+        self.assertEqual(_b(''), self.output.getvalue())
 
     def test_decode_serialised_form(self):
-        self.assertEqual(None, self.decoder.write("F\r\n"))
-        self.assertEqual(None, self.decoder.write("serialised\n"))
-        self.assertEqual('', self.decoder.write("form0\r\n"))
+        self.assertEqual(None, self.decoder.write(_b("F\r\n")))
+        self.assertEqual(None, self.decoder.write(_b("serialised\n")))
+        self.assertEqual(_b(''), self.decoder.write(_b("form0\r\n")))
 
     def test_decode_short(self):
-        self.assertEqual('', self.decoder.write('3\r\nabc0\r\n'))
-        self.assertEqual('abc', self.output.getvalue())
+        self.assertEqual(_b(''), self.decoder.write(_b('3\r\nabc0\r\n')))
+        self.assertEqual(_b('abc'), self.output.getvalue())
 
     def test_decode_combines_short(self):
-        self.assertEqual('', self.decoder.write('6\r\nabcdef0\r\n'))
-        self.assertEqual('abcdef', self.output.getvalue())
+        self.assertEqual(_b(''), self.decoder.write(_b('6\r\nabcdef0\r\n')))
+        self.assertEqual(_b('abcdef'), self.output.getvalue())
 
     def test_decode_excess_bytes_from_write(self):
-        self.assertEqual('1234', self.decoder.write('3\r\nabc0\r\n1234'))
-        self.assertEqual('abc', self.output.getvalue())
+        self.assertEqual(_b('1234'), self.decoder.write(_b('3\r\nabc0\r\n1234')))
+        self.assertEqual(_b('abc'), self.output.getvalue())
 
     def test_decode_write_after_finished_errors(self):
-        self.assertEqual('1234', self.decoder.write('3\r\nabc0\r\n1234'))
-        self.assertRaises(ValueError, self.decoder.write, '')
+        self.assertEqual(_b('1234'), self.decoder.write(_b('3\r\nabc0\r\n1234')))
+        self.assertRaises(ValueError, self.decoder.write, _b(''))
 
     def test_decode_hex(self):
-        self.assertEqual('', self.decoder.write('A\r\n12345678900\r\n'))
-        self.assertEqual('1234567890', self.output.getvalue())
+        self.assertEqual(_b(''), self.decoder.write(_b('A\r\n12345678900\r\n')))
+        self.assertEqual(_b('1234567890'), self.output.getvalue())
 
     def test_decode_long_ranges(self):
-        self.assertEqual(None, self.decoder.write('10000\r\n'))
-        self.assertEqual(None, self.decoder.write('1' * 65536))
-        self.assertEqual(None, self.decoder.write('10000\r\n'))
-        self.assertEqual(None, self.decoder.write('2' * 65536))
-        self.assertEqual('', self.decoder.write('0\r\n'))
-        self.assertEqual('1' * 65536 + '2' * 65536, self.output.getvalue())
+        self.assertEqual(None, self.decoder.write(_b('10000\r\n')))
+        self.assertEqual(None, self.decoder.write(_b('1' * 65536)))
+        self.assertEqual(None, self.decoder.write(_b('10000\r\n')))
+        self.assertEqual(None, self.decoder.write(_b('2' * 65536)))
+        self.assertEqual(_b(''), self.decoder.write(_b('0\r\n')))
+        self.assertEqual(_b('1' * 65536 + '2' * 65536), self.output.getvalue())
 
     def test_decode_newline_nonstrict(self):
         """Tolerate chunk markers with no CR character."""
         # From <http://pad.lv/505078>
         self.decoder = subunit.chunked.Decoder(self.output, strict=False)
-        self.assertEqual(None, self.decoder.write('a\n'))
-        self.assertEqual(None, self.decoder.write('abcdeabcde'))
-        self.assertEqual('', self.decoder.write('0\n'))
-        self.assertEqual('abcdeabcde', self.output.getvalue())
+        self.assertEqual(None, self.decoder.write(_b('a\n')))
+        self.assertEqual(None, self.decoder.write(_b('abcdeabcde')))
+        self.assertEqual(_b(''), self.decoder.write(_b('0\n')))
+        self.assertEqual(_b('abcdeabcde'), self.output.getvalue())
 
     def test_decode_strict_newline_only(self):
         """Reject chunk markers with no CR character in strict mode."""
         # From <http://pad.lv/505078>
         self.assertRaises(ValueError,
-            self.decoder.write, 'a\n')
+            self.decoder.write, _b('a\n'))
 
     def test_decode_strict_multiple_crs(self):
         self.assertRaises(ValueError,
-            self.decoder.write, 'a\r\r\n')
+            self.decoder.write, _b('a\r\r\n'))
 
     def test_decode_short_header(self):
         self.assertRaises(ValueError,
-            self.decoder.write, '\n')
+            self.decoder.write, _b('\n'))
 
 
 class TestEncode(unittest.TestCase):
 
     def setUp(self):
         unittest.TestCase.setUp(self)
-        self.output = StringIO()
+        self.output = BytesIO()
         self.encoder = subunit.chunked.Encoder(self.output)
 
     def test_encode_nothing(self):
         self.encoder.close()
-        self.assertEqual('0\r\n', self.output.getvalue())
+        self.assertEqual(_b('0\r\n'), self.output.getvalue())
 
     def test_encode_empty(self):
-        self.encoder.write('')
+        self.encoder.write(_b(''))
         self.encoder.close()
-        self.assertEqual('0\r\n', self.output.getvalue())
+        self.assertEqual(_b('0\r\n'), self.output.getvalue())
 
     def test_encode_short(self):
-        self.encoder.write('abc')
+        self.encoder.write(_b('abc'))
         self.encoder.close()
-        self.assertEqual('3\r\nabc0\r\n', self.output.getvalue())
+        self.assertEqual(_b('3\r\nabc0\r\n'), self.output.getvalue())
 
     def test_encode_combines_short(self):
-        self.encoder.write('abc')
-        self.encoder.write('def')
+        self.encoder.write(_b('abc'))
+        self.encoder.write(_b('def'))
         self.encoder.close()
-        self.assertEqual('6\r\nabcdef0\r\n', self.output.getvalue())
+        self.assertEqual(_b('6\r\nabcdef0\r\n'), self.output.getvalue())
 
     def test_encode_over_9_is_in_hex(self):
-        self.encoder.write('1234567890')
+        self.encoder.write(_b('1234567890'))
         self.encoder.close()
-        self.assertEqual('A\r\n12345678900\r\n', self.output.getvalue())
+        self.assertEqual(_b('A\r\n12345678900\r\n'), self.output.getvalue())
 
     def test_encode_long_ranges_not_combined(self):
-        self.encoder.write('1' * 65536)
-        self.encoder.write('2' * 65536)
+        self.encoder.write(_b('1' * 65536))
+        self.encoder.write(_b('2' * 65536))
         self.encoder.close()
-        self.assertEqual('10000\r\n' + '1' * 65536 + '10000\r\n' +
-            '2' * 65536 + '0\r\n', self.output.getvalue())
+        self.assertEqual(_b('10000\r\n' + '1' * 65536 + '10000\r\n' +
+            '2' * 65536 + '0\r\n'), self.output.getvalue())
diff --git a/python/subunit/tests/test_details.py b/python/subunit/tests/test_details.py
index 49010d2..746aa04 100644
--- a/python/subunit/tests/test_details.py
+++ b/python/subunit/tests/test_details.py
@@ -95,18 +95,18 @@ class TestMultipartDetails(unittest.TestCase):
 
     def test_parts(self):
         parser = details.MultipartDetailsParser(None)
-        parser.lineReceived("Content-Type: text/plain\n")
-        parser.lineReceived("something\n")
-        parser.lineReceived("F\r\n")
-        parser.lineReceived("serialised\n")
-        parser.lineReceived("form0\r\n")
+        parser.lineReceived(_b("Content-Type: text/plain\n"))
+        parser.lineReceived(_b("something\n"))
+        parser.lineReceived(_b("F\r\n"))
+        parser.lineReceived(_b("serialised\n"))
+        parser.lineReceived(_b("form0\r\n"))
         expected = {}
         expected['something'] = content.Content(
             content_type.ContentType("text", "plain"),
-            lambda:["serialised\nform"])
+            lambda:[_b("serialised\nform")])
         found = parser.get_details()
         self.assertEqual(expected.keys(), found.keys())
         self.assertEqual(expected['something'].content_type,
             found['something'].content_type)
-        self.assertEqual(''.join(expected['something'].iter_bytes()),
-            ''.join(found['something'].iter_bytes()))
+        self.assertEqual(_b('').join(expected['something'].iter_bytes()),
+            _b('').join(found['something'].iter_bytes()))
diff --git a/python/subunit/tests/test_subunit_filter.py b/python/subunit/tests/test_subunit_filter.py
index 682f726..fb6ffcd 100644
--- a/python/subunit/tests/test_subunit_filter.py
+++ b/python/subunit/tests/test_subunit_filter.py
@@ -21,7 +21,7 @@ from subunit import iso8601
 import unittest
 
 from testtools import TestCase
-from testtools.compat import StringIO
+from testtools.compat import _b, BytesIO, StringIO
 from testtools.testresult.doubles import ExtendedTestResult
 
 import subunit
@@ -35,7 +35,7 @@ class TestTestResultFilter(TestCase):
     # is an easy pithy way of getting a series of test objects to call into
     # the TestResult, and as TestResultFilter is intended for use with subunit
     # also has the benefit of detecting any interface skew issues.
-    example_subunit_stream = """\
+    example_subunit_stream = _b("""\
 tags: global
 test passed
 success passed
@@ -50,7 +50,7 @@ test skipped
 skip skipped
 test todo
 xfail todo
-"""
+""")
 
     def run_tests(self, result_filter, input_stream=None):
         """Run tests through the given filter.
@@ -61,7 +61,7 @@ xfail todo
         """
         if input_stream is None:
             input_stream = self.example_subunit_stream
-        test = subunit.ProtocolTestCase(StringIO(input_stream))
+        test = subunit.ProtocolTestCase(BytesIO(input_stream))
         test.run(result_filter)
 
     def test_default(self):
@@ -139,13 +139,13 @@ xfail todo
         date_a = datetime(year=2000, month=1, day=1, tzinfo=iso8601.UTC)
         date_b = datetime(year=2000, month=1, day=2, tzinfo=iso8601.UTC)
         date_c = datetime(year=2000, month=1, day=3, tzinfo=iso8601.UTC)
-        subunit_stream = '\n'.join([
+        subunit_stream = _b('\n'.join([
             "time: %s",
             "test: foo",
             "time: %s",
             "error: foo",
             "time: %s",
-            ""]) % (date_a, date_b, date_c)
+            ""]) % (date_a, date_b, date_c))
         result = ExtendedTestResult()
         result_filter = TestResultFilter(result)
         self.run_tests(result_filter, subunit_stream)
diff --git a/python/subunit/tests/test_test_protocol.py b/python/subunit/tests/test_test_protocol.py
index 7778fcc..7ec7758 100644
--- a/python/subunit/tests/test_test_protocol.py
+++ b/python/subunit/tests/test_test_protocol.py
@@ -28,7 +28,7 @@ from testtools.tests.helpers import (
     )
 
 import subunit
-from subunit import _remote_exception_str
+from subunit import _remote_exception_str, _remote_exception_str_chunked
 import subunit.iso8601 as iso8601
 
 
@@ -994,11 +994,11 @@ class TestIsolatedTestSuite(unittest.TestCase):
 class TestTestProtocolClient(unittest.TestCase):
 
     def setUp(self):
-        self.io = StringIO()
+        self.io = BytesIO()
         self.protocol = subunit.TestProtocolClient(self.io)
         self.test = TestTestProtocolClient("test_start_test")
         self.sample_details = {'something':Content(
-            ContentType('text', 'plain'), lambda:['serialised\nform'])}
+            ContentType('text', 'plain'), lambda:[_b('serialised\nform')])}
         self.sample_tb_details = dict(self.sample_details)
         self.sample_tb_details['traceback'] = TracebackContent(
             subunit.RemoteError(_u("boo qux")), self.test)
@@ -1006,27 +1006,27 @@ class TestTestProtocolClient(unittest.TestCase):
     def test_start_test(self):
         """Test startTest on a TestProtocolClient."""
         self.protocol.startTest(self.test)
-        self.assertEqual(self.io.getvalue(), "test: %s\n" % self.test.id())
+        self.assertEqual(self.io.getvalue(), _b("test: %s\n" % self.test.id()))
 
     def test_stop_test(self):
         # stopTest doesn't output anything.
         self.protocol.stopTest(self.test)
-        self.assertEqual(self.io.getvalue(), "")
+        self.assertEqual(self.io.getvalue(), _b(""))
 
     def test_add_success(self):
         """Test addSuccess on a TestProtocolClient."""
         self.protocol.addSuccess(self.test)
         self.assertEqual(
-            self.io.getvalue(), "successful: %s\n" % self.test.id())
+            self.io.getvalue(), _b("successful: %s\n" % self.test.id()))
 
     def test_add_success_details(self):
         """Test addSuccess on a TestProtocolClient with details."""
         self.protocol.addSuccess(self.test, details=self.sample_details)
         self.assertEqual(
-            self.io.getvalue(), "successful: %s [ multipart\n"
+            self.io.getvalue(), _b("successful: %s [ multipart\n"
                 "Content-Type: text/plain\n"
                 "something\n"
-                "F\r\nserialised\nform0\r\n]\n" % self.test.id())
+                "F\r\nserialised\nform0\r\n]\n" % self.test.id()))
 
     def test_add_failure(self):
         """Test addFailure on a TestProtocolClient."""
@@ -1034,8 +1034,8 @@ class TestTestProtocolClient(unittest.TestCase):
             self.test, subunit.RemoteError(_u("boo qux")))
         self.assertEqual(
             self.io.getvalue(),
-            ('failure: %s [\n' + _remote_exception_str + ': boo qux\n]\n')
-            % self.test.id())
+            _b(('failure: %s [\n' + _remote_exception_str + ': boo qux\n]\n')
+            % self.test.id()))
 
     def test_add_failure_details(self):
         """Test addFailure on a TestProtocolClient with details."""
@@ -1043,14 +1043,13 @@ class TestTestProtocolClient(unittest.TestCase):
             self.test, details=self.sample_tb_details)
         self.assertEqual(
             self.io.getvalue(),
-            ("failure: %s [ multipart\n"
+            _b(("failure: %s [ multipart\n"
             "Content-Type: text/plain\n"
             "something\n"
             "F\r\nserialised\nform0\r\n"
             "Content-Type: text/x-traceback;charset=utf8,language=python\n"
-            "traceback\n"
-            "1A\r\n" + _remote_exception_str + ": boo qux\n0\r\n"
-            "]\n") % self.test.id())
+            "traceback\n" + _remote_exception_str_chunked + ": boo qux\n0\r\n"
+            "]\n") % self.test.id()))
 
     def test_add_error(self):
         """Test stopTest on a TestProtocolClient."""
@@ -1058,9 +1057,9 @@ class TestTestProtocolClient(unittest.TestCase):
             self.test, subunit.RemoteError(_u("phwoar crikey")))
         self.assertEqual(
             self.io.getvalue(),
-            ('error: %s [\n' +
+            _b(('error: %s [\n' +
             _remote_exception_str + ": phwoar crikey\n"
-            "]\n") % self.test.id())
+            "]\n") % self.test.id()))
 
     def test_add_error_details(self):
         """Test stopTest on a TestProtocolClient with details."""
@@ -1068,14 +1067,13 @@ class TestTestProtocolClient(unittest.TestCase):
             self.test, details=self.sample_tb_details)
         self.assertEqual(
             self.io.getvalue(),
-            ("error: %s [ multipart\n"
+            _b(("error: %s [ multipart\n"
             "Content-Type: text/plain\n"
             "something\n"
             "F\r\nserialised\nform0\r\n"
             "Content-Type: text/x-traceback;charset=utf8,language=python\n"
-            "traceback\n"
-            "1A\r\n" + _remote_exception_str + ": boo qux\n0\r\n"
-            "]\n") % self.test.id())
+            "traceback\n" + _remote_exception_str_chunked + ": boo qux\n0\r\n"
+            "]\n") % self.test.id()))
 
     def test_add_expected_failure(self):
         """Test addExpectedFailure on a TestProtocolClient."""
@@ -1083,9 +1081,9 @@ class TestTestProtocolClient(unittest.TestCase):
             self.test, subunit.RemoteError(_u("phwoar crikey")))
         self.assertEqual(
             self.io.getvalue(),
-            ('xfail: %s [\n' +
+            _b(('xfail: %s [\n' +
             _remote_exception_str + ": phwoar crikey\n"
-            "]\n") % self.test.id())
+            "]\n") % self.test.id()))
 
     def test_add_expected_failure_details(self):
         """Test addExpectedFailure on a TestProtocolClient with details."""
@@ -1093,14 +1091,14 @@ class TestTestProtocolClient(unittest.TestCase):
             self.test, details=self.sample_tb_details)
         self.assertEqual(
             self.io.getvalue(),
-            ("xfail: %s [ multipart\n"
+            _b(("xfail: %s [ multipart\n"
             "Content-Type: text/plain\n"
             "something\n"
             "F\r\nserialised\nform0\r\n"
             "Content-Type: text/x-traceback;charset=utf8,language=python\n"
-            "traceback\n"
-            "1A\r\n"+ _remote_exception_str + ": boo qux\n0\r\n"
-            "]\n") % self.test.id())
+            "traceback\n" + _remote_exception_str_chunked + ": boo qux\n0\r\n"
+            "]\n") % self.test.id()))
+
 
     def test_add_skip(self):
         """Test addSkip on a TestProtocolClient."""
@@ -1108,64 +1106,63 @@ class TestTestProtocolClient(unittest.TestCase):
             self.test, "Has it really?")
         self.assertEqual(
             self.io.getvalue(),
-            'skip: %s [\nHas it really?\n]\n' % self.test.id())
+            _b('skip: %s [\nHas it really?\n]\n' % self.test.id()))
 
     def test_add_skip_details(self):
         """Test addSkip on a TestProtocolClient with details."""
         details = {'reason':Content(
-            ContentType('text', 'plain'), lambda:['Has it really?'])}
-        self.protocol.addSkip(
-            self.test, details=details)
+            ContentType('text', 'plain'), lambda:[_b('Has it really?')])}
+        self.protocol.addSkip(self.test, details=details)
         self.assertEqual(
             self.io.getvalue(),
-            "skip: %s [ multipart\n"
+            _b("skip: %s [ multipart\n"
             "Content-Type: text/plain\n"
             "reason\n"
             "E\r\nHas it really?0\r\n"
-            "]\n" % self.test.id())
+            "]\n" % self.test.id()))
 
     def test_progress_set(self):
         self.protocol.progress(23, subunit.PROGRESS_SET)
-        self.assertEqual(self.io.getvalue(), 'progress: 23\n')
+        self.assertEqual(self.io.getvalue(), _b('progress: 23\n'))
 
     def test_progress_neg_cur(self):
         self.protocol.progress(-23, subunit.PROGRESS_CUR)
-        self.assertEqual(self.io.getvalue(), 'progress: -23\n')
+        self.assertEqual(self.io.getvalue(), _b('progress: -23\n'))
 
     def test_progress_pos_cur(self):
         self.protocol.progress(23, subunit.PROGRESS_CUR)
-        self.assertEqual(self.io.getvalue(), 'progress: +23\n')
+        self.assertEqual(self.io.getvalue(), _b('progress: +23\n'))
 
     def test_progress_pop(self):
         self.protocol.progress(1234, subunit.PROGRESS_POP)
-        self.assertEqual(self.io.getvalue(), 'progress: pop\n')
+        self.assertEqual(self.io.getvalue(), _b('progress: pop\n'))
 
     def test_progress_push(self):
         self.protocol.progress(1234, subunit.PROGRESS_PUSH)
-        self.assertEqual(self.io.getvalue(), 'progress: push\n')
+        self.assertEqual(self.io.getvalue(), _b('progress: push\n'))
 
     def test_time(self):
         # Calling time() outputs a time signal immediately.
         self.protocol.time(
             datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc()))
         self.assertEqual(
-            "time: 2009-10-11 12:13:14.000015Z\n",
+            _b("time: 2009-10-11 12:13:14.000015Z\n"),
             self.io.getvalue())
 
     def test_add_unexpected_success(self):
         """Test addUnexpectedSuccess on a TestProtocolClient."""
         self.protocol.addUnexpectedSuccess(self.test)
         self.assertEqual(
-            self.io.getvalue(), "successful: %s\n" % self.test.id())
+            self.io.getvalue(), _b("successful: %s\n" % self.test.id()))
 
     def test_add_unexpected_success_details(self):
         """Test addUnexpectedSuccess on a TestProtocolClient with details."""
         self.protocol.addUnexpectedSuccess(self.test, details=self.sample_details)
         self.assertEqual(
-            self.io.getvalue(), "successful: %s [ multipart\n"
+            self.io.getvalue(), _b("successful: %s [ multipart\n"
                 "Content-Type: text/plain\n"
                 "something\n"
-                "F\r\nserialised\nform0\r\n]\n" % self.test.id())
+                "F\r\nserialised\nform0\r\n]\n" % self.test.id()))
 
 
 def test_suite():