Merge lp:~laurynas-biveinis/percona-server/bug1282599-5.5 into lp:percona-server/5.5

[Laurynas Biveinis]

Fix bug 1282599 (python-for-subunit2junitxml should be removed from
source tree) by removing the subunit2junitxml script and
python-for-subunit2junitxml directory.

http://jenkins.percona.com/job/percona-server-5.5-param/1061/

[Laurynas Biveinis (laurynas-biveinis)]

review: Approve

=== removed directory 'python-for-subunit2junitxml'
=== removed file 'python-for-subunit2junitxml/BytesIO.py'
--- python-for-subunit2junitxml/BytesIO.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/BytesIO.py	1970-01-01 00:00:00 +0000
@@ -1,136 +0,0 @@
-
-# http://wiki.python.org/moin/BytesIO
-#
-# A skeleton one used for systems that don't have BytesIO.
-#
-# It's enough for subunit at least....
-
-class BytesIO(object):
-    """ A file-like API for reading and writing bytes objects.
-
-    Mostly like StringIO, but write() calls modify the underlying
-    bytes object.
-
-    >>> b = bytes()
-    >>> f = BytesIO(b, 'w')
-    >>> f.write(bytes.fromhex('ca fe ba be'))
-    >>> f.write(bytes.fromhex('57 41 56 45'))
-    >>> b
-    bytes([202, 254, 186, 190, 87, 65, 86, 69])
-    """
-
-    def __init__(self, buf, mode='r'):
-        """ Create a new BytesIO for reading or writing the given buffer.
-
-        buf - Back-end buffer for this BytesIO.  A bytes object.
-            Actually, anything that supports len(), slice-assignment,
-            and += will work.
-        mode - One of 'r', 'w', 'a'.
-            An optional 'b' is also allowed, but it doesn't do anything.
-        """
-        # XXX many 'mode' possibilities aren't allowed yet: 'rw+Ut'
-        if len(mode) == 2 and mode[-1] == 'b':
-            mode = mode[:-1]  # binary mode goes without saying
-        if mode not in ('r', 'w', 'a'):
-            raise ValueError("mode must be 'r', 'w', or 'a'")
-
-        self._buf = buf
-        self.mode = mode
-        self.closed = False
-        if self.mode == 'w':
-            del buf[:]
-            self._point = 0
-        elif self.mode == 'r':
-            self._point = 0
-        else: # 'a'
-            self._point = len(buf)
-
-    def close(self):
-        self.closed = True
-
-    def _check_closed(self):
-        if self.closed:
-            raise ValueError("file is closed")
-
-    def flush(self):
-        self._check_closed()
-
-    def next(self):
-        line = self.readline()
-        if len(line) == 0:
-            raise StopIteration
-        return line
-
-    def read(self, size=None):
-        self._check_closed()
-        if size is None:
-            e = len(self._buf)
-        else:
-            e = min(self._point + size, len(self._buf))
-        r = self._buf[self._point:e]
-        self._point = e
-        return r
-
-    def readline(self, size=None):
-        self._check_closed()
-        die  # XXX TODO - assume ascii and read a line
-
-    def readlines(self, sizehint=None):
-        # XXX TODO handle sizehint
-        return list(self)
-
-    def seek(self, offset, whence=0):
-        self._check_closed()
-
-        if whence == 0:
-            self._point = offset
-        elif whence == 1:
-            self._point += offset
-        elif whence == 2:
-            self._point = len(self._buf) + offset
-        else:
-            raise ValueError("whence must be 0, 1, or 2")
-
-        if self._point < 0:
-            self._point = 0  # XXX is this right?
-
-    def tell(self):
-        self._check_closed()
-        return self._point
-
-    def truncate(self, size=None):
-        self._check_closed()
-        if size is None:
-            size = self.tell()
-        del self._buf[size:]
-
-    def write(self, data):
-        self._check_closed()
-        amt = len(data)
-        size = len(self._buf)
-        if self.mode == 'a':
-            self._point = size
-
-        if self._point > size:
-            if isinstance(b, bytes):
-                blank = bytes([0])
-            else:
-                # Don't know what default value to insert, unfortunately
-                raise ValueError("can't write past the end of this object")
-            self._buf += blank * (self._point - size) + data
-            self._point = len(self._buf)
-        else:
-            p = self._point
-            self._buf[p:p + amt] = data
-            self._point = min(p + amt, len(self._buf))
-
-    def writelines(self, seq):
-        for line in seq:
-            self.write(line)
-
-    def __iter__(self):
-        return self
-
-    @property
-    def name(self):
-        return repr(self)

=== removed directory 'python-for-subunit2junitxml/iso8601'
=== removed file 'python-for-subunit2junitxml/iso8601/LICENSE'
--- python-for-subunit2junitxml/iso8601/LICENSE	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/iso8601/LICENSE	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-Copyright (c) 2007 Michael Twomey
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

=== removed file 'python-for-subunit2junitxml/iso8601/README'
--- python-for-subunit2junitxml/iso8601/README	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/iso8601/README	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-A simple package to deal with ISO 8601 date time formats.
-
-ISO 8601 defines a neutral, unambiguous date string format, which also
-has the property of sorting naturally.
-
-e.g. YYYY-MM-DDTHH:MM:SSZ or 2007-01-25T12:00:00Z
-
-Currently this covers only the most common date formats encountered, not
-all of ISO 8601 is handled.
-
-Currently the following formats are handled:
-
-* 2006-01-01T00:00:00Z
-* 2006-01-01T00:00:00[+-]00:00
-
-I'll add more as I encounter them in my day to day life. Patches with 
-new formats and tests will be gratefully accepted of course :)
-
-References:
-
-* http://www.cl.cam.ac.uk/~mgk25/iso-time.html - simple overview
-
-* http://hydracen.com/dx/iso8601.htm - more detailed enumeration of
-  valid formats.
-
-See the LICENSE file for the license this package is released under.

=== removed file 'python-for-subunit2junitxml/iso8601/README.subunit'
--- python-for-subunit2junitxml/iso8601/README.subunit	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/iso8601/README.subunit	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-This is a [slightly rearranged] import of http://pypi.python.org/pypi/iso8601/
-version 0.1.4. The OS X hidden files have been stripped, and the package
-turned into a single module, to simplify installation. The remainder of the
-source distribution is included in the subunit source tree at python/iso8601
-for reference.

=== removed file 'python-for-subunit2junitxml/iso8601/setup.py'
--- python-for-subunit2junitxml/iso8601/setup.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/iso8601/setup.py	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-try:
-    from setuptools import setup
-except ImportError:
-    from distutils import setup
-
-long_description="""Simple module to parse ISO 8601 dates
-
-This module parses the most common forms of ISO 8601 date strings (e.g.
-2007-01-14T20:34:22+00:00) into datetime objects.
-
->>> import iso8601
->>> iso8601.parse_date("2007-01-25T12:00:00Z")
-datetime.datetime(2007, 1, 25, 12, 0, tzinfo=<iso8601.iso8601.Utc ...>)
->>>
-
-Changes
-=======
-
-0.1.4
------
-
-* The default_timezone argument wasn't being passed through correctly,
-  UTC was being used in every case. Fixes issue 10.
-
-0.1.3
------
-
-* Fixed the microsecond handling, the generated microsecond values were 
-  way too small. Fixes issue 9.
-
-0.1.2
------
-
-* Adding ParseError to __all__ in iso8601 module, allows people to import it.
-  Addresses issue 7.
-* Be a little more flexible when dealing with dates without leading zeroes.
-  This violates the spec a little, but handles more dates as seen in the 
-  field. Addresses issue 6.
-* Allow date/time separators other than T.
-
-0.1.1
------
-
-* When parsing dates without a timezone the specified default is used. If no
-  default is specified then UTC is used. Addresses issue 4.
-"""
-
-setup(
-    name="iso8601",
-    version="0.1.4",
-    description=long_description.split("\n")[0],
-    long_description=long_description,
-    author="Michael Twomey",
-    author_email="[e-mail]",
-    url="http://code.google.com/p/pyiso8601/",
-    packages=["iso8601"],
-    license="MIT",
-)

=== removed file 'python-for-subunit2junitxml/iso8601/test_iso8601.py'
--- python-for-subunit2junitxml/iso8601/test_iso8601.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/iso8601/test_iso8601.py	1970-01-01 00:00:00 +0000
@@ -1,111 +0,0 @@
-import iso8601
-
-def test_iso8601_regex():
-    assert iso8601.ISO8601_REGEX.match("2006-10-11T00:14:33Z")
-
-def test_timezone_regex():
-    assert iso8601.TIMEZONE_REGEX.match("+01:00")
-    assert iso8601.TIMEZONE_REGEX.match("+00:00")
-    assert iso8601.TIMEZONE_REGEX.match("+01:20")
-    assert iso8601.TIMEZONE_REGEX.match("-01:00")
-
-def test_parse_date():
-    d = iso8601.parse_date("2006-10-20T15:34:56Z")
-    assert d.year == 2006
-    assert d.month == 10
-    assert d.day == 20
-    assert d.hour == 15
-    assert d.minute == 34
-    assert d.second == 56
-    assert d.tzinfo == iso8601.UTC
-
-def test_parse_date_fraction():
-    d = iso8601.parse_date("2006-10-20T15:34:56.123Z")
-    assert d.year == 2006
-    assert d.month == 10
-    assert d.day == 20
-    assert d.hour == 15
-    assert d.minute == 34
-    assert d.second == 56
-    assert d.microsecond == 123000
-    assert d.tzinfo == iso8601.UTC
-
-def test_parse_date_fraction_2():
-    """From bug 6
-    
-    """
-    d = iso8601.parse_date("2007-5-7T11:43:55.328Z'")
-    assert d.year == 2007
-    assert d.month == 5
-    assert d.day == 7
-    assert d.hour == 11
-    assert d.minute == 43
-    assert d.second == 55
-    assert d.microsecond == 328000
-    assert d.tzinfo == iso8601.UTC
-
-def test_parse_date_tz():
-    d = iso8601.parse_date("2006-10-20T15:34:56.123+02:30")
-    assert d.year == 2006
-    assert d.month == 10
-    assert d.day == 20
-    assert d.hour == 15
-    assert d.minute == 34
-    assert d.second == 56
-    assert d.microsecond == 123000
-    assert d.tzinfo.tzname(None) == "+02:30"
-    offset = d.tzinfo.utcoffset(None)
-    assert offset.days == 0
-    assert offset.seconds == 60 * 60 * 2.5
-
-def test_parse_invalid_date():
-    try:
-        iso8601.parse_date(None)
-    except iso8601.ParseError:
-        pass
-    else:
-        assert 1 == 2
-
-def test_parse_invalid_date2():
-    try:
-        iso8601.parse_date("23")
-    except iso8601.ParseError:
-        pass
-    else:
-        assert 1 == 2
-
-def test_parse_no_timezone():
-    """issue 4 - Handle datetime string without timezone
-    
-    This tests what happens when you parse a date with no timezone. While not
-    strictly correct this is quite common. I'll assume UTC for the time zone
-    in this case.
-    """
-    d = iso8601.parse_date("2007-01-01T08:00:00")
-    assert d.year == 2007
-    assert d.month == 1
-    assert d.day == 1
-    assert d.hour == 8
-    assert d.minute == 0
-    assert d.second == 0
-    assert d.microsecond == 0
-    assert d.tzinfo == iso8601.UTC
-
-def test_parse_no_timezone_different_default():
-    tz = iso8601.FixedOffset(2, 0, "test offset")
-    d = iso8601.parse_date("2007-01-01T08:00:00", default_timezone=tz)
-    assert d.tzinfo == tz
-
-def test_space_separator():
-    """Handle a separator other than T
-    
-    """
-    d = iso8601.parse_date("2007-06-23 06:40:34.00Z")
-    assert d.year == 2007
-    assert d.month == 6
-    assert d.day == 23
-    assert d.hour == 6
-    assert d.minute == 40
-    assert d.second == 34
-    assert d.microsecond == 0
-    assert d.tzinfo == iso8601.UTC

=== removed directory 'python-for-subunit2junitxml/junitxml'
=== removed file 'python-for-subunit2junitxml/junitxml/__init__.py'
--- python-for-subunit2junitxml/junitxml/__init__.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/junitxml/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,221 +0,0 @@
-#
-#  junitxml: extensions to Python unittest to get output junitxml
-#  Copyright (C) 2009 Robert Collins <[e-mail]>
-#
-#  Copying permitted under the LGPL-3 licence, included with this library.
-
-"""unittest compatible JUnit XML output."""
-
-
-import datetime
-import re
-import time
-import unittest
-
-# same format as sys.version_info: "A tuple containing the five components of
-# the version number: major, minor, micro, releaselevel, and serial. All
-# values except releaselevel are integers; the release level is 'alpha',
-# 'beta', 'candidate', or 'final'. The version_info value corresponding to the
-# Python version 2.0 is (2, 0, 0, 'final', 0)."  Additionally we use a
-# releaselevel of 'dev' for unreleased under-development code.
-#
-# If the releaselevel is 'alpha' then the major/minor/micro components are not
-# established at this point, and setup.py will use a version of next-$(revno).
-# If the releaselevel is 'final', then the tarball will be major.minor.micro.
-# Otherwise it is major.minor.micro~$(revno).
-__version__ = (0, 7, 0, 'alpha', 0)
-
-
-def test_suite():
-    import junitxml.tests
-    return junitxml.tests.test_suite()
-
-
-class LocalTimezone(datetime.tzinfo):
-
-    def __init__(self):
-        self._offset = None
-
-    # It seems that the minimal possible implementation is to just return all
-    # None for every function, but then it breaks...
-    def utcoffset(self, dt):
-        if self._offset is None:
-            t = 1260423030 # arbitrary, but doesn't handle dst very well
-            dt = datetime.datetime
-            self._offset = (dt.fromtimestamp(t) - dt.utcfromtimestamp(t))
-        return self._offset
-
-    def dst(self, dt):
-        return datetime.timedelta(0)
-
-    def tzname(self, dt):
-        return None
-
-
-def _error_name(eclass):
-    module = eclass.__module__
-    if module not in ("__main__", "builtins", "exceptions"):
-        return ".".join([module, eclass.__name__])
-    return eclass.__name__
-
-
-_non_cdata = "[\0-\b\x0B-\x1F\uD800-\uDFFF\uFFFE\uFFFF]+"
-if "\\u" in _non_cdata:
-    _non_cdata = _non_cdata.decode("unicode-escape")
-    def _strip_invalid_chars(s, _sub=re.compile(_non_cdata, re.UNICODE).sub):
-        if not isinstance(s, unicode):
-            try:
-                s = s.decode("utf-8")
-            except UnicodeDecodeError:
-                s = s.decode("ascii", "replace")
-        return _sub("", s).encode("utf-8")
-else:
-    def _strip_invalid_chars(s, _sub=re.compile(_non_cdata, re.UNICODE).sub):
-        return _sub("", s)
-def _escape_content(s):
-    return (_strip_invalid_chars(s)
-        .replace("&", "&amp;")
-        .replace("<", "&lt;")
-        .replace("]]>", "]]&gt;"))
-def _escape_attr(s):
-    return (_strip_invalid_chars(s)
-        .replace("&", "&amp;")
-        .replace("<", "&lt;")
-        .replace("]]>", "]]&gt;")
-        .replace('"', "&quot;")
-        .replace("\t", "&#x9;")
-        .replace("\n", "&#xA;"))
-
-
-class JUnitXmlResult(unittest.TestResult):
-    """A TestResult which outputs JUnit compatible XML."""
-    
-    def __init__(self, stream):
-        """Create a JUnitXmlResult.
-
-        :param stream: A stream to write results to. Note that due to the
-            nature of JUnit XML output, nnothing will be written to the stream
-            until stopTestRun() is called.
-        """
-        self.__super = super(JUnitXmlResult, self)
-        self.__super.__init__()
-        # GZ 2010-09-03: We have a problem if passed a text stream in Python 3
-        #                as really we want to write raw UTF-8 to ensure that
-        #                the encoding is not mangled later
-        self._stream = stream
-        self._results = []
-        self._set_time = None
-        self._test_start = None
-        self._run_start = None
-        self._tz_info = None
-
-    def startTestRun(self):
-        """Start a test run."""
-        self._run_start = self._now()
-
-    def _get_tzinfo(self):
-        if self._tz_info is None:
-            self._tz_info = LocalTimezone()
-        return self._tz_info
-
-    def _now(self):
-        if self._set_time is not None:
-            return self._set_time
-        else:
-            return datetime.datetime.now(self._get_tzinfo())
-
-    def time(self, a_datetime):
-        self._set_time = a_datetime
-        if (self._run_start is not None and
-            self._run_start > a_datetime):
-            self._run_start = a_datetime
-
-    def startTest(self, test):
-        self.__super.startTest(test)
-        self._test_start = self._now()
-
-    def _duration(self, from_datetime):
-        try:
-            delta = self._now() - from_datetime
-        except TypeError:
-            n = self._now()
-            delta = datetime.timedelta(-1)
-        seconds = delta.days * 3600*24 + delta.seconds
-        return seconds + 0.000001 * delta.microseconds
-
-    def _test_case_string(self, test):
-        duration = self._duration(self._test_start)
-        test_id = test.id()
-        # Split on the last dot not inside a parameter
-        class_end = test_id.rfind(".", 0, test_id.find("("))
-        if class_end == -1:
-            classname, name = "", test_id
-        else:
-            classname, name = test_id[:class_end], test_id[class_end+1:]
-        self._results.append('<testcase classname="%s" name="%s" '
-            'time="%0.3f"' % (_escape_attr(classname), _escape_attr(name), duration))
-
-    def stopTestRun(self):
-        """Stop a test run.
-
-        This allows JUnitXmlResult to output the XML representation of the test
-        run.
-        """
-        duration = self._duration(self._run_start)
-        self._stream.write('<testsuite errors="%d" failures="%d" name="" '
-            'tests="%d" time="%0.3f">\n' % (len(self.errors),
-            len(self.failures) + len(getattr(self, "unexpectedSuccesses", ())),
-            self.testsRun, duration))
-        self._stream.write(''.join(self._results))
-        self._stream.write('</testsuite>\n')
-
-    def addError(self, test, error):
-        self.__super.addError(test, error)
-        self._test_case_string(test)
-        self._results.append('>\n')
-        self._results.append('<error type="%s">%s</error>\n</testcase>\n' % (
-            _escape_attr(_error_name(error[0])),
-            _escape_content(self._exc_info_to_string(error, test))))
-
-    def addFailure(self, test, error):
-        self.__super.addFailure(test, error)
-        self._test_case_string(test)
-        self._results.append('>\n')
-        self._results.append('<failure type="%s">%s</failure>\n</testcase>\n' %
-            (_escape_attr(_error_name(error[0])),
-            _escape_content(self._exc_info_to_string(error, test))))
-
-    def addSuccess(self, test):
-        self.__super.addSuccess(test)
-        self._test_case_string(test)
-        self._results.append('/>\n')
-
-    def addSkip(self, test, reason):
-        try:
-            self.__super.addSkip(test, reason)
-        except AttributeError:
-            # Python < 2.7|3.1
-            pass
-        self._test_case_string(test)
-        self._results.append('>\n')
-        self._results.append('<skip>%s</skip>\n</testcase>\n'% _escape_attr(reason))
-
-    def addUnexpectedSuccess(self, test):
-        try:
-            self.__super.addUnexpectedSuccess(test)
-        except AttributeError:
-            # Python < 2.7|3.1
-            pass
-        self._test_case_string(test)
-        self._results.append('>\n')
-        self._results.append('<failure type="unittest.case._UnexpectedSuccess"/>\n</testcase>\n')
-
-    def addExpectedFailure(self, test, error):
-        try:
-            self.__super.addExpectedFailure(test, error)
-        except AttributeError:
-            # Python < 2.7|3.1
-            pass
-        self._test_case_string(test)
-        self._results.append('/>\n')
-

=== removed directory 'python-for-subunit2junitxml/junitxml/tests'
=== removed file 'python-for-subunit2junitxml/junitxml/tests/__init__.py'
--- python-for-subunit2junitxml/junitxml/tests/__init__.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/junitxml/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-#
-#  junitxml: extensions to Python unittest to get output junitxml
-#  Copyright (C) 2009 Robert Collins <[e-mail]>
-#
-#  Copying permitted under the LGPL-3 licence, included with this library.
-
-import unittest
-
-from junitxml.tests import (
-    test_junitxml,
-    )
-
-def test_suite():
-    return unittest.TestLoader().loadTestsFromNames([
-        'junitxml.tests.test_junitxml',
-        ])

=== removed file 'python-for-subunit2junitxml/junitxml/tests/test_junitxml.py'
--- python-for-subunit2junitxml/junitxml/tests/test_junitxml.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/junitxml/tests/test_junitxml.py	1970-01-01 00:00:00 +0000
@@ -1,327 +0,0 @@
-#
-#  junitxml: extensions to Python unittest to get output junitxml
-#  Copyright (C) 2009 Robert Collins <[e-mail]>
-#
-#  Copying permitted under the LGPL-3 licence, included with this library.
-
-
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from io import StringIO
-import datetime
-import re
-import sys
-import unittest
-import xml.dom.minidom
-
-import junitxml
-
-class TestImports(unittest.TestCase):
-
-    def test_result(self):
-        from junitxml import JUnitXmlResult
-
-
-class TestJUnitXmlResult__init__(unittest.TestCase):
-
-    def test_with_stream(self):
-        result = junitxml.JUnitXmlResult(StringIO())
-
-
-class TestJUnitXmlResult(unittest.TestCase):
-
-    def setUp(self):
-        self.output = StringIO()
-        self.result = junitxml.JUnitXmlResult(self.output)
-
-    def get_output(self):
-        output = self.output.getvalue()
-        # Collapse detailed regions into specific strings we can match on
-        return re.sub(r'(?s)<failure (.*?)>.*?</failure>',
-            r'<failure \1>failure</failure>', re.sub(
-            r'(?s)<error (.*?)>.*?</error>', r'<error \1>error</error>',
-            re.sub(r'time="\d+\.\d+"', 'time="0.000"', output)))
-
-    def run_test_or_simulate(self, test, method_name, manual_method,
-        *manual_args):
-        if getattr(test, method_name, None):
-            test.run(self.result)
-        else:
-            # older python - manually execute
-            self.result.startTest(test)
-            manual_method(test, *manual_args)
-            self.result.stopTest(test)
-
-    def test_run_duration_handles_datestamping_in_the_past(self):
-        # When used via subunit2junitxml, startTestRun is called before
-        # any tz info in the test stream has been seen.
-        # So, we use the earliest reported timestamp as the start time,
-        # replacing _test_start if needed.
-        self.result.startTestRun() # the time is now.
-        # Lose an hour (peeks inside, a little naughty but not very).
-        self.result.time(self.result._run_start - datetime.timedelta(0, 3600))
-        self.result.stopTestRun()
-        self.assertEqual("""<testsuite errors="0" failures="0" name="" tests="0" time="0.000">
-</testsuite>
-""", self.get_output())
-
-    def test_startTestRun_no_output(self):
-        # startTestRun doesn't output anything, because JUnit wants an up-front
-        # summary.
-        self.result.startTestRun()
-        self.assertEqual('', self.get_output())
-
-    def test_stopTestRun_outputs(self):
-        # When stopTestRun is called, everything is output.
-        self.result.startTestRun()
-        self.result.stopTestRun()
-        self.assertEqual("""<testsuite errors="0" failures="0" name="" tests="0" time="0.000">
-</testsuite>
-""", self.get_output())
-
-    def test_test_count(self):
-        class Passes(unittest.TestCase):
-            def test_me(self):
-                pass
-        self.result.startTestRun()
-        Passes("test_me").run(self.result)
-        Passes("test_me").run(self.result)
-        self.result.stopTestRun()
-        # When tests are run, the number of tests is counted.
-        output = self.get_output()
-        self.assertTrue('tests="2"' in output)
-
-    def test_test_id_with_parameter(self):
-        class Passes(unittest.TestCase):
-            def id(self):
-                return unittest.TestCase.id(self) + '(version_1.6)'
-            def test_me(self):
-                pass
-        self.result.startTestRun()
-        Passes("test_me").run(self.result)
-        self.result.stopTestRun()
-        output = self.get_output()
-        self.assertTrue('Passes" name="test_me(version_1.6)"' in output)
-
-    def test_erroring_test(self):
-        class Errors(unittest.TestCase):
-            def test_me(self):
-                1/0
-        self.result.startTestRun()
-        Errors("test_me").run(self.result)
-        self.result.stopTestRun()
-        self.assertEqual("""<testsuite errors="1" failures="0" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.Errors" name="test_me" time="0.000">
-<error type="ZeroDivisionError">error</error>
-</testcase>
-</testsuite>
-""", self.get_output())
-
-    def test_failing_test(self):
-        class Fails(unittest.TestCase):
-            def test_me(self):
-                self.fail()
-        self.result.startTestRun()
-        Fails("test_me").run(self.result)
-        self.result.stopTestRun()
-        self.assertEqual("""<testsuite errors="0" failures="1" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.Fails" name="test_me" time="0.000">
-<failure type="AssertionError">failure</failure>
-</testcase>
-</testsuite>
-""", self.get_output())
-
-    def test_successful_test(self):
-        class Passes(unittest.TestCase):
-            def test_me(self):
-                pass
-        self.result.startTestRun()
-        Passes("test_me").run(self.result)
-        self.result.stopTestRun()
-        self.assertEqual("""<testsuite errors="0" failures="0" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.Passes" name="test_me" time="0.000"/>
-</testsuite>
-""", self.get_output())
-
-    def test_skip_test(self):
-        class Skips(unittest.TestCase):
-            def test_me(self):
-                self.skipTest("yo")
-        self.result.startTestRun()
-        test = Skips("test_me")
-        self.run_test_or_simulate(test, 'skipTest', self.result.addSkip, 'yo')
-        self.result.stopTestRun()
-        output = self.get_output()
-        expected = """<testsuite errors="0" failures="0" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.Skips" name="test_me" time="0.000">
-<skip>yo</skip>
-</testcase>
-</testsuite>
-"""
-        self.assertEqual(expected, output)
-
-    def test_unexpected_success_test(self):
-        class Succeeds(unittest.TestCase):
-            def test_me(self):
-                pass
-            try:
-                test_me = unittest.expectedFailure(test_me)
-            except AttributeError:
-                pass # Older python - just let the test pass
-        self.result.startTestRun()
-        Succeeds("test_me").run(self.result)
-        self.result.stopTestRun()
-        output = self.get_output()
-        expected = """<testsuite errors="0" failures="1" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.Succeeds" name="test_me" time="0.000">
-<failure type="unittest.case._UnexpectedSuccess"/>
-</testcase>
-</testsuite>
-"""
-        expected_old = """<testsuite errors="0" failures="0" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.Succeeds" name="test_me" time="0.000"/>
-</testsuite>
-"""
-        if output != expected_old:
-            self.assertEqual(expected, output)
-
-    def test_expected_failure_test(self):
-        expected_failure_support = [True]
-        class ExpectedFail(unittest.TestCase):
-            def test_me(self):
-                self.fail("fail")
-            try:
-                test_me = unittest.expectedFailure(test_me)
-            except AttributeError:
-                # Older python - just let the test fail
-                expected_failure_support[0] = False
-        self.result.startTestRun()
-        ExpectedFail("test_me").run(self.result)
-        self.result.stopTestRun()
-        output = self.get_output()
-        expected = """<testsuite errors="0" failures="0" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.ExpectedFail" name="test_me" time="0.000"/>
-</testsuite>
-"""
-        expected_old = """<testsuite errors="0" failures="1" name="" tests="1" time="0.000">
-<testcase classname="junitxml.tests.test_junitxml.ExpectedFail" name="test_me" time="0.000">
-<failure type="AssertionError">failure</failure>
-</testcase>
-</testsuite>
-"""
-        if expected_failure_support[0]:
-            self.assertEqual(expected, output)
-        else:
-            self.assertEqual(expected_old, output)
-
-
-class TestWellFormedXml(unittest.TestCase):
-    """XML created should always be well formed even with odd test cases"""
-
-    def _run_and_parse_test(self, case):
-        output = StringIO()
-        result = junitxml.JUnitXmlResult(output)
-        result.startTestRun()
-        case.run(result)
-        result.stopTestRun()
-        return xml.dom.minidom.parseString(output.getvalue())
-
-    def test_failure_with_amp(self):
-        """Check the failure element content is escaped"""
-        class FailWithAmp(unittest.TestCase):
-            def runTest(self):
-                self.fail("& should be escaped as &amp;")
-        doc = self._run_and_parse_test(FailWithAmp())
-        self.assertTrue(
-            doc.getElementsByTagName("failure")[0].firstChild.nodeValue
-                .endswith("AssertionError: & should be escaped as &amp;\n"))
-
-    def test_quotes_in_test_case_id(self):
-        """Check that quotes in an attribute are escaped"""
-        class QuoteId(unittest.TestCase):
-            def id(self):
-                return unittest.TestCase.id(self) + '("quotes")'
-            def runTest(self):
-                pass
-        doc = self._run_and_parse_test(QuoteId())
-        self.assertEqual('runTest("quotes")',
-            doc.getElementsByTagName("testcase")[0].getAttribute("name"))
-
-    def test_skip_reason(self):
-        """Check the skip element content is escaped"""
-        class SkipWithLt(unittest.TestCase):
-            def runTest(self):
-                self.fail("version < 2.7")
-            try:
-                runTest = unittest.skip("2.7 <= version")(runTest)
-            except AttributeError:
-                self.has_skip = False
-            else:
-                self.has_skip = True
-        doc = self._run_and_parse_test(SkipWithLt())
-        if self.has_skip:
-            self.assertEqual('2.7 <= version',
-                doc.getElementsByTagName("skip")[0].firstChild.nodeValue)
-        else:
-            self.assertTrue(
-                doc.getElementsByTagName("failure")[0].firstChild.nodeValue
-                    .endswith("AssertionError: version < 2.7\n"))
-
-    def test_error_with_control_characters(self):
-        """Check C0 control characters are stripped rather than output"""
-        class ErrorWithC0(unittest.TestCase):
-            def runTest(self):
-                raise ValueError("\x1F\x0E\x0C\x0B\x08\x01\x00lost control")
-        doc = self._run_and_parse_test(ErrorWithC0())
-        self.assertTrue(
-            doc.getElementsByTagName("error")[0].firstChild.nodeValue
-                .endswith("ValueError: lost control\n"))
-
-    def test_error_with_invalid_cdata(self):
-        """Check unicode outside the valid cdata range is stripped"""
-        if len("\uffff") == 1:
-            # Basic str type supports unicode
-            exception = ValueError("\ufffe\uffffEOF")
-        else:
-            class UTF8_Error(Exception):
-                def __unicode__(self):
-                    return str(self).decode("UTF-8")
-            exception = UTF8_Error("\xef\xbf\xbe\xef\xbf\xbfEOF")
-        class ErrorWithBadUnicode(unittest.TestCase):
-            def runTest(self):
-                raise exception
-        doc = self._run_and_parse_test(ErrorWithBadUnicode())
-        self.assertTrue(
-            doc.getElementsByTagName("error")[0].firstChild.nodeValue
-                .endswith("Error: EOF\n"))
-
-    def test_error_with_surrogates(self):
-        """Check unicode surrogates are handled properly, paired or otherwise
-
-        This is a pain due to suboptimal unicode support in Python and the
-        various changes in Python 3. On UCS-2 builds there is no easy way of
-        getting rid of unpaired surrogates while leaving valid pairs alone, so
-        this test doesn't require astral characters are kept there.
-        """
-        if len("\uffff") == 1:
-            exception = ValueError("paired: \U000201a2"
-                " unpaired: "+chr(0xD800)+"-"+chr(0xDFFF))
-            astral_char = "\U000201a2"
-        else:
-            class UTF8_Error(Exception):
-                def __unicode__(self):
-                    return str(self).decode("UTF-8")
-            exception = UTF8_Error("paired: \xf0\xa0\x86\xa2"
-                " unpaired: \xed\xa0\x80-\xed\xbf\xbf")
-            astral_char = "\U000201a2".decode("unicode-escape")
-        class ErrorWithSurrogates(unittest.TestCase):
-            def runTest(self):
-                raise exception
-        doc = self._run_and_parse_test(ErrorWithSurrogates())
-        traceback = doc.getElementsByTagName("error")[0].firstChild.nodeValue
-        if sys.maxunicode == 0xFFFF:
-            pass # would be nice to handle astral characters properly even so
-        else:
-            self.assertTrue(astral_char in traceback)
-        self.assertTrue(traceback.endswith(" unpaired: -\n"))

=== removed directory 'python-for-subunit2junitxml/subunit'
=== removed file 'python-for-subunit2junitxml/subunit/__init__.py'
--- python-for-subunit2junitxml/subunit/__init__.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1250 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Subunit - a streaming test protocol
-
-Overview
-++++++++
-
-The ``subunit`` Python package provides a number of ``unittest`` extensions
-which can be used to cause tests to output Subunit, to parse Subunit streams
-into test activity, perform seamless test isolation within a regular test
-case and variously sort, filter and report on test runs.
-
-
-Key Classes
------------
-
-The ``subunit.TestProtocolClient`` class is a ``unittest.TestResult``
-extension which will translate a test run into a Subunit stream.
-
-The ``subunit.ProtocolTestCase`` class is an adapter between the Subunit wire
-protocol and the ``unittest.TestCase`` object protocol. It is used to translate
-a stream into a test run, which regular ``unittest.TestResult`` objects can
-process and report/inspect.
-
-Subunit has support for non-blocking usage too, for use with asyncore or
-Twisted. See the ``TestProtocolServer`` parser class for more details.
-
-Subunit includes extensions to the Python ``TestResult`` protocol. These are
-all done in a compatible manner: ``TestResult`` objects that do not implement
-the extension methods will not cause errors to be raised, instead the extension
-will either lose fidelity (for instance, folding expected failures to success
-in Python versions < 2.7 or 3.1), or discard the extended data (for extra
-details, tags, timestamping and progress markers).
-
-The test outcome methods ``addSuccess``, ``addError``, ``addExpectedFailure``,
-``addFailure``, ``addSkip`` take an optional keyword parameter ``details``
-which can be used instead of the usual python unittest parameter.
-When used the value of details should be a dict from ``string`` to
-``testtools.content.Content`` objects. This is a draft API being worked on with
-the Python Testing In Python mail list, with the goal of permitting a common
-way to provide additional data beyond a traceback, such as captured data from
-disk, logging messages etc. The reference for this API is in testtools (0.9.0
-and newer).
-
-The ``tags(new_tags, gone_tags)`` method is called (if present) to add or
-remove tags in the test run that is currently executing. If called when no
-test is in progress (that is, if called outside of the ``startTest``,
-``stopTest`` pair), the the tags apply to all sebsequent tests. If called
-when a test is in progress, then the tags only apply to that test.
-
-The ``time(a_datetime)`` method is called (if present) when a ``time:``
-directive is encountered in a Subunit stream. This is used to tell a TestResult
-about the time that events in the stream occured at, to allow reconstructing
-test timing from a stream.
-
-The ``progress(offset, whence)`` method controls progress data for a stream.
-The offset parameter is an int, and whence is one of subunit.PROGRESS_CUR,
-subunit.PROGRESS_SET, PROGRESS_PUSH, PROGRESS_POP. Push and pop operations
-ignore the offset parameter.
-
-
-Python test support
--------------------
-
-``subunit.run`` is a convenience wrapper to run a Python test suite via
-the command line, reporting via Subunit::
-
-  $ python -m subunit.run mylib.tests.test_suite
-
-The ``IsolatedTestSuite`` class is a TestSuite that forks before running its
-tests, allowing isolation between the test runner and some tests.
-
-Similarly, ``IsolatedTestCase`` is a base class which can be subclassed to get
-tests that will fork() before that individual test is run.
-
-`ExecTestCase`` is a convenience wrapper for running an external
-program to get a Subunit stream and then report that back to an arbitrary
-result object::
-
- class AggregateTests(subunit.ExecTestCase):
-
-     def test_script_one(self):
-         './bin/script_one'
-
-     def test_script_two(self):
-         './bin/script_two'
-
- # Normally your normal test loading would take of this automatically,
- # It is only spelt out in detail here for clarity.
- suite = unittest.TestSuite([AggregateTests("test_script_one"),
-     AggregateTests("test_script_two")])
- # Create any TestResult class you like.
- result = unittest._TextTestResult(sys.stdout)
- # And run your suite as normal, Subunit will exec each external script as
- # needed and report to your result object.
- suite.run(result)
-
-Utility modules
----------------
-
-* subunit.chunked contains HTTP chunked encoding/decoding logic.
-* subunit.test_results contains TestResult helper classes.
-"""
-
-import os
-import re
-import subprocess
-import sys
-import unittest
-
-from testtools import content, content_type, ExtendedToOriginalDecorator
-from testtools.compat import _b, _u, BytesIO, StringIO
-try:
-    from testtools.testresult.real import _StringException
-    RemoteException = _StringException
-    # For testing: different pythons have different str() implementations.
-    if sys.version_info > (3, 0):
-        _remote_exception_str = "testtools.testresult.real._StringException"
-        _remote_exception_str_chunked = "34\r\n" + _remote_exception_str
-    else:
-        _remote_exception_str = "_StringException" 
-        _remote_exception_str_chunked = "1A\r\n" + _remote_exception_str
-except ImportError:
-    raise ImportError ("testtools.testresult.real does not contain "
-        "_StringException, check your version.")
-from testtools import testresult
-
-from subunit import chunked, details, iso8601, test_results
-
-
-PROGRESS_SET = 0
-PROGRESS_CUR = 1
-PROGRESS_PUSH = 2
-PROGRESS_POP = 3
-
-
-def test_suite():
-    import subunit.tests
-    return subunit.tests.test_suite()
-
-
-def join_dir(base_path, path):
-    """
-    Returns an absolute path to C{path}, calculated relative to the parent
-    of C{base_path}.
-
-    @param base_path: A path to a file or directory.
-    @param path: An absolute path, or a path relative to the containing
-    directory of C{base_path}.
-
-    @return: An absolute path to C{path}.
-    """
-    return os.path.join(os.path.dirname(os.path.abspath(base_path)), path)
-
-
-def tags_to_new_gone(tags):
-    """Split a list of tags into a new_set and a gone_set."""
-    new_tags = set()
-    gone_tags = set()
-    for tag in tags:
-        if tag[0] == '-':
-            gone_tags.add(tag[1:])
-        else:
-            new_tags.add(tag)
-    return new_tags, gone_tags
-
-
-class DiscardStream(object):
-    """A filelike object which discards what is written to it."""
-
-    def write(self, bytes):
-        pass
-
-
-class _ParserState(object):
-    """State for the subunit parser."""
-
-    def __init__(self, parser):
-        self.parser = parser
-        self._test_sym = (_b('test'), _b('testing'))
-        self._colon_sym = _b(':')
-        self._error_sym = (_b('error'),)
-        self._failure_sym = (_b('failure'),)
-        self._progress_sym = (_b('progress'),)
-        self._skip_sym = _b('skip')
-        self._success_sym = (_b('success'), _b('successful'))
-        self._tags_sym = (_b('tags'),)
-        self._time_sym = (_b('time'),)
-        self._xfail_sym = (_b('xfail'),)
-        self._uxsuccess_sym = (_b('uxsuccess'),)
-        self._start_simple = _u(" [")
-        self._start_multipart = _u(" [ multipart")
-
-    def addError(self, offset, line):
-        """An 'error:' directive has been read."""
-        self.parser.stdOutLineReceived(line)
-
-    def addExpectedFail(self, offset, line):
-        """An 'xfail:' directive has been read."""
-        self.parser.stdOutLineReceived(line)
-
-    def addFailure(self, offset, line):
-        """A 'failure:' directive has been read."""
-        self.parser.stdOutLineReceived(line)
-
-    def addSkip(self, offset, line):
-        """A 'skip:' directive has been read."""
-        self.parser.stdOutLineReceived(line)
-
-    def addSuccess(self, offset, line):
-        """A 'success:' directive has been read."""
-        self.parser.stdOutLineReceived(line)
-
-    def lineReceived(self, line):
-        """a line has been received."""
-        parts = line.split(None, 1)
-        if len(parts) == 2 and line.startswith(parts[0]):
-            cmd, rest = parts
-            offset = len(cmd) + 1
-            cmd = cmd.rstrip(self._colon_sym)
-            if cmd in self._test_sym:
-                self.startTest(offset, line)
-            elif cmd in self._error_sym:
-                self.addError(offset, line)
-            elif cmd in self._failure_sym:
-                self.addFailure(offset, line)
-            elif cmd in self._progress_sym:
-                self.parser._handleProgress(offset, line)
-            elif cmd in self._skip_sym:
-                self.addSkip(offset, line)
-            elif cmd in self._success_sym:
-                self.addSuccess(offset, line)
-            elif cmd in self._tags_sym:
-                self.parser._handleTags(offset, line)
-                self.parser.subunitLineReceived(line)
-            elif cmd in self._time_sym:
-                self.parser._handleTime(offset, line)
-                self.parser.subunitLineReceived(line)
-            elif cmd in self._xfail_sym:
-                self.addExpectedFail(offset, line)
-            elif cmd in self._uxsuccess_sym:
-                self.addUnexpectedSuccess(offset, line)
-            else:
-                self.parser.stdOutLineReceived(line)
-        else:
-            self.parser.stdOutLineReceived(line)
-
-    def lostConnection(self):
-        """Connection lost."""
-        self.parser._lostConnectionInTest(_u('unknown state of '))
-
-    def startTest(self, offset, line):
-        """A test start command received."""
-        self.parser.stdOutLineReceived(line)
-
-
-class _InTest(_ParserState):
-    """State for the subunit parser after reading a test: directive."""
-
-    def _outcome(self, offset, line, no_details, details_state):
-        """An outcome directive has been read.
-
-        :param no_details: Callable to call when no details are presented.
-        :param details_state: The state to switch to for details
-            processing of this outcome.
-        """
-        test_name = line[offset:-1].decode('utf8')
-        if self.parser.current_test_description == test_name:
-            self.parser._state = self.parser._outside_test
-            self.parser.current_test_description = None
-            no_details()
-            self.parser.client.stopTest(self.parser._current_test)
-            self.parser._current_test = None
-            self.parser.subunitLineReceived(line)
-        elif self.parser.current_test_description + self._start_simple == \
-            test_name:
-            self.parser._state = details_state
-            details_state.set_simple()
-            self.parser.subunitLineReceived(line)
-        elif self.parser.current_test_description + self._start_multipart == \
-            test_name:
-            self.parser._state = details_state
-            details_state.set_multipart()
-            self.parser.subunitLineReceived(line)
-        else:
-            self.parser.stdOutLineReceived(line)
-
-    def _error(self):
-        self.parser.client.addError(self.parser._current_test,
-            details={})
-
-    def addError(self, offset, line):
-        """An 'error:' directive has been read."""
-        self._outcome(offset, line, self._error,
-            self.parser._reading_error_details)
-
-    def _xfail(self):
-        self.parser.client.addExpectedFailure(self.parser._current_test,
-            details={})
-
-    def addExpectedFail(self, offset, line):
-        """An 'xfail:' directive has been read."""
-        self._outcome(offset, line, self._xfail,
-            self.parser._reading_xfail_details)
-
-    def _uxsuccess(self):
-        self.parser.client.addUnexpectedSuccess(self.parser._current_test)
-
-    def addUnexpectedSuccess(self, offset, line):
-        """A 'uxsuccess:' directive has been read."""
-        self._outcome(offset, line, self._uxsuccess,
-            self.parser._reading_uxsuccess_details)
-
-    def _failure(self):
-        self.parser.client.addFailure(self.parser._current_test, details={})
-
-    def addFailure(self, offset, line):
-        """A 'failure:' directive has been read."""
-        self._outcome(offset, line, self._failure,
-            self.parser._reading_failure_details)
-
-    def _skip(self):
-        self.parser.client.addSkip(self.parser._current_test, details={})
-
-    def addSkip(self, offset, line):
-        """A 'skip:' directive has been read."""
-        self._outcome(offset, line, self._skip,
-            self.parser._reading_skip_details)
-
-    def _succeed(self):
-        self.parser.client.addSuccess(self.parser._current_test, details={})
-
-    def addSuccess(self, offset, line):
-        """A 'success:' directive has been read."""
-        self._outcome(offset, line, self._succeed,
-            self.parser._reading_success_details)
-
-    def lostConnection(self):
-        """Connection lost."""
-        self.parser._lostConnectionInTest(_u(''))
-
-
-class _OutSideTest(_ParserState):
-    """State for the subunit parser outside of a test context."""
-
-    def lostConnection(self):
-        """Connection lost."""
-
-    def startTest(self, offset, line):
-        """A test start command received."""
-        self.parser._state = self.parser._in_test
-        test_name = line[offset:-1].decode('utf8')
-        self.parser._current_test = RemotedTestCase(test_name)
-        self.parser.current_test_description = test_name
-        self.parser.client.startTest(self.parser._current_test)
-        self.parser.subunitLineReceived(line)
-
-
-class _ReadingDetails(_ParserState):
-    """Common logic for readin state details."""
-
-    def endDetails(self):
-        """The end of a details section has been reached."""
-        self.parser._state = self.parser._outside_test
-        self.parser.current_test_description = None
-        self._report_outcome()
-        self.parser.client.stopTest(self.parser._current_test)
-
-    def lineReceived(self, line):
-        """a line has been received."""
-        self.details_parser.lineReceived(line)
-        self.parser.subunitLineReceived(line)
-
-    def lostConnection(self):
-        """Connection lost."""
-        self.parser._lostConnectionInTest(_u('%s report of ') %
-            self._outcome_label())
-
-    def _outcome_label(self):
-        """The label to describe this outcome."""
-        raise NotImplementedError(self._outcome_label)
-
-    def set_simple(self):
-        """Start a simple details parser."""
-        self.details_parser = details.SimpleDetailsParser(self)
-
-    def set_multipart(self):
-        """Start a multipart details parser."""
-        self.details_parser = details.MultipartDetailsParser(self)
-
-
-class _ReadingFailureDetails(_ReadingDetails):
-    """State for the subunit parser when reading failure details."""
-
-    def _report_outcome(self):
-        self.parser.client.addFailure(self.parser._current_test,
-            details=self.details_parser.get_details())
-
-    def _outcome_label(self):
-        return "failure"
-
-
-class _ReadingErrorDetails(_ReadingDetails):
-    """State for the subunit parser when reading error details."""
-
-    def _report_outcome(self):
-        self.parser.client.addError(self.parser._current_test,
-            details=self.details_parser.get_details())
-
-    def _outcome_label(self):
-        return "error"
-
-
-class _ReadingExpectedFailureDetails(_ReadingDetails):
-    """State for the subunit parser when reading xfail details."""
-
-    def _report_outcome(self):
-        self.parser.client.addExpectedFailure(self.parser._current_test,
-            details=self.details_parser.get_details())
-
-    def _outcome_label(self):
-        return "xfail"
-
-
-class _ReadingUnexpectedSuccessDetails(_ReadingDetails):
-    """State for the subunit parser when reading uxsuccess details."""
-
-    def _report_outcome(self):
-        self.parser.client.addUnexpectedSuccess(self.parser._current_test,
-            details=self.details_parser.get_details())
-
-    def _outcome_label(self):
-        return "uxsuccess"
-
-
-class _ReadingSkipDetails(_ReadingDetails):
-    """State for the subunit parser when reading skip details."""
-
-    def _report_outcome(self):
-        self.parser.client.addSkip(self.parser._current_test,
-            details=self.details_parser.get_details("skip"))
-
-    def _outcome_label(self):
-        return "skip"
-
-
-class _ReadingSuccessDetails(_ReadingDetails):
-    """State for the subunit parser when reading success details."""
-
-    def _report_outcome(self):
-        self.parser.client.addSuccess(self.parser._current_test,
-            details=self.details_parser.get_details("success"))
-
-    def _outcome_label(self):
-        return "success"
-
-
-class TestProtocolServer(object):
-    """A parser for subunit.
-
-    :ivar tags: The current tags associated with the protocol stream.
-    """
-
-    def __init__(self, client, stream=None, forward_stream=None):
-        """Create a TestProtocolServer instance.
-
-        :param client: An object meeting the unittest.TestResult protocol.
-        :param stream: The stream that lines received which are not part of the
-            subunit protocol should be written to. This allows custom handling
-            of mixed protocols. By default, sys.stdout will be used for
-            convenience. It should accept bytes to its write() method.
-        :param forward_stream: A stream to forward subunit lines to. This
-            allows a filter to forward the entire stream while still parsing
-            and acting on it. By default forward_stream is set to
-            DiscardStream() and no forwarding happens.
-        """
-        self.client = ExtendedToOriginalDecorator(client)
-        if stream is None:
-            stream = sys.stdout
-            if sys.version_info > (3, 0):
-                stream = stream.buffer
-        self._stream = stream
-        self._forward_stream = forward_stream or DiscardStream()
-        # state objects we can switch too
-        self._in_test = _InTest(self)
-        self._outside_test = _OutSideTest(self)
-        self._reading_error_details = _ReadingErrorDetails(self)
-        self._reading_failure_details = _ReadingFailureDetails(self)
-        self._reading_skip_details = _ReadingSkipDetails(self)
-        self._reading_success_details = _ReadingSuccessDetails(self)
-        self._reading_xfail_details = _ReadingExpectedFailureDetails(self)
-        self._reading_uxsuccess_details = _ReadingUnexpectedSuccessDetails(self)
-        # start with outside test.
-        self._state = self._outside_test
-        # Avoid casts on every call
-        self._plusminus = _b('+-')
-        self._push_sym = _b('push')
-        self._pop_sym = _b('pop')
-
-    def _handleProgress(self, offset, line):
-        """Process a progress directive."""
-        line = line[offset:].strip()
-        if line[0] in self._plusminus:
-            whence = PROGRESS_CUR
-            delta = int(line)
-        elif line == self._push_sym:
-            whence = PROGRESS_PUSH
-            delta = None
-        elif line == self._pop_sym:
-            whence = PROGRESS_POP
-            delta = None
-        else:
-            whence = PROGRESS_SET
-            delta = int(line)
-        self.client.progress(delta, whence)
-
-    def _handleTags(self, offset, line):
-        """Process a tags command."""
-        tags = line[offset:].decode('utf8').split()
-        new_tags, gone_tags = tags_to_new_gone(tags)
-        self.client.tags(new_tags, gone_tags)
-
-    def _handleTime(self, offset, line):
-        # Accept it, but do not do anything with it yet.
-        try:
-            event_time = iso8601.parse_date(line[offset:-1])
-        except TypeError:
-            raise TypeError(_u("Failed to parse %r, got %r")
-                % (line, sys.exec_info[1]))
-        self.client.time(event_time)
-
-    def lineReceived(self, line):
-        """Call the appropriate local method for the received line."""
-        self._state.lineReceived(line)
-
-    def _lostConnectionInTest(self, state_string):
-        error_string = _u("lost connection during %stest '%s'") % (
-            state_string, self.current_test_description)
-        self.client.addError(self._current_test, RemoteError(error_string))
-        self.client.stopTest(self._current_test)
-
-    def lostConnection(self):
-        """The input connection has finished."""
-        self._state.lostConnection()
-
-    def readFrom(self, pipe):
-        """Blocking convenience API to parse an entire stream.
-
-        :param pipe: A file-like object supporting readlines().
-        :return: None.
-        """
-        for line in pipe.readlines():
-            self.lineReceived(line)
-        self.lostConnection()
-
-    def _startTest(self, offset, line):
-        """Internal call to change state machine. Override startTest()."""
-        self._state.startTest(offset, line)
-
-    def subunitLineReceived(self, line):
-        self._forward_stream.write(line)
-
-    def stdOutLineReceived(self, line):
-        self._stream.write(line)
-
-
-class TestProtocolClient(testresult.TestResult):
-    """A TestResult which generates a subunit stream for a test run.
-
-    # Get a TestSuite or TestCase to run
-    suite = make_suite()
-    # Create a stream (any object with a 'write' method). This should accept
-    # bytes not strings: subunit is a byte orientated protocol.
-    stream = file('tests.log', 'wb')
-    # Create a subunit result object which will output to the stream
-    result = subunit.TestProtocolClient(stream)
-    # Optionally, to get timing data for performance analysis, wrap the
-    # serialiser with a timing decorator
-    result = subunit.test_results.AutoTimingTestResultDecorator(result)
-    # Run the test suite reporting to the subunit result object
-    suite.run(result)
-    # Close the stream.
-    stream.close()
-    """
-
-    def __init__(self, stream):
-        testresult.TestResult.__init__(self)
-        self._stream = stream
-        _make_stream_binary(stream)
-        self._progress_fmt = _b("progress: ")
-        self._bytes_eol = _b("\n")
-        self._progress_plus = _b("+")
-        self._progress_push = _b("push")
-        self._progress_pop = _b("pop")
-        self._empty_bytes = _b("")
-        self._start_simple = _b(" [\n")
-        self._end_simple = _b("]\n")
-
-    def addError(self, test, error=None, details=None):
-        """Report an error in test test.
-
-        Only one of error and details should be provided: conceptually there
-        are two separate methods:
-            addError(self, test, error)
-            addError(self, test, details)
-
-        :param error: Standard unittest positional argument form - an
-            exc_info tuple.
-        :param details: New Testing-in-python drafted API; a dict from string
-            to subunit.Content objects.
-        """
-        self._addOutcome("error", test, error=error, details=details)
-
-    def addExpectedFailure(self, test, error=None, details=None):
-        """Report an expected failure in test test.
-
-        Only one of error and details should be provided: conceptually there
-        are two separate methods:
-            addError(self, test, error)
-            addError(self, test, details)
-
-        :param error: Standard unittest positional argument form - an
-            exc_info tuple.
-        :param details: New Testing-in-python drafted API; a dict from string
-            to subunit.Content objects.
-        """
-        self._addOutcome("xfail", test, error=error, details=details)
-
-    def addFailure(self, test, error=None, details=None):
-        """Report a failure in test test.
-
-        Only one of error and details should be provided: conceptually there
-        are two separate methods:
-            addFailure(self, test, error)
-            addFailure(self, test, details)
-
-        :param error: Standard unittest positional argument form - an
-            exc_info tuple.
-        :param details: New Testing-in-python drafted API; a dict from string
-            to subunit.Content objects.
-        """
-        self._addOutcome("failure", test, error=error, details=details)
-
-    def _addOutcome(self, outcome, test, error=None, details=None,
-        error_permitted=True):
-        """Report a failure in test test.
-
-        Only one of error and details should be provided: conceptually there
-        are two separate methods:
-            addOutcome(self, test, error)
-            addOutcome(self, test, details)
-
-        :param outcome: A string describing the outcome - used as the
-            event name in the subunit stream.
-        :param error: Standard unittest positional argument form - an
-            exc_info tuple.
-        :param details: New Testing-in-python drafted API; a dict from string
-            to subunit.Content objects.
-        :param error_permitted: If True then one and only one of error or
-            details must be supplied. If False then error must not be supplied
-            and details is still optional.  """
-        self._stream.write(_b("%s: %s" % (outcome, test.id())))
-        if error_permitted:
-            if error is None and details is None:
-                raise ValueError
-        else:
-            if error is not None:
-                raise ValueError
-        if error is not None:
-            self._stream.write(self._start_simple)
-            # XXX: this needs to be made much stricter, along the lines of
-            # Martin[gz]'s work in testtools. Perhaps subunit can use that?
-            for line in self._exc_info_to_unicode(error, test).splitlines():
-                self._stream.write(("%s\n" % line).encode('utf8'))
-        elif details is not None:
-            self._write_details(details)
-        else:
-            self._stream.write(_b("\n"))
-        if details is not None or error is not None:
-            self._stream.write(self._end_simple)
-
-    def addSkip(self, test, reason=None, details=None):
-        """Report a skipped test."""
-        if reason is None:
-            self._addOutcome("skip", test, error=None, details=details)
-        else:
-            self._stream.write(_b("skip: %s [\n" % test.id()))
-            self._stream.write(_b("%s\n" % reason))
-            self._stream.write(self._end_simple)
-
-    def addSuccess(self, test, details=None):
-        """Report a success in a test."""
-        self._addOutcome("successful", test, details=details, error_permitted=False)
-
-    def addUnexpectedSuccess(self, test, details=None):
-        """Report an unexpected success in test test.
-
-        Details can optionally be provided: conceptually there
-        are two separate methods:
-            addError(self, test)
-            addError(self, test, details)
-
-        :param details: New Testing-in-python drafted API; a dict from string
-            to subunit.Content objects.
-        """
-        self._addOutcome("uxsuccess", test, details=details,
-            error_permitted=False)
-
-    def startTest(self, test):
-        """Mark a test as starting its test run."""
-        super(TestProtocolClient, self).startTest(test)
-        self._stream.write(_b("test: %s\n" % test.id()))
-        self._stream.flush()
-
-    def stopTest(self, test):
-        super(TestProtocolClient, self).stopTest(test)
-        self._stream.flush()
-
-    def progress(self, offset, whence):
-        """Provide indication about the progress/length of the test run.
-
-        :param offset: Information about the number of tests remaining. If
-            whence is PROGRESS_CUR, then offset increases/decreases the
-            remaining test count. If whence is PROGRESS_SET, then offset
-            specifies exactly the remaining test count.
-        :param whence: One of PROGRESS_CUR, PROGRESS_SET, PROGRESS_PUSH,
-            PROGRESS_POP.
-        """
-        if whence == PROGRESS_CUR and offset > -1:
-            prefix = self._progress_plus
-            offset = _b(str(offset))
-        elif whence == PROGRESS_PUSH:
-            prefix = self._empty_bytes
-            offset = self._progress_push
-        elif whence == PROGRESS_POP:
-            prefix = self._empty_bytes
-            offset = self._progress_pop
-        else:
-            prefix = self._empty_bytes
-            offset = _b(str(offset))
-        self._stream.write(self._progress_fmt + prefix + offset +
-            self._bytes_eol)
-
-    def time(self, a_datetime):
-        """Inform the client of the time.
-
-        ":param datetime: A datetime.datetime object.
-        """
-        time = a_datetime.astimezone(iso8601.Utc())
-        self._stream.write(_b("time: %04d-%02d-%02d %02d:%02d:%02d.%06dZ\n" % (
-            time.year, time.month, time.day, time.hour, time.minute,
-            time.second, time.microsecond)))
-
-    def _write_details(self, details):
-        """Output details to the stream.
-
-        :param details: An extended details dict for a test outcome.
-        """
-        self._stream.write(_b(" [ multipart\n"))
-        for name, content in sorted(details.items()):
-            self._stream.write(_b("Content-Type: %s/%s" %
-                (content.content_type.type, content.content_type.subtype)))
-            parameters = content.content_type.parameters
-            if parameters:
-                self._stream.write(_b(";"))
-                param_strs = []
-                for param, value in parameters.items():
-                    param_strs.append("%s=%s" % (param, value))
-                self._stream.write(_b(",".join(param_strs)))
-            self._stream.write(_b("\n%s\n" % name))
-            encoder = chunked.Encoder(self._stream)
-            list(map(encoder.write, content.iter_bytes()))
-            encoder.close()
-
-    def done(self):
-        """Obey the testtools result.done() interface."""
-
-
-def RemoteError(description=_u("")):
-    return (_StringException, _StringException(description), None)
-
-
-class RemotedTestCase(unittest.TestCase):
-    """A class to represent test cases run in child processes.
-
-    Instances of this class are used to provide the Python test API a TestCase
-    that can be printed to the screen, introspected for metadata and so on.
-    However, as they are a simply a memoisation of a test that was actually
-    run in the past by a separate process, they cannot perform any interactive
-    actions.
-    """
-
-    def __eq__ (self, other):
-        try:
-            return self.__description == other.__description
-        except AttributeError:
-            return False
-
-    def __init__(self, description):
-        """Create a psuedo test case with description description."""
-        self.__description = description
-
-    def error(self, label):
-        raise NotImplementedError("%s on RemotedTestCases is not permitted." %
-            label)
-
-    def setUp(self):
-        self.error("setUp")
-
-    def tearDown(self):
-        self.error("tearDown")
-
-    def shortDescription(self):
-        return self.__description
-
-    def id(self):
-        return "%s" % (self.__description,)
-
-    def __str__(self):
-        return "%s (%s)" % (self.__description, self._strclass())
-
-    def __repr__(self):
-        return "<%s description='%s'>" % \
-               (self._strclass(), self.__description)
-
-    def run(self, result=None):
-        if result is None: result = self.defaultTestResult()
-        result.startTest(self)
-        result.addError(self, RemoteError(_u("Cannot run RemotedTestCases.\n")))
-        result.stopTest(self)
-
-    def _strclass(self):
-        cls = self.__class__
-        return "%s.%s" % (cls.__module__, cls.__name__)
-
-
-class ExecTestCase(unittest.TestCase):
-    """A test case which runs external scripts for test fixtures."""
-
-    def __init__(self, methodName='runTest'):
-        """Create an instance of the class that will use the named test
-           method when executed. Raises a ValueError if the instance does
-           not have a method with the specified name.
-        """
-        unittest.TestCase.__init__(self, methodName)
-        testMethod = getattr(self, methodName)
-        self.script = join_dir(sys.modules[self.__class__.__module__].__file__,
-                               testMethod.__doc__)
-
-    def countTestCases(self):
-        return 1
-
-    def run(self, result=None):
-        if result is None: result = self.defaultTestResult()
-        self._run(result)
-
-    def debug(self):
-        """Run the test without collecting errors in a TestResult"""
-        self._run(testresult.TestResult())
-
-    def _run(self, result):
-        protocol = TestProtocolServer(result)
-        process = subprocess.Popen(self.script, shell=True,
-            stdout=subprocess.PIPE)
-        _make_stream_binary(process.stdout)
-        output = process.communicate()[0]
-        protocol.readFrom(BytesIO(output))
-
-
-class IsolatedTestCase(unittest.TestCase):
-    """A TestCase which executes in a forked process.
-
-    Each test gets its own process, which has a performance overhead but will
-    provide excellent isolation from global state (such as django configs,
-    zope utilities and so on).
-    """
-
-    def run(self, result=None):
-        if result is None: result = self.defaultTestResult()
-        run_isolated(unittest.TestCase, self, result)
-
-
-class IsolatedTestSuite(unittest.TestSuite):
-    """A TestSuite which runs its tests in a forked process.
-
-    This decorator that will fork() before running the tests and report the
-    results from the child process using a Subunit stream.  This is useful for
-    handling tests that mutate global state, or are testing C extensions that
-    could crash the VM.
-    """
-
-    def run(self, result=None):
-        if result is None: result = testresult.TestResult()
-        run_isolated(unittest.TestSuite, self, result)
-
-
-def run_isolated(klass, self, result):
-    """Run a test suite or case in a subprocess, using the run method on klass.
-    """
-    c2pread, c2pwrite = os.pipe()
-    # fixme - error -> result
-    # now fork
-    pid = os.fork()
-    if pid == 0:
-        # Child
-        # Close parent's pipe ends
-        os.close(c2pread)
-        # Dup fds for child
-        os.dup2(c2pwrite, 1)
-        # Close pipe fds.
-        os.close(c2pwrite)
-
-        # at this point, sys.stdin is redirected, now we want
-        # to filter it to escape ]'s.
-        ### XXX: test and write that bit.
-        stream = os.fdopen(1, 'wb')
-        result = TestProtocolClient(stream)
-        klass.run(self, result)
-        stream.flush()
-        sys.stderr.flush()
-        # exit HARD, exit NOW.
-        os._exit(0)
-    else:
-        # Parent
-        # Close child pipe ends
-        os.close(c2pwrite)
-        # hookup a protocol engine
-        protocol = TestProtocolServer(result)
-        fileobj = os.fdopen(c2pread, 'rb')
-        protocol.readFrom(fileobj)
-        os.waitpid(pid, 0)
-        # TODO return code evaluation.
-    return result
-
-
-def TAP2SubUnit(tap, subunit):
-    """Filter a TAP pipe into a subunit pipe.
-
-    :param tap: A tap pipe/stream/file object.
-    :param subunit: A pipe/stream/file object to write subunit results to.
-    :return: The exit code to exit with.
-    """
-    BEFORE_PLAN = 0
-    AFTER_PLAN = 1
-    SKIP_STREAM = 2
-    state = BEFORE_PLAN
-    plan_start = 1
-    plan_stop = 0
-    def _skipped_test(subunit, plan_start):
-        # Some tests were skipped.
-        subunit.write('test test %d\n' % plan_start)
-        subunit.write('error test %d [\n' % plan_start)
-        subunit.write('test missing from TAP output\n')
-        subunit.write(']\n')
-        return plan_start + 1
-    # Test data for the next test to emit
-    test_name = None
-    log = []
-    result = None
-    def _emit_test():
-        "write out a test"
-        if test_name is None:
-            return
-        subunit.write("test %s\n" % test_name)
-        if not log:
-            subunit.write("%s %s\n" % (result, test_name))
-        else:
-            subunit.write("%s %s [\n" % (result, test_name))
-        if log:
-            for line in log:
-                subunit.write("%s\n" % line)
-            subunit.write("]\n")
-        del log[:]
-    for line in tap:
-        if state == BEFORE_PLAN:
-            match = re.match("(\d+)\.\.(\d+)\s*(?:\#\s+(.*))?\n", line)
-            if match:
-                state = AFTER_PLAN
-                _, plan_stop, comment = match.groups()
-                plan_stop = int(plan_stop)
-                if plan_start > plan_stop and plan_stop == 0:
-                    # skipped file
-                    state = SKIP_STREAM
-                    subunit.write("test file skip\n")
-                    subunit.write("skip file skip [\n")
-                    subunit.write("%s\n" % comment)
-                    subunit.write("]\n")
-                continue
-        # not a plan line, or have seen one before
-        match = re.match("(ok|not ok)(?:\s+(\d+)?)?(?:\s+([^#]*[^#\s]+)\s*)?(?:\s+#\s+(TODO|SKIP|skip|todo)(?:\s+(.*))?)?\n", line)
-        if match:
-            # new test, emit current one.
-            _emit_test()
-            status, number, description, directive, directive_comment = match.groups()
-            if status == 'ok':
-                result = 'success'
-            else:
-                result = "failure"
-            if description is None:
-                description = ''
-            else:
-                description = ' ' + description
-            if directive is not None:
-                if directive.upper() == 'TODO':
-                    result = 'xfail'
-                elif directive.upper() == 'SKIP':
-                    result = 'skip'
-                if directive_comment is not None:
-                    log.append(directive_comment)
-            if number is not None:
-                number = int(number)
-                while plan_start < number:
-                    plan_start = _skipped_test(subunit, plan_start)
-            test_name = "test %d%s" % (plan_start, description)
-            plan_start += 1
-            continue
-        match = re.match("Bail out\!(?:\s*(.*))?\n", line)
-        if match:
-            reason, = match.groups()
-            if reason is None:
-                extra = ''
-            else:
-                extra = ' %s' % reason
-            _emit_test()
-            test_name = "Bail out!%s" % extra
-            result = "error"
-            state = SKIP_STREAM
-            continue
-        match = re.match("\#.*\n", line)
-        if match:
-            log.append(line[:-1])
-            continue
-        subunit.write(line)
-    _emit_test()
-    while plan_start <= plan_stop:
-        # record missed tests
-        plan_start = _skipped_test(subunit, plan_start)
-    return 0
-
-
-def tag_stream(original, filtered, tags):
-    """Alter tags on a stream.
-
-    :param original: The input stream.
-    :param filtered: The output stream.
-    :param tags: The tags to apply. As in a normal stream - a list of 'TAG' or
-        '-TAG' commands.
-
-        A 'TAG' command will add the tag to the output stream,
-        and override any existing '-TAG' command in that stream.
-        Specifically:
-         * A global 'tags: TAG' will be added to the start of the stream.
-         * Any tags commands with -TAG will have the -TAG removed.
-
-        A '-TAG' command will remove the TAG command from the stream.
-        Specifically:
-         * A 'tags: -TAG' command will be added to the start of the stream.
-         * Any 'tags: TAG' command will have 'TAG' removed from it.
-        Additionally, any redundant tagging commands (adding a tag globally
-        present, or removing a tag globally removed) are stripped as a
-        by-product of the filtering.
-    :return: 0
-    """
-    new_tags, gone_tags = tags_to_new_gone(tags)
-    def write_tags(new_tags, gone_tags):
-        if new_tags or gone_tags:
-            filtered.write("tags: " + ' '.join(new_tags))
-            if gone_tags:
-                for tag in gone_tags:
-                    filtered.write("-" + tag)
-            filtered.write("\n")
-    write_tags(new_tags, gone_tags)
-    # TODO: use the protocol parser and thus don't mangle test comments.
-    for line in original:
-        if line.startswith("tags:"):
-            line_tags = line[5:].split()
-            line_new, line_gone = tags_to_new_gone(line_tags)
-            line_new = line_new - gone_tags
-            line_gone = line_gone - new_tags
-            write_tags(line_new, line_gone)
-        else:
-            filtered.write(line)
-    return 0
-
-
-class ProtocolTestCase(object):
-    """Subunit wire protocol to unittest.TestCase adapter.
-
-    ProtocolTestCase honours the core of ``unittest.TestCase`` protocol -
-    calling a ProtocolTestCase or invoking the run() method will make a 'test
-    run' happen. The 'test run' will simply be a replay of the test activity
-    that has been encoded into the stream. The ``unittest.TestCase`` ``debug``
-    and ``countTestCases`` methods are not supported because there isn't a
-    sensible mapping for those methods.
-
-    # Get a stream (any object with a readline() method), in this case the
-    # stream output by the example from ``subunit.TestProtocolClient``.
-    stream = file('tests.log', 'rb')
-    # Create a parser which will read from the stream and emit
-    # activity to a unittest.TestResult when run() is called.
-    suite = subunit.ProtocolTestCase(stream)
-    # Create a result object to accept the contents of that stream.
-    result = unittest._TextTestResult(sys.stdout)
-    # 'run' the tests - process the stream and feed its contents to result.
-    suite.run(result)
-    stream.close()
-
-    :seealso: TestProtocolServer (the subunit wire protocol parser).
-    """
-
-    def __init__(self, stream, passthrough=None, forward=False):
-        """Create a ProtocolTestCase reading from stream.
-
-        :param stream: A filelike object which a subunit stream can be read
-            from.
-        :param passthrough: A stream pass non subunit input on to. If not
-            supplied, the TestProtocolServer default is used.
-        :param forward: A stream to pass subunit input on to. If not supplied
-            subunit input is not forwarded.
-        """
-        self._stream = stream
-        _make_stream_binary(stream)
-        self._passthrough = passthrough
-        self._forward = forward
-
-    def __call__(self, result=None):
-        return self.run(result)
-
-    def run(self, result=None):
-        if result is None:
-            result = self.defaultTestResult()
-        protocol = TestProtocolServer(result, self._passthrough, self._forward)
-        line = self._stream.readline()
-        while line:
-            protocol.lineReceived(line)
-            line = self._stream.readline()
-        protocol.lostConnection()
-
-
-class TestResultStats(testresult.TestResult):
-    """A pyunit TestResult interface implementation for making statistics.
-
-    :ivar total_tests: The total tests seen.
-    :ivar passed_tests: The tests that passed.
-    :ivar failed_tests: The tests that failed.
-    :ivar seen_tags: The tags seen across all tests.
-    """
-
-    def __init__(self, stream):
-        """Create a TestResultStats which outputs to stream."""
-        testresult.TestResult.__init__(self)
-        self._stream = stream
-        self.failed_tests = 0
-        self.skipped_tests = 0
-        self.seen_tags = set()
-
-    @property
-    def total_tests(self):
-        return self.testsRun
-
-    def addError(self, test, err, details=None):
-        self.failed_tests += 1
-
-    def addFailure(self, test, err, details=None):
-        self.failed_tests += 1
-
-    def addSkip(self, test, reason, details=None):
-        self.skipped_tests += 1
-
-    def formatStats(self):
-        self._stream.write("Total tests:   %5d\n" % self.total_tests)
-        self._stream.write("Passed tests:  %5d\n" % self.passed_tests)
-        self._stream.write("Failed tests:  %5d\n" % self.failed_tests)
-        self._stream.write("Skipped tests: %5d\n" % self.skipped_tests)
-        tags = sorted(self.seen_tags)
-        self._stream.write("Seen tags: %s\n" % (", ".join(tags)))
-
-    @property
-    def passed_tests(self):
-        return self.total_tests - self.failed_tests - self.skipped_tests
-
-    def tags(self, new_tags, gone_tags):
-        """Accumulate the seen tags."""
-        self.seen_tags.update(new_tags)
-
-    def wasSuccessful(self):
-        """Tells whether or not this result was a success"""
-        return self.failed_tests == 0
-
-
-def get_default_formatter():
-    """Obtain the default formatter to write to.
-
-    :return: A file-like object.
-    """
-    formatter = os.getenv("SUBUNIT_FORMATTER")
-    if formatter:
-        return os.popen(formatter, "w")
-    else:
-        stream = sys.stdout
-        if sys.version_info > (3, 0):
-            stream = stream.buffer
-        return stream
-
-
-if sys.version_info > (3, 0):
-    from io import UnsupportedOperation as _NoFilenoError
-else:
-    _NoFilenoError = AttributeError
-
-def read_test_list(path):
-    """Read a list of test ids from a file on disk.
-
-    :param path: Path to the file
-    :return: Sequence of test ids
-    """
-    f = open(path, 'rb')
-    try:
-        return [l.rstrip("\n") for l in f.readlines()]
-    finally:
-        f.close()
-
-
-def _make_stream_binary(stream):
-    """Ensure that a stream will be binary safe. See _make_binary_on_windows."""
-    try:
-        fileno = stream.fileno()
-    except _NoFilenoError:
-        return
-    _make_binary_on_windows(fileno)
-
-def _make_binary_on_windows(fileno):
-    """Win32 mangles \r\n to \n and that breaks streams. See bug lp:505078."""
-    if sys.platform == "win32":
-        import msvcrt
-        msvcrt.setmode(fileno, os.O_BINARY)

=== removed file 'python-for-subunit2junitxml/subunit/chunked.py'
--- python-for-subunit2junitxml/subunit/chunked.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/chunked.py	1970-01-01 00:00:00 +0000
@@ -1,185 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#  Copyright (C) 2011  Martin Pool <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Encoder/decoder for http style chunked encoding."""
-
-from testtools.compat import _b
-
-empty = _b('')
-
-class Decoder(object):
-    """Decode chunked content to a byte stream."""
-
-    def __init__(self, output, strict=True):
-        """Create a decoder decoding to output.
-
-        :param output: A file-like object. Bytes written to the Decoder are
-            decoded to strip off the chunking and written to the output.
-            Up to a full write worth of data or a single control line may be
-            buffered (whichever is larger). The close method should be called
-            when no more data is available, to detect short streams; the
-            write method will return none-None when the end of a stream is
-            detected. The output object must accept bytes objects.
-
-        :param strict: If True (the default), the decoder will not knowingly
-            accept input that is not conformant to the HTTP specification.
-            (This does not imply that it will catch every nonconformance.)
-            If False, it will accept incorrect input that is still
-            unambiguous.
-        """
-        self.output = output
-        self.buffered_bytes = []
-        self.state = self._read_length
-        self.body_length = 0
-        self.strict = strict
-        self._match_chars = _b("0123456789abcdefABCDEF\r\n")
-        self._slash_n = _b('\n')
-        self._slash_r = _b('\r')
-        self._slash_rn = _b('\r\n')
-        self._slash_nr = _b('\n\r')
-
-    def close(self):
-        """Close the decoder.
-
-        :raises ValueError: If the stream is incomplete ValueError is raised.
-        """
-        if self.state != self._finished:
-            raise ValueError("incomplete stream")
-
-    def _finished(self):
-        """Finished reading, return any remaining bytes."""
-        if self.buffered_bytes:
-            buffered_bytes = self.buffered_bytes
-            self.buffered_bytes = []
-            return empty.join(buffered_bytes)
-        else:
-            raise ValueError("stream is finished")
-
-    def _read_body(self):
-        """Pass body bytes to the output."""
-        while self.body_length and self.buffered_bytes:
-            if self.body_length >= len(self.buffered_bytes[0]):
-                self.output.write(self.buffered_bytes[0])
-                self.body_length -= len(self.buffered_bytes[0])
-                del self.buffered_bytes[0]
-                # No more data available.
-                if not self.body_length:
-                    self.state = self._read_length
-            else:
-                self.output.write(self.buffered_bytes[0][:self.body_length])
-                self.buffered_bytes[0] = \
-                    self.buffered_bytes[0][self.body_length:]
-                self.body_length = 0
-                self.state = self._read_length
-                return self.state()
-
-    def _read_length(self):
-        """Try to decode a length from the bytes."""
-        count_chars = []
-        for bytes in self.buffered_bytes:
-            for pos in range(len(bytes)):
-                byte = bytes[pos:pos+1]
-                if byte not in self._match_chars:
-                    break
-                count_chars.append(byte)
-                if byte == self._slash_n:
-                    break
-        if not count_chars:
-            return
-        if count_chars[-1] != self._slash_n:
-            return
-        count_str = empty.join(count_chars)
-        if self.strict:
-            if count_str[-2:] != self._slash_rn:
-                raise ValueError("chunk header invalid: %r" % count_str)
-            if self._slash_r in count_str[:-2]:
-                raise ValueError("too many CRs in chunk header %r" % count_str)
-        self.body_length = int(count_str.rstrip(self._slash_nr), 16)
-        excess_bytes = len(count_str)
-        while excess_bytes:
-            if excess_bytes >= len(self.buffered_bytes[0]):
-                excess_bytes -= len(self.buffered_bytes[0])
-                del self.buffered_bytes[0]
-            else:
-                self.buffered_bytes[0] = self.buffered_bytes[0][excess_bytes:]
-                excess_bytes = 0
-        if not self.body_length:
-            self.state = self._finished
-            if not self.buffered_bytes:
-                # May not call into self._finished with no buffered data.
-                return empty
-        else:
-            self.state = self._read_body
-        return self.state()
-
-    def write(self, bytes):
-        """Decode bytes to the output stream.
-
-        :raises ValueError: If the stream has already seen the end of file
-            marker.
-        :returns: None, or the excess bytes beyond the end of file marker.
-        """
-        if bytes:
-            self.buffered_bytes.append(bytes)
-        return self.state()
-
-
-class Encoder(object):
-    """Encode content to a stream using HTTP Chunked coding."""
-
-    def __init__(self, output):
-        """Create an encoder encoding to output.
-
-        :param output: A file-like object. Bytes written to the Encoder
-            will be encoded using HTTP chunking. Small writes may be buffered
-            and the ``close`` method must be called to finish the stream.
-        """
-        self.output = output
-        self.buffered_bytes = []
-        self.buffer_size = 0
-
-    def flush(self, extra_len=0):
-        """Flush the encoder to the output stream.
-
-        :param extra_len: Increase the size of the chunk by this many bytes
-            to allow for a subsequent write.
-        """
-        if not self.buffer_size and not extra_len:
-            return
-        buffered_bytes = self.buffered_bytes
-        buffer_size = self.buffer_size
-        self.buffered_bytes = []
-        self.buffer_size = 0
-        self.output.write(_b("%X\r\n" % (buffer_size + extra_len)))
-        if buffer_size:
-            self.output.write(empty.join(buffered_bytes))
-        return True
-
-    def write(self, bytes):
-        """Encode bytes to the output stream."""
-        bytes_len = len(bytes)
-        if self.buffer_size + bytes_len >= 65536:
-            self.flush(bytes_len)
-            self.output.write(bytes)
-        else:
-            self.buffered_bytes.append(bytes)
-            self.buffer_size += bytes_len
-
-    def close(self):
-        """Finish the stream. This does not close the output stream."""
-        self.flush()
-        self.output.write(_b("0\r\n"))

=== removed file 'python-for-subunit2junitxml/subunit/details.py'
--- python-for-subunit2junitxml/subunit/details.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/details.py	1970-01-01 00:00:00 +0000
@@ -1,119 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Handlers for outcome details."""
-
-from testtools import content, content_type
-from testtools.compat import _b, BytesIO
-
-from subunit import chunked
-
-end_marker = _b("]\n")
-quoted_marker = _b(" ]")
-empty = _b('')
-
-
-class DetailsParser(object):
-    """Base class/API reference for details parsing."""
-
-
-class SimpleDetailsParser(DetailsParser):
-    """Parser for single-part [] delimited details."""
-
-    def __init__(self, state):
-        self._message = _b("")
-        self._state = state
-
-    def lineReceived(self, line):
-        if line == end_marker:
-            self._state.endDetails()
-            return
-        if line[0:2] == quoted_marker:
-            # quoted ] start
-            self._message += line[1:]
-        else:
-            self._message += line
-
-    def get_details(self, style=None):
-        result = {}
-        if not style:
-            # We know that subunit/testtools serialise [] formatted
-            # tracebacks as utf8, but perhaps we need a ReplacingContent
-            # or something like that.
-            result['traceback'] = content.Content(
-                content_type.ContentType("text", "x-traceback",
-                {"charset": "utf8"}),
-                lambda:[self._message])
-        else:
-            if style == 'skip':
-                name = 'reason'
-            else:
-                name = 'message'
-            result[name] = content.Content(
-                content_type.ContentType("text", "plain"),
-                lambda:[self._message])
-        return result
-
-    def get_message(self):
-        return self._message
-
-
-class MultipartDetailsParser(DetailsParser):
-    """Parser for multi-part [] surrounded MIME typed chunked details."""
-
-    def __init__(self, state):
-        self._state = state
-        self._details = {}
-        self._parse_state = self._look_for_content
-
-    def _look_for_content(self, line):
-        if line == end_marker:
-            self._state.endDetails()
-            return
-        # TODO error handling
-        field, value = line[:-1].decode('utf8').split(' ', 1)
-        try:
-            main, sub = value.split('/')
-        except ValueError:
-            raise ValueError("Invalid MIME type %r" % value)
-        self._content_type = content_type.ContentType(main, sub)
-        self._parse_state = self._get_name
-
-    def _get_name(self, line):
-        self._name = line[:-1].decode('utf8')
-        self._body = BytesIO()
-        self._chunk_parser = chunked.Decoder(self._body)
-        self._parse_state = self._feed_chunks
-
-    def _feed_chunks(self, line):
-        residue = self._chunk_parser.write(line)
-        if residue is not None:
-            # Line based use always ends on no residue.
-            assert residue == empty, 'residue: %r' % (residue,)
-            body = self._body
-            self._details[self._name] = content.Content(
-                self._content_type, lambda:[body.getvalue()])
-            self._chunk_parser.close()
-            self._parse_state = self._look_for_content
-
-    def get_details(self, for_skip=False):
-        return self._details
-
-    def get_message(self):
-        return None
-
-    def lineReceived(self, line):
-        self._parse_state(line)

=== removed file 'python-for-subunit2junitxml/subunit/iso8601.py'
--- python-for-subunit2junitxml/subunit/iso8601.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/iso8601.py	1970-01-01 00:00:00 +0000
@@ -1,133 +0,0 @@
-# Copyright (c) 2007 Michael Twomey
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-"""ISO 8601 date time string parsing
-
-Basic usage:
->>> import iso8601
->>> iso8601.parse_date("2007-01-25T12:00:00Z")
-datetime.datetime(2007, 1, 25, 12, 0, tzinfo=<iso8601.iso8601.Utc ...>)
->>>
-
-"""
-
-from datetime import datetime, timedelta, tzinfo
-import re
-import sys
-
-__all__ = ["parse_date", "ParseError"]
-
-# Adapted from http://delete.me.uk/2005/03/iso8601.html
-ISO8601_REGEX_PATTERN = (r"(?P<year>[0-9]{4})(-(?P<month>[0-9]{1,2})(-(?P<day>[0-9]{1,2})"
-    r"((?P<separator>.)(?P<hour>[0-9]{2}):(?P<minute>[0-9]{2})(:(?P<second>[0-9]{2})(\.(?P<fraction>[0-9]+))?)?"
-    r"(?P<timezone>Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?"
-)
-TIMEZONE_REGEX_PATTERN = "(?P<prefix>[+-])(?P<hours>[0-9]{2}).(?P<minutes>[0-9]{2})"
-ISO8601_REGEX = re.compile(ISO8601_REGEX_PATTERN.encode('utf8'))
-TIMEZONE_REGEX = re.compile(TIMEZONE_REGEX_PATTERN.encode('utf8'))
-
-zulu = "Z".encode('latin-1')
-minus = "-".encode('latin-1')
-
-if sys.version_info < (3, 0):
-    bytes = str
-
-
-class ParseError(Exception):
-    """Raised when there is a problem parsing a date string"""
-
-# Yoinked from python docs
-ZERO = timedelta(0)
-class Utc(tzinfo):
-    """UTC
-    
-    """
-    def utcoffset(self, dt):
-        return ZERO
-
-    def tzname(self, dt):
-        return "UTC"
-
-    def dst(self, dt):
-        return ZERO
-UTC = Utc()
-
-class FixedOffset(tzinfo):
-    """Fixed offset in hours and minutes from UTC
-    
-    """
-    def __init__(self, offset_hours, offset_minutes, name):
-        self.__offset = timedelta(hours=offset_hours, minutes=offset_minutes)
-        self.__name = name
-
-    def utcoffset(self, dt):
-        return self.__offset
-
-    def tzname(self, dt):
-        return self.__name
-
-    def dst(self, dt):
-        return ZERO
-    
-    def __repr__(self):
-        return "<FixedOffset %r>" % self.__name
-
-def parse_timezone(tzstring, default_timezone=UTC):
-    """Parses ISO 8601 time zone specs into tzinfo offsets
-    
-    """
-    if tzstring == zulu:
-        return default_timezone
-    # This isn't strictly correct, but it's common to encounter dates without
-    # timezones so I'll assume the default (which defaults to UTC).
-    # Addresses issue 4.
-    if tzstring is None:
-        return default_timezone
-    m = TIMEZONE_REGEX.match(tzstring)
-    prefix, hours, minutes = m.groups()
-    hours, minutes = int(hours), int(minutes)
-    if prefix == minus:
-        hours = -hours
-        minutes = -minutes
-    return FixedOffset(hours, minutes, tzstring)
-
-def parse_date(datestring, default_timezone=UTC):
-    """Parses ISO 8601 dates into datetime objects
-    
-    The timezone is parsed from the date string. However it is quite common to
-    have dates without a timezone (not strictly correct). In this case the
-    default timezone specified in default_timezone is used. This is UTC by
-    default.
-    """
-    if not isinstance(datestring, bytes):
-        raise ParseError("Expecting bytes %r" % datestring)
-    m = ISO8601_REGEX.match(datestring)
-    if not m:
-        raise ParseError("Unable to parse date string %r" % datestring)
-    groups = m.groupdict()
-    tz = parse_timezone(groups["timezone"], default_timezone=default_timezone)
-    if groups["fraction"] is None:
-        groups["fraction"] = 0
-    else:
-        groups["fraction"] = int(float("0.%s" % groups["fraction"]) * 1e6)
-    return datetime(int(groups["year"]), int(groups["month"]), int(groups["day"]),
-        int(groups["hour"]), int(groups["minute"]), int(groups["second"]),
-        int(groups["fraction"]), tz)

=== removed file 'python-for-subunit2junitxml/subunit/progress_model.py'
--- python-for-subunit2junitxml/subunit/progress_model.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/progress_model.py	1970-01-01 00:00:00 +0000
@@ -1,106 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Support for dealing with progress state."""
-
-class ProgressModel(object):
-    """A model of progress indicators as subunit defines it.
-    
-    Instances of this class represent a single logical operation that is
-    progressing. The operation may have many steps, and some of those steps may
-    supply their own progress information. ProgressModel uses a nested concept
-    where the overall state can be pushed, creating new starting state, and
-    later pushed to return to the prior state. Many user interfaces will want
-    to display an overall summary though, and accordingly the pos() and width()
-    methods return overall summary information rather than information on the
-    current subtask.
-
-    The default state is 0/0 - indicating that the overall progress is unknown.
-    Anytime the denominator of pos/width is 0, rendering of a ProgressModel
-    should should take this into consideration.
-
-    :ivar: _tasks. This private attribute stores the subtasks. Each is a tuple:
-        pos, width, overall_numerator, overall_denominator. The overall fields
-        store the calculated overall numerator and denominator for the state
-        that was pushed.
-    """
-
-    def __init__(self):
-        """Create a ProgressModel.
-        
-        The new model has no progress data at all - it will claim a summary
-        width of zero and position of 0.
-        """
-        self._tasks = []
-        self.push()
-
-    def adjust_width(self, offset):
-        """Adjust the with of the current subtask."""
-        self._tasks[-1][1] += offset
-
-    def advance(self):
-        """Advance the current subtask."""
-        self._tasks[-1][0] += 1
-
-    def pop(self):
-        """Pop a subtask off the ProgressModel.
-
-        See push for a description of how push and pop work.
-        """
-        self._tasks.pop()
-
-    def pos(self):
-        """Return how far through the operation has progressed."""
-        if not self._tasks:
-            return 0
-        task = self._tasks[-1]
-        if len(self._tasks) > 1:
-            # scale up the overall pos by the current task or preserve it if
-            # no current width is known.
-            offset = task[2] * (task[1] or 1)
-        else:
-            offset = 0
-        return offset + task[0]
-
-    def push(self):
-        """Push a new subtask.
-
-        After pushing a new subtask, the overall progress hasn't changed. Calls
-        to adjust_width, advance, set_width will only after the progress within
-        the range that calling 'advance' would have before - the subtask
-        represents progressing one step in the earlier task.
-
-        Call pop() to restore the progress model to the state before push was
-        called.
-        """
-        self._tasks.append([0, 0, self.pos(), self.width()])
-
-    def set_width(self, width):
-        """Set the width of the current subtask."""
-        self._tasks[-1][1] = width
-
-    def width(self):
-        """Return the total width of the operation."""
-        if not self._tasks:
-            return 0
-        task = self._tasks[-1]
-        if len(self._tasks) > 1:
-            # scale up the overall width by the current task or preserve it if
-            # no current width is known.
-            return task[3] * (task[1] or 1)
-        else:
-            return task[1]
-

=== removed file 'python-for-subunit2junitxml/subunit/run.py'
--- python-for-subunit2junitxml/subunit/run.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/run.py	1970-01-01 00:00:00 +0000
@@ -1,73 +0,0 @@
-#!/usr/bin/python
-#
-# Simple subunit testrunner for python
-# Copyright (C) Jelmer Vernooij <[e-mail]> 2007
-#   
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Run a unittest testcase reporting results as Subunit.
-
-  $ python -m subunit.run mylib.tests.test_suite
-"""
-
-import sys
-
-from subunit import TestProtocolClient, get_default_formatter
-from testtools.run import (
-    BUFFEROUTPUT,
-    CATCHBREAK,
-    FAILFAST,
-    TestProgram,
-    USAGE_AS_MAIN,
-    )
-
-
-class SubunitTestRunner(object):
-    def __init__(self, stream=sys.stdout):
-        self.stream = stream
-
-    def run(self, test):
-        "Run the given test case or test suite."
-        result = TestProtocolClient(self.stream)
-        test(result)
-        return result
-
-
-class SubunitTestProgram(TestProgram):
-
-    USAGE = USAGE_AS_MAIN
-
-    def usageExit(self, msg=None):
-        if msg:
-            print msg
-        usage = {'progName': self.progName, 'catchbreak': '', 'failfast': '',
-                 'buffer': ''}
-        if self.failfast != False:
-            usage['failfast'] = FAILFAST
-        if self.catchbreak != False:
-            usage['catchbreak'] = CATCHBREAK
-        if self.buffer != False:
-            usage['buffer'] = BUFFEROUTPUT
-        usage_text = self.USAGE % usage
-        usage_lines = usage_text.split('\n')
-        usage_lines.insert(2, "Run a test suite with a subunit reporter.")
-        usage_lines.insert(3, "")
-        print('\n'.join(usage_lines))
-        sys.exit(2)
-
-
-if __name__ == '__main__':
-    stream = get_default_formatter()
-    runner = SubunitTestRunner(stream)
-    SubunitTestProgram(module=None, argv=sys.argv, testRunner=runner,
-        stdout=sys.stdout)

=== removed file 'python-for-subunit2junitxml/subunit/test_results.py'
--- python-for-subunit2junitxml/subunit/test_results.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/test_results.py	1970-01-01 00:00:00 +0000
@@ -1,492 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""TestResult helper classes used to by subunit."""
-
-import datetime
-
-import testtools
-
-from subunit import iso8601
-
-
-# NOT a TestResult, because we are implementing the interface, not inheriting
-# it.
-class TestResultDecorator(object):
-    """General pass-through decorator.
-
-    This provides a base that other TestResults can inherit from to
-    gain basic forwarding functionality. It also takes care of
-    handling the case where the target doesn't support newer methods
-    or features by degrading them.
-    """
-
-    def __init__(self, decorated):
-        """Create a TestResultDecorator forwarding to decorated."""
-        # Make every decorator degrade gracefully.
-        self.decorated = testtools.ExtendedToOriginalDecorator(decorated)
-
-    def startTest(self, test):
-        return self.decorated.startTest(test)
-
-    def startTestRun(self):
-        return self.decorated.startTestRun()
-
-    def stopTest(self, test):
-        return self.decorated.stopTest(test)
-
-    def stopTestRun(self):
-        return self.decorated.stopTestRun()
-
-    def addError(self, test, err=None, details=None):
-        return self.decorated.addError(test, err, details=details)
-
-    def addFailure(self, test, err=None, details=None):
-        return self.decorated.addFailure(test, err, details=details)
-
-    def addSuccess(self, test, details=None):
-        return self.decorated.addSuccess(test, details=details)
-
-    def addSkip(self, test, reason=None, details=None):
-        return self.decorated.addSkip(test, reason, details=details)
-
-    def addExpectedFailure(self, test, err=None, details=None):
-        return self.decorated.addExpectedFailure(test, err, details=details)
-
-    def addUnexpectedSuccess(self, test, details=None):
-        return self.decorated.addUnexpectedSuccess(test, details=details)
-
-    def progress(self, offset, whence):
-        return self.decorated.progress(offset, whence)
-
-    def wasSuccessful(self):
-        return self.decorated.wasSuccessful()
-
-    @property
-    def shouldStop(self):
-        return self.decorated.shouldStop
-
-    def stop(self):
-        return self.decorated.stop()
-
-    @property
-    def testsRun(self):
-        return self.decorated.testsRun
-
-    def tags(self, new_tags, gone_tags):
-        return self.decorated.tags(new_tags, gone_tags)
-
-    def time(self, a_datetime):
-        return self.decorated.time(a_datetime)
-
-
-class HookedTestResultDecorator(TestResultDecorator):
-    """A TestResult which calls a hook on every event."""
-
-    def __init__(self, decorated):
-        self.super = super(HookedTestResultDecorator, self)
-        self.super.__init__(decorated)
-
-    def startTest(self, test):
-        self._before_event()
-        return self.super.startTest(test)
-
-    def startTestRun(self):
-        self._before_event()
-        return self.super.startTestRun()
-
-    def stopTest(self, test):
-        self._before_event()
-        return self.super.stopTest(test)
-
-    def stopTestRun(self):
-        self._before_event()
-        return self.super.stopTestRun()
-
-    def addError(self, test, err=None, details=None):
-        self._before_event()
-        return self.super.addError(test, err, details=details)
-
-    def addFailure(self, test, err=None, details=None):
-        self._before_event()
-        return self.super.addFailure(test, err, details=details)
-
-    def addSuccess(self, test, details=None):
-        self._before_event()
-        return self.super.addSuccess(test, details=details)
-
-    def addSkip(self, test, reason=None, details=None):
-        self._before_event()
-        return self.super.addSkip(test, reason, details=details)
-
-    def addExpectedFailure(self, test, err=None, details=None):
-        self._before_event()
-        return self.super.addExpectedFailure(test, err, details=details)
-
-    def addUnexpectedSuccess(self, test, details=None):
-        self._before_event()
-        return self.super.addUnexpectedSuccess(test, details=details)
-
-    def progress(self, offset, whence):
-        self._before_event()
-        return self.super.progress(offset, whence)
-
-    def wasSuccessful(self):
-        self._before_event()
-        return self.super.wasSuccessful()
-
-    @property
-    def shouldStop(self):
-        self._before_event()
-        return self.super.shouldStop
-
-    def stop(self):
-        self._before_event()
-        return self.super.stop()
-
-    def time(self, a_datetime):
-        self._before_event()
-        return self.super.time(a_datetime)
-
-
-class AutoTimingTestResultDecorator(HookedTestResultDecorator):
-    """Decorate a TestResult to add time events to a test run.
-
-    By default this will cause a time event before every test event,
-    but if explicit time data is being provided by the test run, then
-    this decorator will turn itself off to prevent causing confusion.
-    """
-
-    def __init__(self, decorated):
-        self._time = None
-        super(AutoTimingTestResultDecorator, self).__init__(decorated)
-
-    def _before_event(self):
-        time = self._time
-        if time is not None:
-            return
-        time = datetime.datetime.utcnow().replace(tzinfo=iso8601.Utc())
-        self.decorated.time(time)
-
-    def progress(self, offset, whence):
-        return self.decorated.progress(offset, whence)
-
-    @property
-    def shouldStop(self):
-        return self.decorated.shouldStop
-
-    def time(self, a_datetime):
-        """Provide a timestamp for the current test activity.
-
-        :param a_datetime: If None, automatically add timestamps before every
-            event (this is the default behaviour if time() is not called at
-            all).  If not None, pass the provided time onto the decorated
-            result object and disable automatic timestamps.
-        """
-        self._time = a_datetime
-        return self.decorated.time(a_datetime)
-
-
-class TagCollapsingDecorator(TestResultDecorator):
-    """Collapses many 'tags' calls into one where possible."""
-
-    def __init__(self, result):
-        super(TagCollapsingDecorator, self).__init__(result)
-        # The (new, gone) tags for the current test.
-        self._current_test_tags = None
-
-    def startTest(self, test):
-        """Start a test.
-
-        Not directly passed to the client, but used for handling of tags
-        correctly.
-        """
-        self.decorated.startTest(test)
-        self._current_test_tags = set(), set()
-
-    def stopTest(self, test):
-        """Stop a test.
-
-        Not directly passed to the client, but used for handling of tags
-        correctly.
-        """
-        # Tags to output for this test.
-        if self._current_test_tags[0] or self._current_test_tags[1]:
-            self.decorated.tags(*self._current_test_tags)
-        self.decorated.stopTest(test)
-        self._current_test_tags = None
-
-    def tags(self, new_tags, gone_tags):
-        """Handle tag instructions.
-
-        Adds and removes tags as appropriate. If a test is currently running,
-        tags are not affected for subsequent tests.
-
-        :param new_tags: Tags to add,
-        :param gone_tags: Tags to remove.
-        """
-        if self._current_test_tags is not None:
-            # gather the tags until the test stops.
-            self._current_test_tags[0].update(new_tags)
-            self._current_test_tags[0].difference_update(gone_tags)
-            self._current_test_tags[1].update(gone_tags)
-            self._current_test_tags[1].difference_update(new_tags)
-        else:
-            return self.decorated.tags(new_tags, gone_tags)
-
-
-class TimeCollapsingDecorator(HookedTestResultDecorator):
-    """Only pass on the first and last of a consecutive sequence of times."""
-
-    def __init__(self, decorated):
-        super(TimeCollapsingDecorator, self).__init__(decorated)
-        self._last_received_time = None
-        self._last_sent_time = None
-
-    def _before_event(self):
-        if self._last_received_time is None:
-            return
-        if self._last_received_time != self._last_sent_time:
-            self.decorated.time(self._last_received_time)
-            self._last_sent_time = self._last_received_time
-        self._last_received_time = None
-
-    def time(self, a_time):
-        # Don't upcall, because we don't want to call _before_event, it's only
-        # for non-time events.
-        if self._last_received_time is None:
-            self.decorated.time(a_time)
-            self._last_sent_time = a_time
-        self._last_received_time = a_time
-
-
-def all_true(bools):
-    """Return True if all of 'bools' are True. False otherwise."""
-    for b in bools:
-        if not b:
-            return False
-    return True
-
-
-class TestResultFilter(TestResultDecorator):
-    """A pyunit TestResult interface implementation which filters tests.
-
-    Tests that pass the filter are handed on to another TestResult instance
-    for further processing/reporting. To obtain the filtered results,
-    the other instance must be interrogated.
-
-    :ivar result: The result that tests are passed to after filtering.
-    :ivar filter_predicate: The callback run to decide whether to pass
-        a result.
-    """
-
-    def __init__(self, result, filter_error=False, filter_failure=False,
-        filter_success=True, filter_skip=False,
-        filter_predicate=None, fixup_expected_failures=None):
-        """Create a FilterResult object filtering to result.
-
-        :param filter_error: Filter out errors.
-        :param filter_failure: Filter out failures.
-        :param filter_success: Filter out successful tests.
-        :param filter_skip: Filter out skipped tests.
-        :param filter_predicate: A callable taking (test, outcome, err,
-            details) and returning True if the result should be passed
-            through.  err and details may be none if no error or extra
-            metadata is available. outcome is the name of the outcome such
-            as 'success' or 'failure'.
-        :param fixup_expected_failures: Set of test ids to consider known
-            failing.
-        """
-        super(TestResultFilter, self).__init__(result)
-        self.decorated = TimeCollapsingDecorator(
-            TagCollapsingDecorator(self.decorated))
-        predicates = []
-        if filter_error:
-            predicates.append(lambda t, outcome, e, d: outcome != 'error')
-        if filter_failure:
-            predicates.append(lambda t, outcome, e, d: outcome != 'failure')
-        if filter_success:
-            predicates.append(lambda t, outcome, e, d: outcome != 'success')
-        if filter_skip:
-            predicates.append(lambda t, outcome, e, d: outcome != 'skip')
-        if filter_predicate is not None:
-            predicates.append(filter_predicate)
-        self.filter_predicate = (
-            lambda test, outcome, err, details:
-                all_true(p(test, outcome, err, details) for p in predicates))
-        # The current test (for filtering tags)
-        self._current_test = None
-        # Has the current test been filtered (for outputting test tags)
-        self._current_test_filtered = None
-        # Calls to this result that we don't know whether to forward on yet.
-        self._buffered_calls = []
-        if fixup_expected_failures is None:
-            self._fixup_expected_failures = frozenset()
-        else:
-            self._fixup_expected_failures = fixup_expected_failures
-
-    def addError(self, test, err=None, details=None):
-        if (self.filter_predicate(test, 'error', err, details)):
-            if self._failure_expected(test):
-                self._buffered_calls.append(
-                    ('addExpectedFailure', [test, err], {'details': details}))
-            else:
-                self._buffered_calls.append(
-                    ('addError', [test, err], {'details': details}))
-        else:
-            self._filtered()
-
-    def addFailure(self, test, err=None, details=None):
-        if (self.filter_predicate(test, 'failure', err, details)):
-            if self._failure_expected(test):
-                self._buffered_calls.append(
-                    ('addExpectedFailure', [test, err], {'details': details}))
-            else:
-                self._buffered_calls.append(
-                    ('addFailure', [test, err], {'details': details}))
-        else:
-            self._filtered()
-
-    def addSkip(self, test, reason=None, details=None):
-        if (self.filter_predicate(test, 'skip', reason, details)):
-            self._buffered_calls.append(
-                ('addSkip', [test, reason], {'details': details}))
-        else:
-            self._filtered()
-
-    def addSuccess(self, test, details=None):
-        if (self.filter_predicate(test, 'success', None, details)):
-            if self._failure_expected(test):
-                self._buffered_calls.append(
-                    ('addUnexpectedSuccess', [test], {'details': details}))
-            else:
-                self._buffered_calls.append(
-                    ('addSuccess', [test], {'details': details}))
-        else:
-            self._filtered()
-
-    def addExpectedFailure(self, test, err=None, details=None):
-        if self.filter_predicate(test, 'expectedfailure', err, details):
-            self._buffered_calls.append(
-                ('addExpectedFailure', [test, err], {'details': details}))
-        else:
-            self._filtered()
-
-    def addUnexpectedSuccess(self, test, details=None):
-        self._buffered_calls.append(
-            ('addUnexpectedSuccess', [test], {'details': details}))
-
-    def _filtered(self):
-        self._current_test_filtered = True
-
-    def _failure_expected(self, test):
-        return (test.id() in self._fixup_expected_failures)
-
-    def startTest(self, test):
-        """Start a test.
-
-        Not directly passed to the client, but used for handling of tags
-        correctly.
-        """
-        self._current_test = test
-        self._current_test_filtered = False
-        self._buffered_calls.append(('startTest', [test], {}))
-
-    def stopTest(self, test):
-        """Stop a test.
-
-        Not directly passed to the client, but used for handling of tags
-        correctly.
-        """
-        if not self._current_test_filtered:
-            # Tags to output for this test.
-            for method, args, kwargs in self._buffered_calls:
-                getattr(self.decorated, method)(*args, **kwargs)
-            self.decorated.stopTest(test)
-        self._current_test = None
-        self._current_test_filtered = None
-        self._buffered_calls = []
-
-    def time(self, a_time):
-        if self._current_test is not None:
-            self._buffered_calls.append(('time', [a_time], {}))
-        else:
-            return self.decorated.time(a_time)
-
-    def id_to_orig_id(self, id):
-        if id.startswith("subunit.RemotedTestCase."):
-            return id[len("subunit.RemotedTestCase."):]
-        return id
-
-
-class TestIdPrintingResult(testtools.TestResult):
-
-    def __init__(self, stream, show_times=False):
-        """Create a FilterResult object outputting to stream."""
-        super(TestIdPrintingResult, self).__init__()
-        self._stream = stream
-        self.failed_tests = 0
-        self.__time = None
-        self.show_times = show_times
-        self._test = None
-        self._test_duration = 0
-
-    def addError(self, test, err):
-        self.failed_tests += 1
-        self._test = test
-
-    def addFailure(self, test, err):
-        self.failed_tests += 1
-        self._test = test
-
-    def addSuccess(self, test):
-        self._test = test
-
-    def addSkip(self, test, reason=None, details=None):
-        self._test = test
-
-    def addUnexpectedSuccess(self, test, details=None):
-        self.failed_tests += 1
-        self._test = test
-
-    def addExpectedFailure(self, test, err=None, details=None):
-        self._test = test
-
-    def reportTest(self, test, duration):
-        if self.show_times:
-            seconds = duration.seconds
-            seconds += duration.days * 3600 * 24
-            seconds += duration.microseconds / 1000000.0
-            self._stream.write(test.id() + ' %0.3f\n' % seconds)
-        else:
-            self._stream.write(test.id() + '\n')
-
-    def startTest(self, test):
-        self._start_time = self._time()
-
-    def stopTest(self, test):
-        test_duration = self._time() - self._start_time
-        self.reportTest(self._test, test_duration)
-
-    def time(self, time):
-        self.__time = time
-
-    def _time(self):
-        return self.__time
-
-    def wasSuccessful(self):
-        "Tells whether or not this result was a success"
-        return self.failed_tests == 0

=== removed directory 'python-for-subunit2junitxml/subunit/tests'
=== removed file 'python-for-subunit2junitxml/subunit/tests/TestUtil.py'
--- python-for-subunit2junitxml/subunit/tests/TestUtil.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/TestUtil.py	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-# Copyright (c) 2004 Canonical Limited
-#       Author: Robert Collins <[e-mail]>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-#
-
-import sys
-import logging
-import unittest
-
-
-class LogCollector(logging.Handler):
-    def __init__(self):
-        logging.Handler.__init__(self)
-        self.records=[]
-    def emit(self, record):
-        self.records.append(record.getMessage())
-
-
-def makeCollectingLogger():
-    """I make a logger instance that collects its logs for programmatic analysis
-    -> (logger, collector)"""
-    logger=logging.Logger("collector")
-    handler=LogCollector()
-    handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
-    logger.addHandler(handler)
-    return logger, handler
-
-
-def visitTests(suite, visitor):
-    """A foreign method for visiting the tests in a test suite."""
-    for test in suite._tests:
-        #Abusing types to avoid monkey patching unittest.TestCase.
-        # Maybe that would be better?
-        try:
-            test.visit(visitor)
-        except AttributeError:
-            if isinstance(test, unittest.TestCase):
-                visitor.visitCase(test)
-            elif isinstance(test, unittest.TestSuite):
-                visitor.visitSuite(test)
-                visitTests(test, visitor)
-            else:
-                print ("unvisitable non-unittest.TestCase element %r (%r)" % (test, test.__class__))
-
-
-class TestSuite(unittest.TestSuite):
-    """I am an extended TestSuite with a visitor interface.
-    This is primarily to allow filtering of tests - and suites or
-    more in the future. An iterator of just tests wouldn't scale..."""
-
-    def visit(self, visitor):
-        """visit the composite. Visiting is depth-first.
-        current callbacks are visitSuite and visitCase."""
-        visitor.visitSuite(self)
-        visitTests(self, visitor)
-
-
-class TestLoader(unittest.TestLoader):
-    """Custome TestLoader to set the right TestSuite class."""
-    suiteClass = TestSuite
-
-class TestVisitor(object):
-    """A visitor for Tests"""
-    def visitSuite(self, aTestSuite):
-        pass
-    def visitCase(self, aTestCase):
-        pass

=== removed file 'python-for-subunit2junitxml/subunit/tests/__init__.py'
--- python-for-subunit2junitxml/subunit/tests/__init__.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-from subunit.tests import (
-    TestUtil,
-    test_chunked,
-    test_details,
-    test_progress_model,
-    test_subunit_filter,
-    test_subunit_stats,
-    test_subunit_tags,
-    test_tap2subunit,
-    test_test_protocol,
-    test_test_results,
-    )
-
-def test_suite():
-    result = TestUtil.TestSuite()
-    result.addTest(test_chunked.test_suite())
-    result.addTest(test_details.test_suite())
-    result.addTest(test_progress_model.test_suite())
-    result.addTest(test_test_results.test_suite())
-    result.addTest(test_test_protocol.test_suite())
-    result.addTest(test_tap2subunit.test_suite())
-    result.addTest(test_subunit_filter.test_suite())
-    result.addTest(test_subunit_tags.test_suite())
-    result.addTest(test_subunit_stats.test_suite())
-    return result

=== removed file 'python-for-subunit2junitxml/subunit/tests/sample-script.py'
--- python-for-subunit2junitxml/subunit/tests/sample-script.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/sample-script.py	1970-01-01 00:00:00 +0000
@@ -1,21 +0,0 @@
-#!/usr/bin/env python
-import sys
-if sys.platform == "win32":
-    import msvcrt, os
-    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
-if len(sys.argv) == 2:
-    # subunit.tests.test_test_protocol.TestExecTestCase.test_sample_method_args 
-    # uses this code path to be sure that the arguments were passed to
-    # sample-script.py
-    print "test fail"
-    print "error fail"
-    sys.exit(0)
-print "test old mcdonald"
-print "success old mcdonald"
-print "test bing crosby"
-print "failure bing crosby ["
-print "foo.c:53:ERROR invalid state"
-print "]"
-print "test an error"
-print "error an error"
-sys.exit(0)

=== removed file 'python-for-subunit2junitxml/subunit/tests/sample-two-script.py'
--- python-for-subunit2junitxml/subunit/tests/sample-two-script.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/sample-two-script.py	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-import sys
-print "test old mcdonald"
-print "success old mcdonald"
-print "test bing crosby"
-print "success bing crosby"
-sys.exit(0)

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_chunked.py'
--- python-for-subunit2junitxml/subunit/tests/test_chunked.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_chunked.py	1970-01-01 00:00:00 +0000
@@ -1,152 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#  Copyright (C) 2011  Martin Pool <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-import unittest
-
-from testtools.compat import _b, BytesIO
-
-import subunit.chunked
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result
-
-
-class TestDecode(unittest.TestCase):
-
-    def setUp(self):
-        unittest.TestCase.setUp(self)
-        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(_b('2\r\na')))
-        self.assertRaises(ValueError, self.decoder.close)
-
-    def test_close_body_buffered_data_errors(self):
-        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(_b('2\r\nab')))
-        self.assertEqual(_b(''), self.decoder.write(_b('0\r\n')))
-        self.decoder.close()
-
-    def test_decode_nothing(self):
-        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(_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(_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(_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(_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(_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(_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(_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(_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, _b('a\n'))
-
-    def test_decode_strict_multiple_crs(self):
-        self.assertRaises(ValueError,
-            self.decoder.write, _b('a\r\r\n'))
-
-    def test_decode_short_header(self):
-        self.assertRaises(ValueError,
-            self.decoder.write, _b('\n'))
-
-
-class TestEncode(unittest.TestCase):
-
-    def setUp(self):
-        unittest.TestCase.setUp(self)
-        self.output = BytesIO()
-        self.encoder = subunit.chunked.Encoder(self.output)
-
-    def test_encode_nothing(self):
-        self.encoder.close()
-        self.assertEqual(_b('0\r\n'), self.output.getvalue())
-
-    def test_encode_empty(self):
-        self.encoder.write(_b(''))
-        self.encoder.close()
-        self.assertEqual(_b('0\r\n'), self.output.getvalue())
-
-    def test_encode_short(self):
-        self.encoder.write(_b('abc'))
-        self.encoder.close()
-        self.assertEqual(_b('3\r\nabc0\r\n'), self.output.getvalue())
-
-    def test_encode_combines_short(self):
-        self.encoder.write(_b('abc'))
-        self.encoder.write(_b('def'))
-        self.encoder.close()
-        self.assertEqual(_b('6\r\nabcdef0\r\n'), self.output.getvalue())
-
-    def test_encode_over_9_is_in_hex(self):
-        self.encoder.write(_b('1234567890'))
-        self.encoder.close()
-        self.assertEqual(_b('A\r\n12345678900\r\n'), self.output.getvalue())
-
-    def test_encode_long_ranges_not_combined(self):
-        self.encoder.write(_b('1' * 65536))
-        self.encoder.write(_b('2' * 65536))
-        self.encoder.close()
-        self.assertEqual(_b('10000\r\n' + '1' * 65536 + '10000\r\n' +
-            '2' * 65536 + '0\r\n'), self.output.getvalue())

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_details.py'
--- python-for-subunit2junitxml/subunit/tests/test_details.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_details.py	1970-01-01 00:00:00 +0000
@@ -1,112 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-import unittest
-
-from testtools.compat import _b, StringIO
-
-import subunit.tests
-from subunit import content, content_type, details
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result
-
-
-class TestSimpleDetails(unittest.TestCase):
-
-    def test_lineReceived(self):
-        parser = details.SimpleDetailsParser(None)
-        parser.lineReceived(_b("foo\n"))
-        parser.lineReceived(_b("bar\n"))
-        self.assertEqual(_b("foo\nbar\n"), parser._message)
-
-    def test_lineReceived_escaped_bracket(self):
-        parser = details.SimpleDetailsParser(None)
-        parser.lineReceived(_b("foo\n"))
-        parser.lineReceived(_b(" ]are\n"))
-        parser.lineReceived(_b("bar\n"))
-        self.assertEqual(_b("foo\n]are\nbar\n"), parser._message)
-
-    def test_get_message(self):
-        parser = details.SimpleDetailsParser(None)
-        self.assertEqual(_b(""), parser.get_message())
-
-    def test_get_details(self):
-        parser = details.SimpleDetailsParser(None)
-        traceback = ""
-        expected = {}
-        expected['traceback'] = content.Content(
-            content_type.ContentType("text", "x-traceback",
-                {'charset': 'utf8'}),
-            lambda:[_b("")])
-        found = parser.get_details()
-        self.assertEqual(expected.keys(), found.keys())
-        self.assertEqual(expected['traceback'].content_type,
-            found['traceback'].content_type)
-        self.assertEqual(_b('').join(expected['traceback'].iter_bytes()),
-            _b('').join(found['traceback'].iter_bytes()))
-
-    def test_get_details_skip(self):
-        parser = details.SimpleDetailsParser(None)
-        traceback = ""
-        expected = {}
-        expected['reason'] = content.Content(
-            content_type.ContentType("text", "plain"),
-            lambda:[_b("")])
-        found = parser.get_details("skip")
-        self.assertEqual(expected, found)
-
-    def test_get_details_success(self):
-        parser = details.SimpleDetailsParser(None)
-        traceback = ""
-        expected = {}
-        expected['message'] = content.Content(
-            content_type.ContentType("text", "plain"),
-            lambda:[_b("")])
-        found = parser.get_details("success")
-        self.assertEqual(expected, found)
-
-
-class TestMultipartDetails(unittest.TestCase):
-
-    def test_get_message_is_None(self):
-        parser = details.MultipartDetailsParser(None)
-        self.assertEqual(None, parser.get_message())
-
-    def test_get_details(self):
-        parser = details.MultipartDetailsParser(None)
-        self.assertEqual({}, parser.get_details())
-
-    def test_parts(self):
-        parser = details.MultipartDetailsParser(None)
-        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:[_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(_b('').join(expected['something'].iter_bytes()),
-            _b('').join(found['something'].iter_bytes()))

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_progress_model.py'
--- python-for-subunit2junitxml/subunit/tests/test_progress_model.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_progress_model.py	1970-01-01 00:00:00 +0000
@@ -1,118 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-import unittest
-
-import subunit
-from subunit.progress_model import ProgressModel
-
-
-class TestProgressModel(unittest.TestCase):
-
-    def assertProgressSummary(self, pos, total, progress):
-        """Assert that a progress model has reached a particular point."""
-        self.assertEqual(pos, progress.pos())
-        self.assertEqual(total, progress.width())
-
-    def test_new_progress_0_0(self):
-        progress = ProgressModel()
-        self.assertProgressSummary(0, 0, progress)
-
-    def test_advance_0_0(self):
-        progress = ProgressModel()
-        progress.advance()
-        self.assertProgressSummary(1, 0, progress)
-
-    def test_advance_1_0(self):
-        progress = ProgressModel()
-        progress.advance()
-        self.assertProgressSummary(1, 0, progress)
-
-    def test_set_width_absolute(self):
-        progress = ProgressModel()
-        progress.set_width(10)
-        self.assertProgressSummary(0, 10, progress)
-
-    def test_set_width_absolute_preserves_pos(self):
-        progress = ProgressModel()
-        progress.advance()
-        progress.set_width(2)
-        self.assertProgressSummary(1, 2, progress)
-
-    def test_adjust_width(self):
-        progress = ProgressModel()
-        progress.adjust_width(10)
-        self.assertProgressSummary(0, 10, progress)
-        progress.adjust_width(-10)
-        self.assertProgressSummary(0, 0, progress)
-
-    def test_adjust_width_preserves_pos(self):
-        progress = ProgressModel()
-        progress.advance()
-        progress.adjust_width(10)
-        self.assertProgressSummary(1, 10, progress)
-        progress.adjust_width(-10)
-        self.assertProgressSummary(1, 0, progress)
-
-    def test_push_preserves_progress(self):
-        progress = ProgressModel()
-        progress.adjust_width(3)
-        progress.advance()
-        progress.push()
-        self.assertProgressSummary(1, 3, progress)
-
-    def test_advance_advances_substack(self):
-        progress = ProgressModel()
-        progress.adjust_width(3)
-        progress.advance()
-        progress.push()
-        progress.adjust_width(1)
-        progress.advance()
-        self.assertProgressSummary(2, 3, progress)
-
-    def test_adjust_width_adjusts_substack(self):
-        progress = ProgressModel()
-        progress.adjust_width(3)
-        progress.advance()
-        progress.push()
-        progress.adjust_width(2)
-        progress.advance()
-        self.assertProgressSummary(3, 6, progress)
-
-    def test_set_width_adjusts_substack(self):
-        progress = ProgressModel()
-        progress.adjust_width(3)
-        progress.advance()
-        progress.push()
-        progress.set_width(2)
-        progress.advance()
-        self.assertProgressSummary(3, 6, progress)
-
-    def test_pop_restores_progress(self):
-        progress = ProgressModel()
-        progress.adjust_width(3)
-        progress.advance()
-        progress.push()
-        progress.adjust_width(1)
-        progress.advance()
-        progress.pop()
-        self.assertProgressSummary(1, 3, progress)
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_subunit_filter.py'
--- python-for-subunit2junitxml/subunit/tests/test_subunit_filter.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_subunit_filter.py	1970-01-01 00:00:00 +0000
@@ -1,208 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Tests for subunit.TestResultFilter."""
-
-from datetime import datetime
-from subunit import iso8601
-import unittest
-
-from testtools import TestCase
-from testtools.compat import _b, BytesIO, StringIO
-from testtools.testresult.doubles import ExtendedTestResult
-
-import subunit
-from subunit.test_results import TestResultFilter
-
-
-class TestTestResultFilter(TestCase):
-    """Test for TestResultFilter, a TestResult object which filters tests."""
-
-    # While TestResultFilter works on python objects, using a subunit stream
-    # 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 = _b("""\
-tags: global
-test passed
-success passed
-test failed
-tags: local
-failure failed
-test error
-error error [
-error details
-]
-test skipped
-skip skipped
-test todo
-xfail todo
-""")
-
-    def run_tests(self, result_filter, input_stream=None):
-        """Run tests through the given filter.
-
-        :param result_filter: A filtering TestResult object.
-        :param input_stream: Bytes of subunit stream data. If not provided,
-            uses TestTestResultFilter.example_subunit_stream.
-        """
-        if input_stream is None:
-            input_stream = self.example_subunit_stream
-        test = subunit.ProtocolTestCase(BytesIO(input_stream))
-        test.run(result_filter)
-
-    def test_default(self):
-        """The default is to exclude success and include everything else."""
-        filtered_result = unittest.TestResult()
-        result_filter = TestResultFilter(filtered_result)
-        self.run_tests(result_filter)
-        # skips are seen as success by default python TestResult.
-        self.assertEqual(['error'],
-            [error[0].id() for error in filtered_result.errors])
-        self.assertEqual(['failed'],
-            [failure[0].id() for failure in
-            filtered_result.failures])
-        self.assertEqual(4, filtered_result.testsRun)
-
-    def test_exclude_errors(self):
-        filtered_result = unittest.TestResult()
-        result_filter = TestResultFilter(filtered_result, filter_error=True)
-        self.run_tests(result_filter)
-        # skips are seen as errors by default python TestResult.
-        self.assertEqual([], filtered_result.errors)
-        self.assertEqual(['failed'],
-            [failure[0].id() for failure in
-            filtered_result.failures])
-        self.assertEqual(3, filtered_result.testsRun)
-
-    def test_fixup_expected_failures(self):
-        filtered_result = unittest.TestResult()
-        result_filter = TestResultFilter(filtered_result,
-            fixup_expected_failures=set(["failed"]))
-        self.run_tests(result_filter)
-        self.assertEqual(['failed', 'todo'],
-            [failure[0].id() for failure in filtered_result.expectedFailures])
-        self.assertEqual([], filtered_result.failures)
-        self.assertEqual(4, filtered_result.testsRun)
-
-    def test_fixup_expected_errors(self):
-        filtered_result = unittest.TestResult()
-        result_filter = TestResultFilter(filtered_result,
-            fixup_expected_failures=set(["error"]))
-        self.run_tests(result_filter)
-        self.assertEqual(['error', 'todo'],
-            [failure[0].id() for failure in filtered_result.expectedFailures])
-        self.assertEqual([], filtered_result.errors)
-        self.assertEqual(4, filtered_result.testsRun)
-
-    def test_fixup_unexpected_success(self):
-        filtered_result = unittest.TestResult()
-        result_filter = TestResultFilter(filtered_result, filter_success=False,
-            fixup_expected_failures=set(["passed"]))
-        self.run_tests(result_filter)
-        self.assertEqual(['passed'],
-            [passed.id() for passed in filtered_result.unexpectedSuccesses])
-        self.assertEqual(5, filtered_result.testsRun)
-
-    def test_exclude_failure(self):
-        filtered_result = unittest.TestResult()
-        result_filter = TestResultFilter(filtered_result, filter_failure=True)
-        self.run_tests(result_filter)
-        self.assertEqual(['error'],
-            [error[0].id() for error in filtered_result.errors])
-        self.assertEqual([],
-            [failure[0].id() for failure in
-            filtered_result.failures])
-        self.assertEqual(3, filtered_result.testsRun)
-
-    def test_exclude_skips(self):
-        filtered_result = subunit.TestResultStats(None)
-        result_filter = TestResultFilter(filtered_result, filter_skip=True)
-        self.run_tests(result_filter)
-        self.assertEqual(0, filtered_result.skipped_tests)
-        self.assertEqual(2, filtered_result.failed_tests)
-        self.assertEqual(3, filtered_result.testsRun)
-
-    def test_include_success(self):
-        """Successes can be included if requested."""
-        filtered_result = unittest.TestResult()
-        result_filter = TestResultFilter(filtered_result,
-            filter_success=False)
-        self.run_tests(result_filter)
-        self.assertEqual(['error'],
-            [error[0].id() for error in filtered_result.errors])
-        self.assertEqual(['failed'],
-            [failure[0].id() for failure in
-            filtered_result.failures])
-        self.assertEqual(5, filtered_result.testsRun)
-
-    def test_filter_predicate(self):
-        """You can filter by predicate callbacks"""
-        filtered_result = unittest.TestResult()
-        def filter_cb(test, outcome, err, details):
-            return outcome == 'success'
-        result_filter = TestResultFilter(filtered_result,
-            filter_predicate=filter_cb,
-            filter_success=False)
-        self.run_tests(result_filter)
-        # Only success should pass
-        self.assertEqual(1, filtered_result.testsRun)
-
-    def test_time_ordering_preserved(self):
-        # Passing a subunit stream through TestResultFilter preserves the
-        # relative ordering of 'time' directives and any other subunit
-        # directives that are still included.
-        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 = _b('\n'.join([
-            "time: %s",
-            "test: foo",
-            "time: %s",
-            "error: foo",
-            "time: %s",
-            ""]) % (date_a, date_b, date_c))
-        result = ExtendedTestResult()
-        result_filter = TestResultFilter(result)
-        self.run_tests(result_filter, subunit_stream)
-        foo = subunit.RemotedTestCase('foo')
-        self.assertEquals(
-            [('time', date_a),
-             ('startTest', foo),
-             ('time', date_b),
-             ('addError', foo, {}),
-             ('stopTest', foo),
-             ('time', date_c)], result._events)
-
-    def test_skip_preserved(self):
-        subunit_stream = _b('\n'.join([
-            "test: foo",
-            "skip: foo",
-            ""]))
-        result = ExtendedTestResult()
-        result_filter = TestResultFilter(result)
-        self.run_tests(result_filter, subunit_stream)
-        foo = subunit.RemotedTestCase('foo')
-        self.assertEquals(
-            [('startTest', foo),
-             ('addSkip', foo, {}),
-             ('stopTest', foo), ], result._events)
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_subunit_stats.py'
--- python-for-subunit2junitxml/subunit/tests/test_subunit_stats.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_subunit_stats.py	1970-01-01 00:00:00 +0000
@@ -1,84 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Tests for subunit.TestResultStats."""
-
-import unittest
-
-from testtools.compat import _b, BytesIO, StringIO
-
-import subunit
-
-
-class TestTestResultStats(unittest.TestCase):
-    """Test for TestResultStats, a TestResult object that generates stats."""
-
-    def setUp(self):
-        self.output = StringIO()
-        self.result = subunit.TestResultStats(self.output)
-        self.input_stream = BytesIO()
-        self.test = subunit.ProtocolTestCase(self.input_stream)
-
-    def test_stats_empty(self):
-        self.test.run(self.result)
-        self.assertEqual(0, self.result.total_tests)
-        self.assertEqual(0, self.result.passed_tests)
-        self.assertEqual(0, self.result.failed_tests)
-        self.assertEqual(set(), self.result.seen_tags)
-
-    def setUpUsedStream(self):
-        self.input_stream.write(_b("""tags: global
-test passed
-success passed
-test failed
-tags: local
-failure failed
-test error
-error error
-test skipped
-skip skipped
-test todo
-xfail todo
-"""))
-        self.input_stream.seek(0)
-        self.test.run(self.result)
-    
-    def test_stats_smoke_everything(self):
-        # Statistics are calculated usefully.
-        self.setUpUsedStream()
-        self.assertEqual(5, self.result.total_tests)
-        self.assertEqual(2, self.result.passed_tests)
-        self.assertEqual(2, self.result.failed_tests)
-        self.assertEqual(1, self.result.skipped_tests)
-        self.assertEqual(set(["global", "local"]), self.result.seen_tags)
-
-    def test_stat_formatting(self):
-        expected = ("""
-Total tests:       5
-Passed tests:      2
-Failed tests:      2
-Skipped tests:     1
-Seen tags: global, local
-""")[1:]
-        self.setUpUsedStream()
-        self.result.formatStats()
-        self.assertEqual(expected, self.output.getvalue())
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_subunit_tags.py'
--- python-for-subunit2junitxml/subunit/tests/test_subunit_tags.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_subunit_tags.py	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Tests for subunit.tag_stream."""
-
-import unittest
-
-from testtools.compat import StringIO
-
-import subunit
-import subunit.test_results
-
-
-class TestSubUnitTags(unittest.TestCase):
-
-    def setUp(self):
-        self.original = StringIO()
-        self.filtered = StringIO()
-
-    def test_add_tag(self):
-        self.original.write("tags: foo\n")
-        self.original.write("test: test\n")
-        self.original.write("tags: bar -quux\n")
-        self.original.write("success: test\n")
-        self.original.seek(0)
-        result = subunit.tag_stream(self.original, self.filtered, ["quux"])
-        self.assertEqual([
-            "tags: quux",
-            "tags: foo",
-            "test: test",
-            "tags: bar",
-            "success: test",
-            ],
-            self.filtered.getvalue().splitlines())
-
-    def test_remove_tag(self):
-        self.original.write("tags: foo\n")
-        self.original.write("test: test\n")
-        self.original.write("tags: bar -quux\n")
-        self.original.write("success: test\n")
-        self.original.seek(0)
-        result = subunit.tag_stream(self.original, self.filtered, ["-bar"])
-        self.assertEqual([
-            "tags: -bar",
-            "tags: foo",
-            "test: test",
-            "tags: -quux",
-            "success: test",
-            ],
-            self.filtered.getvalue().splitlines())
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_tap2subunit.py'
--- python-for-subunit2junitxml/subunit/tests/test_tap2subunit.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_tap2subunit.py	1970-01-01 00:00:00 +0000
@@ -1,445 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#  
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-"""Tests for TAP2SubUnit."""
-
-import unittest
-
-from testtools.compat import StringIO
-
-import subunit
-
-
-class TestTAP2SubUnit(unittest.TestCase):
-    """Tests for TAP2SubUnit.
-
-    These tests test TAP string data in, and subunit string data out.
-    This is ok because the subunit protocol is intended to be stable,
-    but it might be easier/pithier to write tests against TAP string in,
-    parsed subunit objects out (by hooking the subunit stream to a subunit
-    protocol server.
-    """
-
-    def setUp(self):
-        self.tap = StringIO()
-        self.subunit = StringIO()
-
-    def test_skip_entire_file(self):
-        # A file
-        # 1..- # Skipped: comment
-        # results in a single skipped test.
-        self.tap.write("1..0 # Skipped: entire file skipped\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test file skip",
-            "skip file skip [",
-            "Skipped: entire file skipped",
-            "]",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_test_pass(self):
-        # A file
-        # ok
-        # results in a passed test with name 'test 1' (a synthetic name as tap
-        # does not require named fixtures - it is the first test in the tap
-        # stream).
-        self.tap.write("ok\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1",
-            "success test 1",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_test_number_pass(self):
-        # A file
-        # ok 1
-        # results in a passed test with name 'test 1'
-        self.tap.write("ok 1\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1",
-            "success test 1",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_test_number_description_pass(self):
-        # A file
-        # ok 1 - There is a description
-        # results in a passed test with name 'test 1 - There is a description'
-        self.tap.write("ok 1 - There is a description\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1 - There is a description",
-            "success test 1 - There is a description",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_test_description_pass(self):
-        # A file
-        # ok There is a description
-        # results in a passed test with name 'test 1 There is a description'
-        self.tap.write("ok There is a description\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1 There is a description",
-            "success test 1 There is a description",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_SKIP_skip(self):
-        # A file
-        # ok # SKIP
-        # results in a skkip test with name 'test 1'
-        self.tap.write("ok # SKIP\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1",
-            "skip test 1",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_skip_number_comment_lowercase(self):
-        self.tap.write("ok 1 # skip no samba environment available, skipping compilation\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1",
-            "skip test 1 [", 
-            "no samba environment available, skipping compilation",
-            "]"
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_number_description_SKIP_skip_comment(self):
-        # A file
-        # ok 1 foo  # SKIP Not done yet
-        # results in a skip test with name 'test 1 foo' and a log of
-        # Not done yet
-        self.tap.write("ok 1 foo  # SKIP Not done yet\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1 foo",
-            "skip test 1 foo [",
-            "Not done yet",
-            "]",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_SKIP_skip_comment(self):
-        # A file
-        # ok # SKIP Not done yet
-        # results in a skip test with name 'test 1' and a log of Not done yet
-        self.tap.write("ok # SKIP Not done yet\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1",
-            "skip test 1 [",
-            "Not done yet",
-            "]",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_TODO_xfail(self):
-        # A file
-        # ok # TODO
-        # results in a xfail test with name 'test 1'
-        self.tap.write("ok # TODO\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1",
-            "xfail test 1",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_ok_TODO_xfail_comment(self):
-        # A file
-        # ok # TODO Not done yet
-        # results in a xfail test with name 'test 1' and a log of Not done yet
-        self.tap.write("ok # TODO Not done yet\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1",
-            "xfail test 1 [",
-            "Not done yet",
-            "]",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_bail_out_errors(self):
-        # A file with line in it
-        # Bail out! COMMENT
-        # is treated as an error
-        self.tap.write("ok 1 foo\n")
-        self.tap.write("Bail out! Lifejacket engaged\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            "test test 1 foo",
-            "success test 1 foo",
-            "test Bail out! Lifejacket engaged",
-            "error Bail out! Lifejacket engaged",
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_missing_test_at_end_with_plan_adds_error(self):
-        # A file
-        # 1..3
-        # ok first test
-        # not ok third test
-        # results in three tests, with the third being created
-        self.tap.write('1..3\n')
-        self.tap.write('ok first test\n')
-        self.tap.write('not ok second test\n')
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1 first test',
-            'success test 1 first test',
-            'test test 2 second test',
-            'failure test 2 second test',
-            'test test 3',
-            'error test 3 [',
-            'test missing from TAP output',
-            ']',
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_missing_test_with_plan_adds_error(self):
-        # A file
-        # 1..3
-        # ok first test
-        # not ok 3 third test
-        # results in three tests, with the second being created
-        self.tap.write('1..3\n')
-        self.tap.write('ok first test\n')
-        self.tap.write('not ok 3 third test\n')
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1 first test',
-            'success test 1 first test',
-            'test test 2',
-            'error test 2 [',
-            'test missing from TAP output',
-            ']',
-            'test test 3 third test',
-            'failure test 3 third test',
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_missing_test_no_plan_adds_error(self):
-        # A file
-        # ok first test
-        # not ok 3 third test
-        # results in three tests, with the second being created
-        self.tap.write('ok first test\n')
-        self.tap.write('not ok 3 third test\n')
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1 first test',
-            'success test 1 first test',
-            'test test 2',
-            'error test 2 [',
-            'test missing from TAP output',
-            ']',
-            'test test 3 third test',
-            'failure test 3 third test',
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_four_tests_in_a_row_trailing_plan(self):
-        # A file
-        # ok 1 - first test in a script with no plan at all
-        # not ok 2 - second
-        # ok 3 - third
-        # not ok 4 - fourth
-        # 1..4
-        # results in four tests numbered and named
-        self.tap.write('ok 1 - first test in a script with trailing plan\n')
-        self.tap.write('not ok 2 - second\n')
-        self.tap.write('ok 3 - third\n')
-        self.tap.write('not ok 4 - fourth\n')
-        self.tap.write('1..4\n')
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1 - first test in a script with trailing plan',
-            'success test 1 - first test in a script with trailing plan',
-            'test test 2 - second',
-            'failure test 2 - second',
-            'test test 3 - third',
-            'success test 3 - third',
-            'test test 4 - fourth',
-            'failure test 4 - fourth'
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_four_tests_in_a_row_with_plan(self):
-        # A file
-        # 1..4
-        # ok 1 - first test in a script with no plan at all
-        # not ok 2 - second
-        # ok 3 - third
-        # not ok 4 - fourth
-        # results in four tests numbered and named
-        self.tap.write('1..4\n')
-        self.tap.write('ok 1 - first test in a script with a plan\n')
-        self.tap.write('not ok 2 - second\n')
-        self.tap.write('ok 3 - third\n')
-        self.tap.write('not ok 4 - fourth\n')
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1 - first test in a script with a plan',
-            'success test 1 - first test in a script with a plan',
-            'test test 2 - second',
-            'failure test 2 - second',
-            'test test 3 - third',
-            'success test 3 - third',
-            'test test 4 - fourth',
-            'failure test 4 - fourth'
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_four_tests_in_a_row_no_plan(self):
-        # A file
-        # ok 1 - first test in a script with no plan at all
-        # not ok 2 - second
-        # ok 3 - third
-        # not ok 4 - fourth
-        # results in four tests numbered and named
-        self.tap.write('ok 1 - first test in a script with no plan at all\n')
-        self.tap.write('not ok 2 - second\n')
-        self.tap.write('ok 3 - third\n')
-        self.tap.write('not ok 4 - fourth\n')
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1 - first test in a script with no plan at all',
-            'success test 1 - first test in a script with no plan at all',
-            'test test 2 - second',
-            'failure test 2 - second',
-            'test test 3 - third',
-            'success test 3 - third',
-            'test test 4 - fourth',
-            'failure test 4 - fourth'
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_todo_and_skip(self):
-        # A file
-        # not ok 1 - a fail but # TODO but is TODO
-        # not ok 2 - another fail # SKIP instead
-        # results in two tests, numbered and commented.
-        self.tap.write("not ok 1 - a fail but # TODO but is TODO\n")
-        self.tap.write("not ok 2 - another fail # SKIP instead\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1 - a fail but',
-            'xfail test 1 - a fail but [',
-            'but is TODO',
-            ']',
-            'test test 2 - another fail',
-            'skip test 2 - another fail [',
-            'instead',
-            ']',
-            ],
-            self.subunit.getvalue().splitlines())
-
-    def test_leading_comments_add_to_next_test_log(self):
-        # A file
-        # # comment
-        # ok 
-        # ok
-        # results in a single test with the comment included
-        # in the first test and not the second.
-        self.tap.write("# comment\n")
-        self.tap.write("ok\n")
-        self.tap.write("ok\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1',
-            'success test 1 [',
-            '# comment',
-            ']',
-            'test test 2',
-            'success test 2',
-            ],
-            self.subunit.getvalue().splitlines())
-    
-    def test_trailing_comments_are_included_in_last_test_log(self):
-        # A file
-        # ok foo
-        # ok foo
-        # # comment
-        # results in a two tests, with the second having the comment
-        # attached to its log.
-        self.tap.write("ok\n")
-        self.tap.write("ok\n")
-        self.tap.write("# comment\n")
-        self.tap.seek(0)
-        result = subunit.TAP2SubUnit(self.tap, self.subunit)
-        self.assertEqual(0, result)
-        self.assertEqual([
-            'test test 1',
-            'success test 1',
-            'test test 2',
-            'success test 2 [',
-            '# comment',
-            ']',
-            ],
-            self.subunit.getvalue().splitlines())
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result

=== removed file 'python-for-subunit2junitxml/subunit/tests/test_test_protocol.py'
--- python-for-subunit2junitxml/subunit/tests/test_test_protocol.py	2013-05-27 13:46:13 +0000
+++ python-for-subunit2junitxml/subunit/tests/test_test_protocol.py	1970-01-01 00:00:00 +0000
@@ -1,1299 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <[e-mail]>
-#
-#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
-#  license at the users choice. A copy of both licenses are available in the
-#  project source as Apache-2.0 and BSD. You may not use this file except in
-#  compliance with one of these two licences.
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
-#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-#  license you chose for the specific language governing permissions and
-#  limitations under that license.
-#
-
-import datetime
-import unittest
-import os
-
-from testtools import skipIf, TestCase
-from testtools.compat import _b, _u, BytesIO, StringIO
-from testtools.content import Content, TracebackContent
-from testtools.content_type import ContentType
-from testtools.tests.helpers import (
-    Python26TestResult,
-    Python27TestResult,
-    ExtendedTestResult,
-    )
-
-import subunit
-from subunit import _remote_exception_str, _remote_exception_str_chunked
-import subunit.iso8601 as iso8601
-
-
-class TestTestImports(unittest.TestCase):
-
-    def test_imports(self):
-        from subunit import DiscardStream
-        from subunit import TestProtocolServer
-        from subunit import RemotedTestCase
-        from subunit import RemoteError
-        from subunit import ExecTestCase
-        from subunit import IsolatedTestCase
-        from subunit import TestProtocolClient
-        from subunit import ProtocolTestCase
-
-
-class TestDiscardStream(unittest.TestCase):
-
-    def test_write(self):
-        subunit.DiscardStream().write("content")
-
-
-class TestProtocolServerForward(unittest.TestCase):
-
-    def test_story(self):
-        client = unittest.TestResult()
-        out = BytesIO()
-        protocol = subunit.TestProtocolServer(client, forward_stream=out)
-        pipe = BytesIO(_b("test old mcdonald\n"
-                        "success old mcdonald\n"))
-        protocol.readFrom(pipe)
-        self.assertEqual(client.testsRun, 1)
-        self.assertEqual(pipe.getvalue(), out.getvalue())
-
-    def test_not_command(self):
-        client = unittest.TestResult()
-        out = BytesIO()
-        protocol = subunit.TestProtocolServer(client,
-            stream=subunit.DiscardStream(), forward_stream=out)
-        pipe = BytesIO(_b("success old mcdonald\n"))
-        protocol.readFrom(pipe)
-        self.assertEqual(client.testsRun, 0)
-        self.assertEqual(_b(""), out.getvalue())
-
-
-class TestTestProtocolServerPipe(unittest.TestCase):
-
-    def test_story(self):
-        client = unittest.TestResult()
-        protocol = subunit.TestProtocolServer(client)
-        pipe = BytesIO(_b("test old mcdonald\n"
-                        "success old mcdonald\n"
-                        "test bing crosby\n"
-                        "failure bing crosby [\n"
-                        "foo.c:53:ERROR invalid state\n"
-                        "]\n"
-                        "test an error\n"
-                        "error an error\n"))
-        protocol.readFrom(pipe)
-        bing = subunit.RemotedTestCase("bing crosby")
-        an_error = subunit.RemotedTestCase("an error")
-        self.assertEqual(client.errors,
-                         [(an_error, _remote_exception_str + '\n')])
-        self.assertEqual(
-            client.failures,
-            [(bing, _remote_exception_str + ": Text attachment: traceback\n"
-                "------------\nfoo.c:53:ERROR invalid state\n"
-                "------------\n\n")])
-        self.assertEqual(client.testsRun, 3)
-
-    def test_non_test_characters_forwarded_immediately(self):
-        pass
-
-
-class TestTestProtocolServerStartTest(unittest.TestCase):
-
-    def setUp(self):
-        self.client = Python26TestResult()
-        self.stream = BytesIO()
-        self.protocol = subunit.TestProtocolServer(self.client, self.stream)
-
-    def test_start_test(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.assertEqual(self.client._events,
-            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
-
-    def test_start_testing(self):
-        self.protocol.lineReceived(_b("testing old mcdonald\n"))
-        self.assertEqual(self.client._events,
-            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
-
-    def test_start_test_colon(self):
-        self.protocol.lineReceived(_b("test: old mcdonald\n"))
-        self.assertEqual(self.client._events,
-            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
-
-    def test_indented_test_colon_ignored(self):
-        ignored_line = _b(" test: old mcdonald\n")
-        self.protocol.lineReceived(ignored_line)
-        self.assertEqual([], self.client._events)
-        self.assertEqual(self.stream.getvalue(), ignored_line)
-
-    def test_start_testing_colon(self):
-        self.protocol.lineReceived(_b("testing: old mcdonald\n"))
-        self.assertEqual(self.client._events,
-            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
-
-
-class TestTestProtocolServerPassThrough(unittest.TestCase):
-
-    def setUp(self):
-        self.stdout = BytesIO()
-        self.test = subunit.RemotedTestCase("old mcdonald")
-        self.client = ExtendedTestResult()
-        self.protocol = subunit.TestProtocolServer(self.client, self.stdout)
-
-    def keywords_before_test(self):
-        self.protocol.lineReceived(_b("failure a\n"))
-        self.protocol.lineReceived(_b("failure: a\n"))
-        self.protocol.lineReceived(_b("error a\n"))
-        self.protocol.lineReceived(_b("error: a\n"))
-        self.protocol.lineReceived(_b("success a\n"))
-        self.protocol.lineReceived(_b("success: a\n"))
-        self.protocol.lineReceived(_b("successful a\n"))
-        self.protocol.lineReceived(_b("successful: a\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.assertEqual(self.stdout.getvalue(), _b("failure a\n"
-                                                 "failure: a\n"
-                                                 "error a\n"
-                                                 "error: a\n"
-                                                 "success a\n"
-                                                 "success: a\n"
-                                                 "successful a\n"
-                                                 "successful: a\n"
-                                                 "]\n"))
-
-    def test_keywords_before_test(self):
-        self.keywords_before_test()
-        self.assertEqual(self.client._events, [])
-
-    def test_keywords_after_error(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("error old mcdonald\n"))
-        self.keywords_before_test()
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addError', self.test, {}),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_keywords_after_failure(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("failure old mcdonald\n"))
-        self.keywords_before_test()
-        self.assertEqual(self.client._events, [
-            ('startTest', self.test),
-            ('addFailure', self.test, {}),
-            ('stopTest', self.test),
-            ])
-
-    def test_keywords_after_success(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("success old mcdonald\n"))
-        self.keywords_before_test()
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addSuccess', self.test),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_keywords_after_test(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("failure a\n"))
-        self.protocol.lineReceived(_b("failure: a\n"))
-        self.protocol.lineReceived(_b("error a\n"))
-        self.protocol.lineReceived(_b("error: a\n"))
-        self.protocol.lineReceived(_b("success a\n"))
-        self.protocol.lineReceived(_b("success: a\n"))
-        self.protocol.lineReceived(_b("successful a\n"))
-        self.protocol.lineReceived(_b("successful: a\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.protocol.lineReceived(_b("failure old mcdonald\n"))
-        self.assertEqual(self.stdout.getvalue(), _b("test old mcdonald\n"
-                                                 "failure a\n"
-                                                 "failure: a\n"
-                                                 "error a\n"
-                                                 "error: a\n"
-                                                 "success a\n"
-                                                 "success: a\n"
-                                                 "successful a\n"
-                                                 "successful: a\n"
-                                                 "]\n"))
-        self.assertEqual(self.client._events, [
-            ('startTest', self.test),
-            ('addFailure', self.test, {}),
-            ('stopTest', self.test),
-            ])
-
-    def test_keywords_during_failure(self):
-        # A smoke test to make sure that the details parsers have control
-        # appropriately.
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("failure: old mcdonald [\n"))
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("failure a\n"))
-        self.protocol.lineReceived(_b("failure: a\n"))
-        self.protocol.lineReceived(_b("error a\n"))