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 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 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 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 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 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 __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 __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)
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_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_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_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_io_stringio(self):
# io.StringIO only accepts unicode so should be returned as itself.
s = io.StringIO()
self.assertEqual(s, unicode_output_stream(s))
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_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_stringio(self):
"""A StringIO object should maybe get an ascii native str type"""
sout = io.StringIO()
soutwrapper = unicode_output_stream(sout)
soutwrapper.write(self.uni)
self.assertEqual(self.uni, sout.getvalue())
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_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))
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_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_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_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_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_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'))
