def test_unicode_encodings_not_wrapped(self):
     """A unicode encoding is left unwrapped as needs no error handler"""
     sout = _FakeOutputStream()
     sout.encoding = "utf-8"
     self.assertIs(unicode_output_stream(sout), sout)
     sout = _FakeOutputStream()
     sout.encoding = "utf-16-be"
     self.assertIs(unicode_output_stream(sout), sout)

def main(argv, prepare_args=prepare_argv, find_tests=find_tests):
    """CLI entry point to adapt a test run to parallel testing."""
    child_args = prepare_argv(argv)
    test_ids = find_tests(argv)
    # We could create a proxy object per test id if desired in future)
    def parallelise_tests(suite):
        test_ids = list(suite)[0]._test_ids
        count = concurrency()
        partitions = partition_tests(test_ids, count)
        return [ListTestCase(partition, child_args) for partition in partitions]
    suite = ConcurrentTestSuite(ListTestCase(test_ids, None), parallelise_tests)
    if '--subunit' in argv:
        runner = SubunitTestRunner(sys.stdout)
        result = runner.run(suite)
    else:
        stream = unicode_output_stream(sys.stdout)
        result = TextTestResult(stream)
        result.startTestRun()
        try:
            suite.run(result)
        finally:
            result.stopTestRun()
    if result.wasSuccessful():
        return 0
    return -1

 def test_unicode_encodings_wrapped_when_str_is_not_unicode(self):
     """A unicode encoding is wrapped but needs no error handler"""
     sout = _FakeOutputStream()
     sout.encoding = "utf-8"
     uout = unicode_output_stream(sout)
     self.assertEqual(uout.errors, "strict")
     uout.write(self.uni)
     self.assertEqual([_b("pa\xc9\xaa\xce\xb8\xc9\x99n")], sout.writelog)

 def run(self, test):
     "Run the given test case or test suite."
     result = TextTestResult(unicode_output_stream(self.stdout))
     result.startTestRun()
     try:
         return test.run(result)
     finally:
         result.stopTestRun()

 def __init__(self, ui, get_id, stream, previous_run=None, filter_tags=None):
     """Construct a CLITestResult writing to stream.
     
     :param filter_tags: Tags that should be used to filter tests out. When
         a tag in this set is present on a test outcome, the test is not
         counted towards the test run count. If the test errors, then it is
         still counted and the error is still shown.
     """
     super(CLITestResult, self).__init__(ui, get_id, previous_run)
     self.stream = unicode_output_stream(stream)
     self.sep1 = _u('=' * 70 + '\n')
     self.sep2 = _u('-' * 70 + '\n')
     self.filter_tags = filter_tags or frozenset()
     self.filterable_states = set(['success', 'uxsuccess', 'xfail', 'skip'])

 def test_stringio(self):
     """A StringIO object should maybe get an ascii native str type"""
     try:
         from cStringIO import StringIO
         newio = False
     except ImportError:
         from io import StringIO
         newio = True
     sout = StringIO()
     soutwrapper = unicode_output_stream(sout)
     soutwrapper.write(self.uni)
     if newio:
         self.assertEqual(self.uni, sout.getvalue())
     else:
         self.assertEqual("pa???n", sout.getvalue())

 def test_stringio(self):
     """A StringIO object should maybe get an ascii native str type"""
     try:
         from cStringIO import StringIO
         newio = False
     except ImportError:
         from io import StringIO
         newio = True
     sout = StringIO()
     soutwrapper = unicode_output_stream(sout)
     if newio:
         self.expectFailure("Python 3 StringIO expects text not bytes",
             self.assertThat, lambda: soutwrapper.write(self.uni),
             Not(Raises(MatchesException(TypeError))))
     soutwrapper.write(self.uni)
     self.assertEqual("pa???n", sout.getvalue())

 def test_unicode_encodings_not_wrapped_when_str_is_unicode(self):
     # No wrapping needed if native str type is unicode
     sout = _FakeOutputStream()
     sout.encoding = "utf-8"
     uout = unicode_output_stream(sout)
     self.assertIs(uout, sout)

 def test_partial_encoding_replace(self):
     """A string which can be partly encoded correctly should be"""
     sout = _FakeOutputStream()
     sout.encoding = "iso-8859-7"
     unicode_output_stream(sout).write(self.uni)
     self.assertEqual([_b("pa?\xe8?n")], sout.writelog)

 def test_bogus_encoding_becomes_ascii(self):
     """A stream with a bogus encoding gets ascii/replace strings"""
     sout = _FakeOutputStream()
     sout.encoding = "bogus"
     unicode_output_stream(sout).write(self.uni)
     self.assertEqual([_b("pa???n")], sout.writelog)

 def test_encoding_as_none_becomes_ascii(self):
     """A stream with encoding value of None gets ascii/replace strings"""
     sout = _FakeOutputStream()
     sout.encoding = None
     unicode_output_stream(sout).write(self.uni)
     self.assertEqual([_b("pa???n")], sout.writelog)

 def test_no_encoding_becomes_ascii(self):
     """A stream with no encoding attribute gets ascii/replace strings"""
     sout = _FakeOutputStream()
     unicode_output_stream(sout).write(self.uni)
     self.assertEqual([_b("pa???n")], sout.writelog)

 def test_io_textwrapper(self):
     # textwrapper is unicode, should be returned as itself.
     text_io = io.TextIOWrapper(io.BytesIO())
     self.assertThat(unicode_output_stream(text_io), Is(text_io))
     # To be sure...
     unicode_output_stream(text_io).write(_u('foo'))

 def test_io_bytesio(self):
     # io.BytesIO only accepts bytes so should be wrapped.
     bytes_io = io.BytesIO()
     self.assertThat(bytes_io, Not(Is(unicode_output_stream(bytes_io))))
     # Will error if s was not wrapped properly.
     unicode_output_stream(bytes_io).write(_u('foo'))

 def test_io_stringio(self):
     # io.StringIO only accepts unicode so should be returned as itself.
     s = io.StringIO()
     self.assertEqual(s, unicode_output_stream(s))