Remove bundled subunit.

Change-Id: I18e19c3817de6f97fe2a9fb1b7faa4f8a0d27649
Signed-off-by: Jelmer Vernooij <jelmer@samba.org>
Reviewed-by: Andrew Bartlett <abartlet@samba.org>

67 files changed, 0 insertions, 9783 deletions

diff --git a/lib/subunit/Apache-2.0 b/lib/subunit/Apache-2.0
deleted file mode 100644
index d645695673..0000000000
--- a/lib/subunit/Apache-2.0
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/lib/subunit/BSD b/lib/subunit/BSD
deleted file mode 100644
index fa130cd529..0000000000
--- a/lib/subunit/BSD
+++ /dev/null
@@ -1,26 +0,0 @@
-Copyright (c) Robert Collins and Subunit contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. Neither the name of Robert Collins nor the names of Subunit contributors
-   may be used to endorse or promote products derived from this software
-   without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY ROBERT COLLINS AND SUBUNIT CONTRIBUTORS ``AS IS''
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
diff --git a/lib/subunit/COPYING b/lib/subunit/COPYING
deleted file mode 100644
index 3ba50f8e08..0000000000
--- a/lib/subunit/COPYING
+++ /dev/null
@@ -1,36 +0,0 @@
-Subunit is licensed under two licenses, the Apache License, Version 2.0 or the
-3-clause BSD License. You may use this project under either of these licenses
-- choose the one that works best for you.
-
-We require contributions to be licensed under both licenses. The primary
-difference between them is that the Apache license takes care of potential
-issues with Patents and other intellectual property concerns. This is
-important to Subunit as Subunit wants to be license compatible in a very 
-broad manner to allow reuse and incorporation into other projects.
-
-Generally every source file in Subunit needs a license grant under both these
-licenses.  As the code is shipped as a single unit, a brief form is used:
-----
-Copyright (c) [yyyy][,yyyy]* [name or 'Subunit Contributors']
-
-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.
-----
-
-Code that has been incorporated into Subunit from other projects will
-naturally be under its own license, and will retain that license.
-
-A known list of such code is maintained here:
-* The python/iso8601 module by Michael Twomey, distributed under an MIT style
-  licence - see python/iso8601/LICENSE for details.
-* The runtests.py and python/subunit/tests/TestUtil.py module are GPL test
-  support modules. There are not installed by Subunit - they are only ever
-  used on the build machine.  Copyright 2004 Canonical Limited.
diff --git a/lib/subunit/INSTALL b/lib/subunit/INSTALL
deleted file mode 100644
index eeea734f6a..0000000000
--- a/lib/subunit/INSTALL
+++ /dev/null
@@ -1,32 +0,0 @@
-To install subunit
-------------------
-
-Bootstrap::
-  autoreconf -vi
-Configure::
-  ./configure
-Install::
-  make install
-
-Dependencies
-------------
-
-* Python for the filters
-* 'testtools' (On Debian and Ubuntu systems the 'python-testtools' package,
-  the testtools package on pypi, or https://launchpad.net/testtools) for
-  the extended test API which permits attachments. Version 0.9.23 or newer is 
-  required. Of particular note, http://testtools.python-hosting.com/ is not
-  the testtools you want.
-* A C compiler for the C bindings
-* Perl for the Perl tools (including subunit-diff)
-* Check to run the subunit test suite.
-* python-gtk2 if you wish to use subunit2gtk
-* python-junitxml if you wish to use subunit2junitxml
-* pkg-config for configure detection of supporting libraries.
-
-Binary packages
----------------
-
-A number of distributions now include subunit, you can try via your package
-manager. The authors maintain a personal package archive on Launchpad::
-  https://launchpad.net/~testing-cabal/+archive/archive
diff --git a/lib/subunit/MANIFEST.in b/lib/subunit/MANIFEST.in
deleted file mode 100644
index eb98981628..0000000000
--- a/lib/subunit/MANIFEST.in
+++ /dev/null
@@ -1,20 +0,0 @@
-exclude .bzrignore
-exclude aclocal.m4
-prune autom4te.cache
-prune c
-prune c++
-prune compile
-exclude configure*
-exclude depcomp
-exclude INSTALL
-exclude install-sh
-exclude lib*
-exclude ltmain.sh
-prune m4
-exclude Makefile*
-exclude missing
-prune perl
-exclude py-compile
-prune shell
-exclude stamp-h1
-include NEWS
diff --git a/lib/subunit/Makefile.am b/lib/subunit/Makefile.am
deleted file mode 100644
index da1602037e..0000000000
--- a/lib/subunit/Makefile.am
+++ /dev/null
@@ -1,141 +0,0 @@
-EXTRA_DIST =  \
-	.bzrignore \
-	Apache-2.0 \
-	BSD \
-	INSTALL \
-	Makefile.am \
-	NEWS \
-	README \
-	c++/README \
-	c/README \
-	c/check-subunit-0.9.3.patch \
-	c/check-subunit-0.9.5.patch \
-	c/check-subunit-0.9.6.patch \
-	perl/Makefile.PL.in \
-	perl/lib/Subunit.pm \
-	perl/lib/Subunit/Diff.pm \
-	perl/subunit-diff \
-	python/iso8601/LICENSE \
-	python/iso8601/README \
-	python/iso8601/README.subunit \
-	python/iso8601/setup.py \
-	python/iso8601/test_iso8601.py \
-	python/subunit/tests/TestUtil.py \
-	python/subunit/tests/__init__.py \
-	python/subunit/tests/sample-script.py \
-	python/subunit/tests/sample-two-script.py \
-	python/subunit/tests/test_chunked.py \
-	python/subunit/tests/test_details.py \
-	python/subunit/tests/test_progress_model.py \
-	python/subunit/tests/test_subunit_filter.py \
-	python/subunit/tests/test_run.py \
-	python/subunit/tests/test_subunit_stats.py \
-	python/subunit/tests/test_subunit_tags.py \
-	python/subunit/tests/test_tap2subunit.py \
-	python/subunit/tests/test_test_protocol.py \
-	python/subunit/tests/test_test_results.py \
-	runtests.py \
-	setup.py \
-	shell/README \
-	shell/share/subunit.sh \
-	shell/subunit-ui.patch \
-	shell/tests/test_function_output.sh \
-	shell/tests/test_source_library.sh
-
-ACLOCAL_AMFLAGS = -I m4
-
-include_subunitdir = $(includedir)/subunit
-
-dist_bin_SCRIPTS = \
-	filters/subunit-filter \
-	filters/subunit-ls \
-	filters/subunit-notify \
-	filters/subunit-stats \
-	filters/subunit-tags \
-	filters/subunit2csv \
-	filters/subunit2gtk \
-	filters/subunit2junitxml \
-	filters/subunit2pyunit \
-	filters/tap2subunit
-
-TESTS_ENVIRONMENT = SHELL_SHARE='$(top_srcdir)/shell/share/' PYTHONPATH='$(abs_top_srcdir)/python':${PYTHONPATH}
-TESTS = runtests.py $(check_PROGRAMS)
-
-## install libsubunit.pc
-pcdatadir = $(libdir)/pkgconfig
-pcdata_DATA = \
-	libsubunit.pc \
-	libcppunit_subunit.pc
-
-pkgpython_PYTHON = \
-	python/subunit/__init__.py \
-	python/subunit/chunked.py \
-	python/subunit/details.py \
-	python/subunit/filters.py \
-	python/subunit/iso8601.py \
-	python/subunit/progress_model.py \
-	python/subunit/run.py \
-	python/subunit/test_results.py
-
-lib_LTLIBRARIES = libsubunit.la
-lib_LTLIBRARIES +=  libcppunit_subunit.la
-
-include_subunit_HEADERS = \
-	c/include/subunit/child.h \
-	c++/SubunitTestProgressListener.h
-
-check_PROGRAMS = \
-	c/tests/test_child
-
-check_SCRIPTS = \
-	runtests.py
-
-libsubunit_la_SOURCES = \
-	c/lib/child.c \
-	c/include/subunit/child.h
-
-libcppunit_subunit_la_SOURCES = \
-	c++/SubunitTestProgressListener.cpp \
-	c++/SubunitTestProgressListener.h
-
-tests_LDADD = @CHECK_LIBS@ $(top_builddir)/libsubunit.la
-c_tests_test_child_CFLAGS = -I$(top_srcdir)/c/include $(SUBUNIT_CFLAGS) @CHECK_CFLAGS@
-c_tests_test_child_LDADD = $(tests_LDADD)
-
-
-all-local: perl/Makefile
-	$(MAKE) -C perl all
-
-check-local: perl/Makefile
-	$(MAKE) -C perl check
-
-clean-local:
-	find . -type f -name "*.pyc" -exec rm {} ';'
-	rm -f perl/Makefile
-
-# Remove perl dir for VPATH builds.
-distclean-local:
-	-rmdir perl > /dev/null
-	-rm perl/Makefile.PL > /dev/null
-
-install-exec-local: perl/Makefile
-	$(MAKE) -C perl install
-
-mostlyclean-local:
-	rm -rf perl/blib
-	rm -rf perl/pm_to_blib
-
-# 'uninstall' perl files during distcheck
-uninstall-local:
-	if [ "_inst" = `basename ${prefix}` ]; then \
-	  $(MAKE) -C perl uninstall_distcheck; \
-	    rm -f "$(DESTDIR)$(bindir)"/subunit-diff; \
-	fi
-
-# The default for MakeMaker; can be overridden by exporting
-INSTALLDIRS ?= site
-
-perl/Makefile: perl/Makefile.PL
-	mkdir -p perl
-	cd perl && perl Makefile.PL INSTALLDIRS=${INSTALLDIRS}
-	-rm perl/Makefile.old > /dev/null
diff --git a/lib/subunit/NEWS b/lib/subunit/NEWS
deleted file mode 100644
index 081dc5dbfc..0000000000
--- a/lib/subunit/NEWS
+++ /dev/null
@@ -1,344 +0,0 @@
----------------------
-subunit release notes
----------------------
-
-NEXT (In development)
----------------------
-
-0.0.9
------
-
-BUG FIXES
-~~~~~~~~~
-
-* All the source files are now included in the distribution tarball.
-  (Arfrever Frehtes Taifersar Arahesis, Robert Collins, #996275)
-
-* ``python/subunit/tests/test_run.py`` and ``python/subunit/filters.py`` were
-  not included in the 0.0.8 tarball. (Robert Collins)
-
-* Test ids which include non-ascii unicode characters are now supported.
-  (Robert Collins, #1029866)
-
-* The ``failfast`` option to ``subunit.run`` will now work. The dependency on
-  testtools has been raised to 0.9.23 to permit this.
-  (Robert Collins, #1090582)
-
-0.0.8
------
-
-IMPROVEMENTS
-~~~~~~~~~~~~
-
-* Perl module now correctly outputs "failure" instead of "fail".  (Stewart Smith)
-
-* Shell functions now output timestamps. (Stewart Smith, Robert Collins)
-
-* 'subunit2csv' script that converts subunit output to CSV format.
-  (Jonathan Lange)
-
-* ``TagCollapsingDecorator`` now correctly distinguishes between local and
-  global tags.  (Jonathan Lange)
-
-* ``TestResultFilter`` always forwards ``time:`` events.
-  (Benji York, Brad Crittenden)
-
-BUG FIXES
-~~~~~~~~~
-
-* Add 'subunit --no-xfail', which will omit expected failures from the subunit
-  stream. (John Arbash Meinel, #623642)
-
-* Add 'subunit -F/--only-genuine-failures' which sets all of '--no-skips',
-  '--no-xfail', '--no-passthrough, '--no-success', and gives you just the
-  failure stream. (John Arbash Meinel)
-
-* Python2.6 support was broken by the fixup feature.
-  (Arfrever Frehtes Taifersar Arahesis, #987490)
-
-* Python3 support regressed in trunk.
-  (Arfrever Frehtes Taifersar Arahesis, #987514)
-
-* Python3 support was insufficiently robust in detecting unicode streams.
-  (Robert Collins, Arfrever Frehtes Taifersar Arahesis)
-
-* Tag support has been implemented for TestProtocolClient.
-  (Robert Collins, #518016)
-
-* Tags can now be filtered. (Jonathan Lange, #664171)
-
-* Test suite works with latest testtools (but not older ones - formatting
-  changes only). (Robert Collins)
-
-0.0.7
------
-
-The Subunit Python test runner ``python -m subunit.run`` can now report the
-test ids and also filter via a test id list file thanks to improvements in
-``testtools.run``. See the testtools manual, or testrepository - a major
-user of such functionality.
-
-Additionally the protocol now has a keyword uxsuccess for Unexpected Success
-reporting. Older parsers will report tests with this status code as 'lost
-connection'.
-
-IMPROVEMENTS
-~~~~~~~~~~~~
-
-* Add ``TimeCollapsingDecorator`` which collapses multiple sequential time()
-  calls into just the first and last. (Jonathan Lange)
-
-* Add ``TagCollapsingDecorator`` which collapses many tags() calls into one
-  where possible. (Jonathan Lange, Robert Collins)
-
-* Force flush of writes to stdout in c/tests/test_child.
-  (Jelmer Vernooij, #687611)
-
-* Provisional Python 3.x support.
-  (Robert Collins, Tres Seaver, Martin[gz], #666819)
-
-* ``subunit.chunked.Decoder`` Python class takes a new ``strict`` option,
-  which defaults to ``True``. When ``False``, the ``Decoder`` will accept
-  incorrect input that is still unambiguous. i.e. subunit will not barf if
-  a \r is missing from the input. (Martin Pool)
-
-* ``subunit-filter`` preserves the relative ordering of ``time:`` statements,
-  so you can now use filtered streams to gather data about how long it takes
-  to run a test. (Jonathan Lange, #716554)
-
-* ``subunit-ls`` now handles a stream with time: instructions that start
-  partway through the stream (which may lead to strange times) more gracefully.
-  (Robert Collins, #785954)
-
-* ``subunit-ls`` should handle the new test outcomes in Python2.7 better.
-  (Robert Collins, #785953)
-
-* ``TestResultFilter`` now collapses sequential calls to time().
-  (Jonathan Lange, #567150)
-
-* ``TestResultDecorator.tags()`` now actually works, and is no longer a buggy
-  copy/paste of ``TestResultDecorator.time()``. (Jonathan Lange, #681828)
-
-* ``TestResultFilter`` now supports a ``fixup_expected_failures``
-  argument. (Jelmer Vernooij, #755241)
-
-* The ``subunit.run`` Python module supports ``-l`` and ``--load-list`` as
-  per ``testtools.run``. This required a dependency bump due to a small
-  API change in ``testtools``. (Robert Collins)
-
-* The help for subunit-filter was confusing about the behaviour of ``-f`` /
-  ``--no-failure``. (Robert Collins, #703392)
-
-* The Python2.7 / testtools addUnexpectedSuccess API is now supported. This
-  required adding a new status code to the protocol. (Robert Collins, #654474)
-
-CHANGES
-~~~~~~~
-
-* testtools 0.9.11 or newer is new needed (due to the Python 3 support).
-  (Robert Collins)
-
-0.0.6
------
-
-This release of subunit fixes a number of unicode related bugs. This depends on
-testtools 0.9.4 and will not function without it. Thanks to Tres Seaver there
-is also an optional native setup.py file for use with easy_install and the
-like.
-
-BUG FIXES
-~~~~~~~~~
-
-* Be consistent about delivering unicode content to testtools StringException
-  class which has become (appropriately) conservative. (Robert Collins)
-
-* Fix incorrect reference to subunit_test_failf in c/README.
-  (Brad Hards, #524341)
-
-* Fix incorrect ordering of tags method parameters in TestResultDecorator. This
-  is purely cosmetic as the parameters are passed down with no interpretation.
-  (Robert Collins, #537611)
-
-* Old style tracebacks with no encoding info are now treated as UTF8 rather
-  than some-random-codec-like-ascii. (Robert Collins)
-
-* On windows, ProtocolTestCase and TestProtocolClient will set their streams to
-  binary mode by calling into msvcrt; this avoids having their input or output
-  mangled by the default line ending translation on that platform.
-  (Robert Collins, Martin [gz], #579296)
-
-IMPROVEMENTS
-~~~~~~~~~~~~
-
-* Subunit now has a setup.py for python deployments that are not using
-  distribution packages. (Tres Seaver, #538181)
-
-* Subunit now supports test discovery by building on the testtools support for
-  it. You can take advantage of it with "python -m subunit.run discover [path]"
-  and see "python -m subunit.run discover --help" for more options.
-
-* Subunit now uses the improved unicode support in testtools when outputting
-  non-details based test information; this should consistently UTF8 encode such
-  strings.
-
-* The Python TestProtocolClient now flushes output on startTest and stopTest.
-  (Martin [gz]).
-
-
-0.0.5
------
-
-BUG FIXES
-~~~~~~~~~
-
-* make check was failing if subunit wasn't installed due to a missing include
-  path for the test program test_child.
-
-* make distcheck was failing due to a missing $(top_srcdir) rune.
-
-IMPROVEMENTS
-~~~~~~~~~~~~
-
-* New filter `subunit-notify` that will show a notification window with test 
-  statistics when the test run finishes.
-
-* subunit.run will now pipe its output to the command in the 
-  SUBUNIT_FORMATTER environment variable, if set.
-
-0.0.4
------
-
-BUG FIXES
-~~~~~~~~~
-
-* subunit2junitxml -f required a value, this is now fixed and -f acts as a
-  boolean switch with no parameter.
-
-* Building with autoconf 2.65 is now supported.
-
-
-0.0.3
------
-
-  CHANGES:
-  
-    * License change, by unanimous agreement of contributors to BSD/Apache
-      License Version 2.0. This makes Subunit compatible with more testing
-      frameworks.
-
-  IMPROVEMENTS:
-
-    * CPPUnit is now directly supported: subunit builds a cppunit listener
-      ``libcppunit-subunit``. 
-
-    * In the python API ``addExpectedFailure`` and ``addUnexpectedSuccess``
-      from python 2.7/3.1 are now supported. ``addExpectedFailure`` is
-      serialised as ``xfail``, and ``addUnexpectedSuccess`` as ``success``.
-      The ``ProtocolTestCase`` parser now calls outcomes using an extended
-      API that permits attaching arbitrary MIME resources such as text files
-      log entries and so on. This extended API is being developed with the
-      Python testing community, and is in flux. ``TestResult`` objects that
-      do not support the API will be detected and transparently downgraded
-      back to the regular Python unittest API.
-
-    * INSTALLDIRS can be set to control the perl MakeMaker 'INSTALLDIRS'
-      viarable when installing.
-
-    * Multipart test outcomes are tentatively supported; the exact protocol
-      for them, both serialiser and object is not yet finalised. Testers and
-      early adopters are sought. As part of this and also in an attempt to
-      provider a more precise focus on the wire protocol and toolchain, 
-      Subunit now depends on testtools (http://launchpad.net/testtools)
-      release 0.9.0 or newer.
-
-    * subunit2junitxml supports a new option, --forward which causes it
-      to forward the raw subunit stream in a similar manner to tee. This
-      is used with the -o option to both write a xml report and get some
-      other subunit filter to process the stream.
-
-    * The C library now has ``subunit_test_skip``.
-
-  BUG FIXES:
-
-    * Install progress_model.py correctly.
-
-    * Non-gcc builds will no longer try to use gcc specific flags.
-      (Thanks trondn-norbye)
-
-  API CHANGES:
-
-  INTERNALS:
-
-0.0.2
------
-
-  CHANGES:
-
-  IMPROVEMENTS:
-
-    * A number of filters now support ``--no-passthrough`` to cause all
-      non-subunit content to be discarded. This is useful when precise control
-      over what is output is required - such as with subunit2junitxml.
-
-    * A small perl parser is now included, and a new ``subunit-diff`` tool
-      using that is included. (Jelmer Vernooij)
-
-    * Subunit streams can now include optional, incremental lookahead
-      information about progress. This allows reporters to make estimates
-      about completion, when such information is available. See the README
-      under ``progress`` for more details.
-
-    * ``subunit-filter`` now supports regex filtering via ``--with`` and
-      ``without`` options. (Martin Pool)
-
-    * ``subunit2gtk`` has been added, a filter that shows a GTK summary of a
-      test stream.
-
-    * ``subunit2pyunit`` has a --progress flag which will cause the bzrlib
-      test reporter to be used, which has a textual progress bar. This requires
-      a recent bzrlib as a minor bugfix was required in bzrlib to support this.
-
-    * ``subunit2junitxml`` has been added. This filter converts a subunit
-      stream to a single JUnit style XML stream using the pyjunitxml
-      python library.
-
-    * The shell functions support skipping via ``subunit_skip_test`` now.
-
-  BUG FIXES:
-
-    * ``xfail`` outcomes are now passed to python TestResult's via
-      addExpectedFailure if it is present on the TestResult. Python 2.6 and
-      earlier which do not have this function will have ``xfail`` outcomes
-      passed through as success outcomes as earlier versions of subunit did.
-
-  API CHANGES:
-
-    * tags are no longer passed around in python via the ``TestCase.tags``
-      attribute. Instead ``TestResult.tags(new_tags, gone_tags)`` is called,
-      and like in the protocol, if called while a test is active only applies
-      to that test. (Robert Collins)
-
-    * ``TestResultFilter`` takes a new optional constructor parameter 
-      ``filter_predicate``.  (Martin Pool)
-
-    * When a progress: directive is encountered in a subunit stream, the
-      python bindings now call the ``progress(offset, whence)`` method on
-      ``TestResult``.
-
-    * When a time: directive is encountered in a subunit stream, the python
-      bindings now call the ``time(seconds)`` method on ``TestResult``.
-
-  INTERNALS:
-
-    * (python) Added ``subunit.test_results.AutoTimingTestResultDecorator``. Most
-      users of subunit will want to wrap their ``TestProtocolClient`` objects
-      in this decorator to get test timing data for performance analysis.
-
-    * (python) ExecTestCase supports passing arguments to test scripts.
-
-    * (python) New helper ``subunit.test_results.HookedTestResultDecorator``
-      which can be used to call some code on every event, without having to
-      implement all the event methods.
-
-    * (python) ``TestProtocolClient.time(a_datetime)`` has been added which
-      causes a timestamp to be output to the stream.
diff --git a/lib/subunit/README b/lib/subunit/README
deleted file mode 100644
index 47a97345cd..0000000000
--- a/lib/subunit/README
+++ /dev/null
@@ -1,229 +0,0 @@
-
-  subunit: A streaming protocol for test results
-  Copyright (C) 2005-2009 Robert Collins <robertc@robertcollins.net>
-
-  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.
-
-  See the COPYING file for full details on the licensing of Subunit.
-
-  subunit reuses iso8601 by Michael Twomey, distributed under an MIT style
-  licence - see python/iso8601/LICENSE for details.
-
-Subunit
--------
-
-Subunit is a streaming protocol for test results. The protocol is human
-readable and easily generated and parsed. By design all the components of 
-the protocol conceptually fit into the xUnit TestCase->TestResult interaction.
-
-Subunit comes with command line filters to process a subunit stream and
-language bindings for python, C, C++ and shell. Bindings are easy to write
-for other languages.
-
-A number of useful things can be done easily with subunit:
- * Test aggregation: Tests run separately can be combined and then
-   reported/displayed together. For instance, tests from different languages
-   can be shown as a seamless whole.
- * Test archiving: A test run may be recorded and replayed later.
- * Test isolation: Tests that may crash or otherwise interact badly with each
-   other can be run separately and then aggregated, rather than interfering
-   with each other.
- * Grid testing: subunit can act as the necessary serialisation and
-   deserialiation to get test runs on distributed machines to be reported in
-   real time.
-
-Subunit supplies the following filters:
- * tap2subunit - convert perl's TestAnythingProtocol to subunit.
- * subunit2csv - convert a subunit stream to csv.
- * subunit2pyunit - convert a subunit stream to pyunit test results.
- * subunit2gtk - show a subunit stream in GTK.
- * subunit2junitxml - convert a subunit stream to JUnit's XML format.
- * subunit-diff - compare two subunit streams.
- * subunit-filter - filter out tests from a subunit stream.
- * subunit-ls - list info about tests present in a subunit stream.
- * subunit-stats - generate a summary of a subunit stream.
- * subunit-tags - add or remove tags from a stream.
-
-Integration with other tools
-----------------------------
-
-Subunit's language bindings act as integration with various test runners like
-'check', 'cppunit', Python's 'unittest'. Beyond that a small amount of glue
-(typically a few lines) will allow Subunit to be used in more sophisticated
-ways.
-
-Python
-======
-
-Subunit has excellent Python support: most of the filters and tools are written
-in python and there are facilities for using Subunit to increase test isolation
-seamlessly within a test suite.
-
-One simple way to run an existing python test suite and have it output subunit
-is the module ``subunit.run``::
-
-  $ python -m subunit.run mypackage.tests.test_suite
- 
-For more information on the Python support Subunit offers , please see
-``pydoc subunit``, or the source in ``python/subunit/__init__.py``
-
-C
-=
-
-Subunit has C bindings to emit the protocol, and comes with a patch for 'check'
-which has been nominally accepted by the 'check' developers. See 'c/README' for
-more details.
-
-C++
-===
-
-The C library is includable and usable directly from C++. A TestListener for
-CPPUnit is included in the Subunit distribution. See 'c++/README' for details.
-
-shell
-=====
-
-Similar to C, the shell bindings consist of simple functions to output protocol
-elements, and a patch for adding subunit output to the 'ShUnit' shell test
-runner. See 'shell/README' for details.
-
-Filter recipes
---------------
-
-To ignore some failing tests whose root cause is already known::
-
-  subunit-filter --without 'AttributeError.*flavor'
-
-
-The protocol
-------------
-
-Sample subunit wire contents
-----------------------------
-
-The following::
-  test: test foo works
-  success: test foo works.
-  test: tar a file.
-  failure: tar a file. [
-  ..
-   ]..  space is eaten.
-  foo.c:34 WARNING foo is not defined.
-  ]
-  a writeln to stdout
-
-When run through subunit2pyunit::
-  .F
-  a writeln to stdout
-
-  ========================
-  FAILURE: tar a file.
-  -------------------
-  ..
-  ]..  space is eaten.
-  foo.c:34 WARNING foo is not defined.
-
-
-Subunit protocol description
-============================
-
-This description is being ported to an EBNF style. Currently its only partly in
-that style, but should be fairly clear all the same. When in doubt, refer the
-source (and ideally help fix up the description!). Generally the protocol is
-line orientated and consists of either directives and their parameters, or
-when outside a DETAILS region unexpected lines which are not interpreted by
-the parser - they should be forwarded unaltered.
-
-test|testing|test:|testing: test LABEL
-success|success:|successful|successful: test LABEL
-success|success:|successful|successful: test LABEL DETAILS
-failure: test LABEL
-failure: test LABEL DETAILS
-error: test LABEL
-error: test LABEL DETAILS
-skip[:] test LABEL
-skip[:] test LABEL DETAILS
-xfail[:] test LABEL
-xfail[:] test LABEL DETAILS
-uxsuccess[:] test LABEL
-uxsuccess[:] test LABEL DETAILS
-progress: [+|-]X
-progress: push
-progress: pop
-tags: [-]TAG ...
-time: YYYY-MM-DD HH:MM:SSZ
-
-LABEL: UTF8*
-DETAILS ::= BRACKETED | MULTIPART
-BRACKETED ::= '[' CR UTF8-lines ']' CR
-MULTIPART ::= '[ multipart' CR PART* ']' CR
-PART ::= PART_TYPE CR NAME CR PART_BYTES CR
-PART_TYPE ::= Content-Type: type/sub-type(;parameter=value,parameter=value)
-PART_BYTES ::= (DIGITS CR LF BYTE{DIGITS})* '0' CR LF
-
-unexpected output on stdout -> stdout.
-exit w/0 or last test completing -> error
-
-Tags given outside a test are applied to all following tests
-Tags given after a test: line and before the result line for the same test
-apply only to that test, and inherit the current global tags.
-A '-' before a tag is used to remove tags - e.g. to prevent a global tag
-applying to a single test, or to cancel a global tag.
-
-The progress directive is used to provide progress information about a stream
-so that stream consumer can provide completion estimates, progress bars and so
-on. Stream generators that know how many tests will be present in the stream
-should output "progress: COUNT". Stream filters that add tests should output
-"progress: +COUNT", and those that remove tests should output
-"progress: -COUNT". An absolute count should reset the progress indicators in
-use - it indicates that two separate streams from different generators have
-been trivially concatenated together, and there is no knowledge of how many
-more complete streams are incoming. Smart concatenation could scan each stream
-for their count and sum them, or alternatively translate absolute counts into
-relative counts inline. It is recommended that outputters avoid absolute counts
-unless necessary. The push and pop directives are used to provide local regions
-for progress reporting. This fits with hierarchically operating test
-environments - such as those that organise tests into suites - the top-most
-runner can report on the number of suites, and each suite surround its output
-with a (push, pop) pair. Interpreters should interpret a pop as also advancing
-the progress of the restored level by one step. Encountering progress
-directives between the start and end of a test pair indicates that a previous
-test was interrupted and did not cleanly terminate: it should be implicitly
-closed with an error (the same as when a stream ends with no closing test
-directive for the most recently started test).
-
-The time directive acts as a clock event - it sets the time for all future
-events. The value should be a valid ISO8601 time.
-
-The skip, xfail and uxsuccess outcomes are not supported by all testing
-environments. In Python the testttools (https://launchpad.net/testtools)
-library is used to translate these automatically if an older Python version
-that does not support them is in use. See the testtools documentation for the
-translation policy.
-
-skip is used to indicate a test was discovered but not executed. xfail is used
-to indicate a test that errored in some expected fashion (also know as "TODO"
-tests in some frameworks). uxsuccess is used to indicate and unexpected success
-where a test though to be failing actually passes. It is complementary to
-xfail.
-
-Hacking on subunit
-------------------
-
-Releases
-========
-
-* Update versions in configure.ac and python/subunit/__init__.py.
-* Make PyPI and regular tarball releases. Upload the regular one to LP, the
-  PyPI one to PyPI.
-* Push a tagged commit.
-
diff --git a/lib/subunit/c++/README b/lib/subunit/c++/README
deleted file mode 100644
index 7b8184400e..0000000000
--- a/lib/subunit/c++/README
+++ /dev/null
@@ -1,50 +0,0 @@
-#
-#  subunit C++ bindings.
-#  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
-#
-#  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
-#
-
-Currently there are no native C++ bindings for subunit. However the C library
-can be used from C++ safely. A CPPUnit listener is built as part of Subunit to
-allow CPPUnit users to simply get Subunit output.
-
-To use the listener, use pkg-config (or your preferred replacement) to get the
-cflags and link settings from libcppunit_subunit.pc.
-
-In your test driver main, use SubunitTestProgressListener, as shown in this
-example main::
-
-  {
-    // Create the event manager and test controller
-    CPPUNIT_NS::TestResult controller;
-  
-    // Add a listener that collects test result
-    // so we can get the overall status.
-    // note this isn't needed for subunit...
-    CPPUNIT_NS::TestResultCollector result;
-    controller.addListener( &result );
-  
-    // Add a listener that print test activity in subunit format.
-    CPPUNIT_NS::SubunitTestProgressListener progress;
-    controller.addListener( &progress );
-  
-    // Add the top suite to the test runner
-    CPPUNIT_NS::TestRunner runner;
-    runner.addTest( CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest() );
-    runner.run( controller );
-  
-    return result.wasSuccessful() ? 0 : 1;
-  }
diff --git a/lib/subunit/c++/SubunitTestProgressListener.cpp b/lib/subunit/c++/SubunitTestProgressListener.cpp
deleted file mode 100644
index 76cd9e1194..0000000000
--- a/lib/subunit/c++/SubunitTestProgressListener.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-/*  Subunit test listener for cppunit (http://cppunit.sourceforge.net).
- *  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
- *
- *  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.
- */
-
-#include <cppunit/Exception.h>
-#include <cppunit/Test.h>
-#include <cppunit/TestFailure.h>
-#include <cppunit/TextOutputter.h>
-#include <iostream>
-
-// Have to be able to import the public interface without config.h.
-#include "SubunitTestProgressListener.h"
-#include "config.h"
-#include "subunit/child.h"
-
-
-CPPUNIT_NS_BEGIN
-
-
-void 
-SubunitTestProgressListener::startTest( Test *test )
-{
-  subunit_test_start(test->getName().c_str());
-  last_test_failed = false;
-}
-
-void 
-SubunitTestProgressListener::addFailure( const TestFailure &failure )
-{
-  std::ostringstream capture_stream;
-  TextOutputter outputter(NULL, capture_stream);
-  outputter.printFailureLocation(failure.sourceLine());
-  outputter.printFailureDetail(failure.thrownException());
-
-  if (failure.isError())
-      subunit_test_error(failure.failedTestName().c_str(),
-        		 capture_stream.str().c_str());
-  else
-      subunit_test_fail(failure.failedTestName().c_str(),
-                        capture_stream.str().c_str());
-  last_test_failed = true;
-}
-
-void 
-SubunitTestProgressListener::endTest( Test *test)
-{
-  if (!last_test_failed)
-      subunit_test_pass(test->getName().c_str());
-}
-
-
-CPPUNIT_NS_END
diff --git a/lib/subunit/c++/SubunitTestProgressListener.h b/lib/subunit/c++/SubunitTestProgressListener.h
deleted file mode 100644
index 5206d833c7..0000000000
--- a/lib/subunit/c++/SubunitTestProgressListener.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*  Subunit test listener for cppunit (http://cppunit.sourceforge.net).
- *  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
- *
- *  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.
- */
-#ifndef CPPUNIT_SUBUNITTESTPROGRESSLISTENER_H
-#define CPPUNIT_SUBUNITTESTPROGRESSLISTENER_H
-
-#include <cppunit/TestListener.h>
-
-
-CPPUNIT_NS_BEGIN
-
-
-/*! 
- * \brief TestListener that outputs subunit
- * (http://www.robertcollins.net/unittest/subunit) compatible output.
- * \ingroup TrackingTestExecution
- */
-class CPPUNIT_API SubunitTestProgressListener : public TestListener
-{
-public:
- 
-  SubunitTestProgressListener() {}
-  
-  void startTest( Test *test );
-
-  void addFailure( const TestFailure &failure );
-
-  void endTest( Test *test );
-
-private:
-  /// Prevents the use of the copy constructor.
-  SubunitTestProgressListener( const SubunitTestProgressListener &copy );
-
-  /// Prevents the use of the copy operator.
-  void operator =( const SubunitTestProgressListener &copy );
-
-private:
-  int last_test_failed;
-};
-
-
-CPPUNIT_NS_END
-
-#endif  // CPPUNIT_SUBUNITTESTPROGRESSLISTENER_H
-
diff --git a/lib/subunit/c/README b/lib/subunit/c/README
deleted file mode 100644
index b62fd45395..0000000000
--- a/lib/subunit/c/README
+++ /dev/null
@@ -1,68 +0,0 @@
-#
-#  subunit C bindings.
-#  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-
-This subtree contains an implementation of the subunit child protocol.
-Currently I have no plans to write a test runner in C, so I have not written
-an implementation of the parent protocol. [but will happily accept patches].
-This implementation is built using SCons and tested via 'check'.
-See the tests/ directory for the test programs.
-You can use `make check` or `scons check` to run the tests. 
-
-The C protocol consists of four functions which you can use to output test
-metadata trivially. See lib/subunit_child.[ch] for details.
-
-However, this is not a test runner - subunit provides no support for [for
-instance] managing assertions, cleaning up on errors etc. You can look at
-'check' (http://check.sourceforge.net/) or
-'gunit' (https://garage.maemo.org/projects/gunit) for C unit test
-frameworks. 
-There is a patch for 'check' (check-subunit-*.patch) in this source tree.
-Its also available as request ID #1470750 in the sourceforge request tracker
-http://sourceforge.net/tracker/index.php. The 'check' developers have indicated
-they will merge this during the current release cycle.
-
-If you are a test environment maintainer - either homegrown, or 'check' or
-'gunit' or some other, you will to know how the subunit calls should be used.
-Here is what a manually written test using the bindings might look like:
-
-
-void
-a_test(void) {
-  int result;
-  subunit_test_start("test name");
-  # determine if test passes or fails
-  result = SOME_VALUE;
-  if (!result) {
-    subunit_test_pass("test name");
-  } else {
-    subunit_test_fail("test name",
-      "Something went wrong running something:\n"
-      "exited with result: '%s'", result);
-  }
-}
-
-Which when run with a subunit test runner will generate something like:
-test name ... ok
-
-on success, and:
-
-test name ... FAIL
-
-======================================================================
-FAIL: test name
-----------------------------------------------------------------------
-RemoteError:
-Something went wrong running something:
-exited with result: '1'
diff --git a/lib/subunit/c/include/subunit/child.h b/lib/subunit/c/include/subunit/child.h
deleted file mode 100644
index 896d2dfad0..0000000000
--- a/lib/subunit/c/include/subunit/child.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- *
- *  subunit C bindings.
- *  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
- *
- *  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.
- **/
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * subunit_test_start:
- *
- * Report that a test is starting.
- * @name: test case name
- */
-extern void subunit_test_start(char const * const name);
-
-
-/**
- * subunit_test_pass:
- *
- * Report that a test has passed.
- *
- * @name: test case name
- */
-extern void subunit_test_pass(char const * const name);
-
-
-/**
- * subunit_test_fail:
- *
- * Report that a test has failed.
- * @name: test case name
- * @error: a string describing the error.
- */
-extern void subunit_test_fail(char const * const name, char const * const error);
-
-
-/**
- * subunit_test_error:
- *
- * Report that a test has errored. An error is an unintentional failure - i.e.
- * a segfault rather than a failed assertion.
- * @name: test case name
- * @error: a string describing the error.
- */
-extern void subunit_test_error(char const * const name,
-                               char const * const error);
-
-
-/**
- * subunit_test_skip:
- *
- * Report that a test has been skipped. An skip is a test that has not run to
- * conclusion but hasn't given an error either - its result is unknown.
- * @name: test case name
- * @reason: a string describing the reason for the skip.
- */
-extern void subunit_test_skip(char const * const name, 
-			      char const * const reason);
-
-
-enum subunit_progress_whence {
-	SUBUNIT_PROGRESS_SET,
-	SUBUNIT_PROGRESS_CUR,
-	SUBUNIT_PROGRESS_POP,
-	SUBUNIT_PROGRESS_PUSH,
-};
-
-/**
- * subunit_progress:
- *
- * Report the progress of a test run.
- * @whence: The type of progress update to report.
- * @offset: Offset of the progress (only for SUBUNIT_PROGRESS_SET
- * 			and SUBUNIT_PROGRESS_CUR).
- */
-extern void subunit_progress(enum subunit_progress_whence whence, int offset);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/lib/subunit/c/lib/child.c b/lib/subunit/c/lib/child.c
deleted file mode 100644
index 20f38da8c9..0000000000
--- a/lib/subunit/c/lib/child.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- *
- *  subunit C child-side bindings: report on tests being run.
- *  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
- *
- *  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.
- **/
-
-#include <stdio.h>
-#include <string.h>
-#include "subunit/child.h"
-
-/* Write details about a test event. It is the callers responsibility to ensure
- * that details are only provided for events the protocol expects details on.
- * @event: The event - e.g. 'skip'
- * @name: The test name/id.
- * @details: The details of the event, may be NULL if no details are present.
- */
-static void
-subunit_send_event(char const * const event, char const * const name,
-		   char const * const details)
-{
-  if (NULL == details) {
-    fprintf(stdout, "%s: %s\n", event, name);
-  } else {
-    fprintf(stdout, "%s: %s [\n", event, name);
-    fprintf(stdout, "%s", details);
-    if (details[strlen(details) - 1] != '\n')
-      fprintf(stdout, "\n");
-    fprintf(stdout, "]\n");
-  }
-  fflush(stdout);
-}
-
-/* these functions all flush to ensure that the test runner knows the action
- * that has been taken even if the subsequent test etc takes a long time or
- * never completes (i.e. a segfault).
- */
-
-void
-subunit_test_start(char const * const name)
-{
-  subunit_send_event("test", name, NULL);
-}
-
-
-void
-subunit_test_pass(char const * const name)
-{
-  /* TODO: add success details as an option */
-  subunit_send_event("success", name, NULL);
-}
-
-
-void
-subunit_test_fail(char const * const name, char const * const error)
-{
-  subunit_send_event("failure", name, error);
-}
-
-
-void
-subunit_test_error(char const * const name, char const * const error)
-{
-  subunit_send_event("error", name, error);
-}
-
-
-void
-subunit_test_skip(char const * const name, char const * const reason)
-{
-  subunit_send_event("skip", name, reason);
-}
-
-void
-subunit_progress(enum subunit_progress_whence whence, int offset)
-{
-	switch (whence) {
-	case SUBUNIT_PROGRESS_SET:
-		printf("progress: %d\n", offset);
-		break;
-	case SUBUNIT_PROGRESS_CUR:
-		printf("progress: %+-d\n", offset);
-		break;
-	case SUBUNIT_PROGRESS_POP:
-		printf("progress: pop\n");
-		break;
-	case SUBUNIT_PROGRESS_PUSH:
-		printf("progress: push\n");
-		break;
-	default:
-		fprintf(stderr, "Invalid whence %d in subunit_progress()\n", whence);
-		break;
-	}
-}
diff --git a/lib/subunit/c/tests/test_child.c b/lib/subunit/c/tests/test_child.c
deleted file mode 100644
index 1318322ab2..0000000000
--- a/lib/subunit/c/tests/test_child.c
+++ /dev/null
@@ -1,234 +0,0 @@
-/**
- *
- *  subunit C bindings.
- *  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
- *
- *  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.
- **/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-#include <check.h>
-
-#include "subunit/child.h"
-
-/**
- * Helper function to capture stdout, run some call, and check what
- * was written.
- * @expected the expected stdout content
- * @function the function to call.
- **/
-static void
-test_stdout_function(char const * expected,
-                     void (*function)(void))
-{
-    /* test that the start function emits a correct test: line. */
-    int bytecount;
-    int old_stdout;
-    int new_stdout[2];
-    char buffer[100];
-    /* we need a socketpair to capture stdout in */
-    fail_if(pipe(new_stdout), "Failed to create a socketpair.");
-    /* backup stdout so we can replace it */
-    old_stdout = dup(1);
-    if (old_stdout == -1) {
-      close(new_stdout[0]);
-      close(new_stdout[1]);
-      fail("Failed to backup stdout before replacing.");
-    }
-    /* redirect stdout so we can analyse it */
-    if (dup2(new_stdout[1], 1) != 1) {
-      close(old_stdout);
-      close(new_stdout[0]);
-      close(new_stdout[1]);
-      fail("Failed to redirect stdout");
-    }
-    /* yes this can block. Its a test case with < 100 bytes of output.
-     * DEAL.
-     */
-    function();
-    /* flush writes on FILE object to file descriptor */
-    fflush(stdout);
-    /* restore stdout now */
-    if (dup2(old_stdout, 1) != 1) {
-      close(old_stdout);
-      close(new_stdout[0]);
-      close(new_stdout[1]);
-      fail("Failed to restore stdout");
-    }
-    /* and we dont need the write side any more */
-    if (close(new_stdout[1])) {
-      close(new_stdout[0]);
-      fail("Failed to close write side of socketpair.");
-    }
-    /* get the output */
-    bytecount = read(new_stdout[0], buffer, 100);
-    if (0 > bytecount) {
-      close(new_stdout[0]);
-      fail("Failed to read captured output.");
-    }
-    buffer[bytecount]='\0';
-    /* and we dont need the read side any more */
-    fail_if(close(new_stdout[0]), "Failed to close write side of socketpair.");
-    /* compare with expected outcome */
-    fail_if(strcmp(expected, buffer), "Did not get expected output [%s], got [%s]", expected, buffer);
-}
-
-
-static void
-call_test_start(void)
-{
-    subunit_test_start("test case");
-}
-
-
-START_TEST (test_start)
-{
-    test_stdout_function("test: test case\n", call_test_start);
-}
-END_TEST
-
-
-static void
-call_test_pass(void)
-{
-    subunit_test_pass("test case");
-}
-
-
-START_TEST (test_pass)
-{
-    test_stdout_function("success: test case\n", call_test_pass);
-}
-END_TEST
-
-
-static void
-call_test_fail(void)
-{
-    subunit_test_fail("test case", "Multiple lines\n of error\n");
-}
-
-
-START_TEST (test_fail)
-{
-    test_stdout_function("failure: test case [\n"
-                         "Multiple lines\n"
-        		 " of error\n"
-			 "]\n",
-			 call_test_fail);
-}
-END_TEST
-
-
-static void
-call_test_error(void)
-{
-    subunit_test_error("test case", "Multiple lines\n of output\n");
-}
-
-
-START_TEST (test_error)
-{
-    test_stdout_function("error: test case [\n"
-                         "Multiple lines\n"
-        		 " of output\n"
-			 "]\n",
-			 call_test_error);
-}
-END_TEST
-
-
-static void
-call_test_skip(void)
-{
-    subunit_test_skip("test case", "Multiple lines\n of output\n");
-}
-
-
-START_TEST (test_skip)
-{
-    test_stdout_function("skip: test case [\n"
-                         "Multiple lines\n"
-        		 " of output\n"
-			 "]\n",
-			 call_test_skip);
-}
-END_TEST
-
-
-static void
-call_test_progress_pop(void)
-{
-	subunit_progress(SUBUNIT_PROGRESS_POP, 0);
-}
-
-static void
-call_test_progress_set(void)
-{
-	subunit_progress(SUBUNIT_PROGRESS_SET, 5);
-}
-
-static void
-call_test_progress_push(void)
-{
-	subunit_progress(SUBUNIT_PROGRESS_PUSH, 0);
-}
-
-static void
-call_test_progress_cur(void)
-{
-	subunit_progress(SUBUNIT_PROGRESS_CUR, -6);
-}
-
-START_TEST (test_progress)
-{
-	test_stdout_function("progress: pop\n",
-			 call_test_progress_pop);
-	test_stdout_function("progress: push\n",
-			 call_test_progress_push);
-	test_stdout_function("progress: 5\n",
-			 call_test_progress_set);
-	test_stdout_function("progress: -6\n",
-			 call_test_progress_cur);
-}
-END_TEST
-
-static Suite *
-child_suite(void)
-{
-    Suite *s = suite_create("subunit_child");
-    TCase *tc_core = tcase_create("Core");
-    suite_add_tcase (s, tc_core);
-    tcase_add_test (tc_core, test_start);
-    tcase_add_test (tc_core, test_pass);
-    tcase_add_test (tc_core, test_fail);
-    tcase_add_test (tc_core, test_error);
-    tcase_add_test (tc_core, test_skip);
-    tcase_add_test (tc_core, test_progress);
-    return s;
-}
-
-
-int
-main(void)
-{
-  int nf;
-  Suite *s = child_suite();
-  SRunner *sr = srunner_create(s);
-  srunner_run_all(sr, CK_NORMAL);
-  nf = srunner_ntests_failed(sr);
-  srunner_free(sr);
-  return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
diff --git a/lib/subunit/configure.ac b/lib/subunit/configure.ac
deleted file mode 100644
index cf21d55480..0000000000
--- a/lib/subunit/configure.ac
+++ /dev/null
@@ -1,75 +0,0 @@
-m4_define([SUBUNIT_MAJOR_VERSION], [0])
-m4_define([SUBUNIT_MINOR_VERSION], [0])
-m4_define([SUBUNIT_MICRO_VERSION], [9])
-m4_define([SUBUNIT_VERSION],
-m4_defn([SUBUNIT_MAJOR_VERSION]).m4_defn([SUBUNIT_MINOR_VERSION]).m4_defn([SUBUNIT_MICRO_VERSION]))
-AC_PREREQ([2.59])
-AC_INIT([subunit], [SUBUNIT_VERSION], [subunit-dev@lists.launchpad.net])
-AC_CONFIG_SRCDIR([c/lib/child.c])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects])
-AC_CONFIG_MACRO_DIR([m4])
-[SUBUNIT_MAJOR_VERSION]=SUBUNIT_MAJOR_VERSION
-[SUBUNIT_MINOR_VERSION]=SUBUNIT_MINOR_VERSION
-[SUBUNIT_MICRO_VERSION]=SUBUNIT_MICRO_VERSION
-[SUBUNIT_VERSION]=SUBUNIT_VERSION
-AC_SUBST([SUBUNIT_MAJOR_VERSION])
-AC_SUBST([SUBUNIT_MINOR_VERSION])
-AC_SUBST([SUBUNIT_MICRO_VERSION])
-AC_SUBST([SUBUNIT_VERSION])
-AC_USE_SYSTEM_EXTENSIONS
-AC_PROG_CC
-AC_PROG_CXX
-AM_PROG_CC_C_O
-AC_PROG_INSTALL
-AC_PROG_LN_S
-AC_PROG_LIBTOOL
-AM_PATH_PYTHON
-
-AS_IF([test "$GCC" = "yes"],
-      [
-  SUBUNIT_CFLAGS="-Wall -Werror -Wextra -Wstrict-prototypes "
-  SUBUNIT_CFLAGS="$SUBUNIT_CFLAGS -Wmissing-prototypes -Wwrite-strings "
-  SUBUNIT_CFLAGS="$SUBUNIT_CFLAGS -Wno-variadic-macros "
-  SUBUNIT_CXXFLAGS="-Wall -Werror -Wextra -Wwrite-strings -Wno-variadic-macros"
-      ])
-
-AM_CFLAGS="$SUBUNIT_CFLAGS -I\$(top_srcdir)/c/include"
-AM_CXXFLAGS="$SUBUNIT_CXXFLAGS -I\$(top_srcdir)/c/include"
-AC_SUBST(AM_CFLAGS)
-AC_SUBST(AM_CXXFLAGS)
-
-# Checks for libraries.
-
-# Checks for header files.
-AC_CHECK_HEADERS([stdlib.h])
-
-# Checks for typedefs, structures, and compiler characteristics.
-AC_C_CONST
-AC_TYPE_PID_T
-AC_TYPE_SIZE_T
-AC_HEADER_TIME
-AC_STRUCT_TM
-
-AC_CHECK_SIZEOF(int, 4)
-AC_CHECK_SIZEOF(short, 2)
-AC_CHECK_SIZEOF(long, 4)
-
-# Checks for library functions.
-AC_FUNC_MALLOC
-AC_FUNC_REALLOC
-
-# Easier memory management.
-# C unit testing.
-PKG_CHECK_MODULES([CHECK], [check >= 0.9.4])
-# C++ unit testing.
-PKG_CHECK_MODULES([CPPUNIT], [cppunit])
-
-# Output files
-AC_CONFIG_HEADERS([config.h])
-
-AC_CONFIG_FILES([libsubunit.pc
-		 libcppunit_subunit.pc
-                 Makefile
-		 perl/Makefile.PL
-                 ])
-AC_OUTPUT
diff --git a/lib/subunit/filters/subunit-filter b/lib/subunit/filters/subunit-filter
deleted file mode 100755
index 6a1ecc9a01..0000000000
--- a/lib/subunit/filters/subunit-filter
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2008  Robert Collins <robertc@robertcollins.net>
-#            (C) 2009  Martin Pool
-#
-#  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.
-#
-
-"""Filter a subunit stream to include/exclude tests.
-
-The default is to strip successful tests.
-
-Tests can be filtered by Python regular expressions with --with and --without,
-which match both the test name and the error text (if any).  The result
-contains tests which match any of the --with expressions and none of the
---without expressions.  For case-insensitive matching prepend '(?i)'.
-Remember to quote shell metacharacters.
-"""
-
-from optparse import OptionParser
-import sys
-import re
-
-from subunit import (
-    DiscardStream,
-    ProtocolTestCase,
-    TestProtocolClient,
-    read_test_list,
-    )
-from subunit.filters import filter_by_result
-from subunit.test_results import (
-    and_predicates,
-    make_tag_filter,
-    TestResultFilter,
-    )
-
-
-def make_options(description):
-    parser = OptionParser(description=__doc__)
-    parser.add_option("--error", action="store_false",
-        help="include errors", default=False, dest="error")
-    parser.add_option("-e", "--no-error", action="store_true",
-        help="exclude errors", dest="error")
-    parser.add_option("--failure", action="store_false",
-        help="include failures", default=False, dest="failure")
-    parser.add_option("-f", "--no-failure", action="store_true",
-        help="exclude failures", dest="failure")
-    parser.add_option("--passthrough", action="store_false",
-        help="Show all non subunit input.", default=False, dest="no_passthrough")
-    parser.add_option("--no-passthrough", action="store_true",
-        help="Hide all non subunit input.", default=False, dest="no_passthrough")
-    parser.add_option("-s", "--success", action="store_false",
-        help="include successes", dest="success")
-    parser.add_option("--no-success", action="store_true",
-        help="exclude successes", default=True, dest="success")
-    parser.add_option("--no-skip", action="store_true",
-        help="exclude skips", dest="skip")
-    parser.add_option("--xfail", action="store_false",
-        help="include expected falures", default=True, dest="xfail")
-    parser.add_option("--no-xfail", action="store_true",
-        help="exclude expected falures", default=True, dest="xfail")
-    parser.add_option(
-        "--with-tag", type=str,
-        help="include tests with these tags", action="append", dest="with_tags")
-    parser.add_option(
-        "--without-tag", type=str,
-        help="exclude tests with these tags", action="append", dest="without_tags")
-    parser.add_option("-m", "--with", type=str,
-        help="regexp to include (case-sensitive by default)",
-        action="append", dest="with_regexps")
-    parser.add_option("--fixup-expected-failures", type=str,
-        help="File with list of test ids that are expected to fail; on failure "
-             "their result will be changed to xfail; on success they will be "
-             "changed to error.", dest="fixup_expected_failures", action="append")
-    parser.add_option("--without", type=str,
-        help="regexp to exclude (case-sensitive by default)",
-        action="append", dest="without_regexps")
-    parser.add_option("-F", "--only-genuine-failures", action="callback",
-        callback=only_genuine_failures_callback,
-        help="Only pass through failures and exceptions.")
-    return parser
-
-
-def only_genuine_failures_callback(option, opt, value, parser):
-    parser.rargs.insert(0, '--no-passthrough')
-    parser.rargs.insert(0, '--no-xfail')
-    parser.rargs.insert(0, '--no-skip')
-    parser.rargs.insert(0, '--no-success')
-
-
-def _compile_re_from_list(l):
-    return re.compile("|".join(l), re.MULTILINE)
-
-
-def _make_regexp_filter(with_regexps, without_regexps):
-    """Make a callback that checks tests against regexps.
-
-    with_regexps and without_regexps are each either a list of regexp strings,
-    or None.
-    """
-    with_re = with_regexps and _compile_re_from_list(with_regexps)
-    without_re = without_regexps and _compile_re_from_list(without_regexps)
-
-    def check_regexps(test, outcome, err, details, tags):
-        """Check if this test and error match the regexp filters."""
-        test_str = str(test) + outcome + str(err) + str(details)
-        if with_re and not with_re.search(test_str):
-            return False
-        if without_re and without_re.search(test_str):
-            return False
-        return True
-    return check_regexps
-
-
-def _make_result(output, options, predicate):
-    """Make the result that we'll send the test outcomes to."""
-    fixup_expected_failures = set()
-    for path in options.fixup_expected_failures or ():
-        fixup_expected_failures.update(read_test_list(path))
-    return TestResultFilter(
-        TestProtocolClient(output),
-        filter_error=options.error,
-        filter_failure=options.failure,
-        filter_success=options.success,
-        filter_skip=options.skip,
-        filter_xfail=options.xfail,
-        filter_predicate=predicate,
-        fixup_expected_failures=fixup_expected_failures)
-
-
-def main():
-    parser = make_options(__doc__)
-    (options, args) = parser.parse_args()
-
-    regexp_filter = _make_regexp_filter(
-        options.with_regexps, options.without_regexps)
-    tag_filter = make_tag_filter(options.with_tags, options.without_tags)
-    filter_predicate = and_predicates([regexp_filter, tag_filter])
-
-    filter_by_result(
-        lambda output_to: _make_result(sys.stdout, options, filter_predicate),
-        output_path=None,
-        passthrough=(not options.no_passthrough),
-        forward=False)
-    sys.exit(0)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/lib/subunit/filters/subunit-ls b/lib/subunit/filters/subunit-ls
deleted file mode 100755
index 82db4c371a..0000000000
--- a/lib/subunit/filters/subunit-ls
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2008  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-"""List tests in a subunit stream."""
-
-from optparse import OptionParser
-import sys
-
-from subunit import DiscardStream, ProtocolTestCase
-from subunit.test_results import (
-    AutoTimingTestResultDecorator,
-    TestIdPrintingResult,
-    )
-
-
-parser = OptionParser(description=__doc__)
-parser.add_option("--times", action="store_true",
-    help="list the time each test took (requires a timestamped stream)",
-        default=False)
-parser.add_option("--no-passthrough", action="store_true",
-    help="Hide all non subunit input.", default=False, dest="no_passthrough")
-(options, args) = parser.parse_args()
-result = AutoTimingTestResultDecorator(
-    TestIdPrintingResult(sys.stdout, options.times))
-if options.no_passthrough:
-    passthrough_stream = DiscardStream()
-else:
-    passthrough_stream = None
-test = ProtocolTestCase(sys.stdin, passthrough=passthrough_stream)
-test.run(result)
-if result.wasSuccessful():
-    exit_code = 0
-else:
-    exit_code = 1
-sys.exit(exit_code)
diff --git a/lib/subunit/filters/subunit-notify b/lib/subunit/filters/subunit-notify
deleted file mode 100755
index 8cce2d1609..0000000000
--- a/lib/subunit/filters/subunit-notify
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2010 Jelmer Vernooij <jelmer@samba.org>
-#
-#  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.
-#
-
-"""Notify the user of a finished test run."""
-
-import pygtk
-pygtk.require('2.0')
-import pynotify
-
-from subunit import TestResultStats
-from subunit.filters import run_filter_script
-
-if not pynotify.init("Subunit-notify"):
-    sys.exit(1)
-
-
-def notify_of_result(result):
-    if result.failed_tests > 0:
-        summary = "Test run failed"
-    else:
-        summary = "Test run successful"
-    body = "Total tests: %d; Passed: %d; Failed: %d" % (
-        result.total_tests,
-        result.passed_tests,
-        result.failed_tests,
-    )
-    nw = pynotify.Notification(summary, body)
-    nw.show()
-
-
-run_filter_script(TestResultStats, __doc__, notify_of_result)
diff --git a/lib/subunit/filters/subunit-stats b/lib/subunit/filters/subunit-stats
deleted file mode 100755
index 4734988fc2..0000000000
--- a/lib/subunit/filters/subunit-stats
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-"""Filter a subunit stream to get aggregate statistics."""
-
-from optparse import OptionParser
-import sys
-import unittest
-
-from subunit import DiscardStream, ProtocolTestCase, TestResultStats
-
-parser = OptionParser(description=__doc__)
-parser.add_option("--no-passthrough", action="store_true",
-    help="Hide all non subunit input.", default=False, dest="no_passthrough")
-(options, args) = parser.parse_args()
-result = TestResultStats(sys.stdout)
-if options.no_passthrough:
-    passthrough_stream = DiscardStream()
-else:
-    passthrough_stream = None
-test = ProtocolTestCase(sys.stdin, passthrough=passthrough_stream)
-test.run(result)
-result.formatStats()
-if result.wasSuccessful():
-    exit_code = 0
-else:
-    exit_code = 1
-sys.exit(exit_code)
diff --git a/lib/subunit/filters/subunit-tags b/lib/subunit/filters/subunit-tags
deleted file mode 100755
index edbbfce480..0000000000
--- a/lib/subunit/filters/subunit-tags
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-"""A filter to change tags on a subunit stream.
-
-subunit-tags foo -> adds foo
-subunit-tags foo -bar -> adds foo and removes bar
-"""
-
-import sys
-
-from subunit import tag_stream
-sys.exit(tag_stream(sys.stdin, sys.stdout, sys.argv[1:]))
diff --git a/lib/subunit/filters/subunit2csv b/lib/subunit/filters/subunit2csv
deleted file mode 100755
index 14620ff674..0000000000
--- a/lib/subunit/filters/subunit2csv
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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 d 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.
-#
-
-"""Turn a subunit stream into a CSV"""
-
-from subunit.filters import run_filter_script
-from subunit.test_results import CsvResult
-
-
-run_filter_script(CsvResult, __doc__)
diff --git a/lib/subunit/filters/subunit2gtk b/lib/subunit/filters/subunit2gtk
deleted file mode 100755
index c2cb2de3ce..0000000000
--- a/lib/subunit/filters/subunit2gtk
+++ /dev/null
@@ -1,259 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-### The GTK progress bar __init__ function is derived from the pygtk tutorial:
-# The PyGTK Tutorial is Copyright (C) 2001-2005 John Finlay.
-# 
-# The GTK Tutorial is Copyright (C) 1997 Ian Main.
-# 
-# Copyright (C) 1998-1999 Tony Gale.
-# 
-# Permission is granted to make and distribute verbatim copies of this manual
-# provided the copyright notice and this permission notice are preserved on all
-# copies.
-# 
-# Permission is granted to copy and distribute modified versions of this
-# document under the conditions for verbatim copying, provided that this
-# copyright notice is included exactly as in the original, and that the entire
-# resulting derived work is distributed under the terms of a permission notice
-# identical to this one.
-# 
-# Permission is granted to copy and distribute translations of this document
-# into another language, under the above conditions for modified versions.
-# 
-# If you are intending to incorporate this document into a published work,
-# please contact the maintainer, and we will make an effort to ensure that you
-# have the most up to date information available.
-# 
-# There is no guarantee that this document lives up to its intended purpose.
-# This is simply provided as a free resource. As such, the authors and
-# maintainers of the information provided within can not make any guarantee
-# that the information is even accurate.
-
-"""Display a subunit stream in a gtk progress window."""
-
-import sys
-import unittest
-
-import pygtk
-pygtk.require('2.0')
-import gtk, gtk.gdk, gobject
-
-from subunit import (
-    PROGRESS_POP,
-    PROGRESS_PUSH,
-    PROGRESS_SET,
-    TestProtocolServer,
-    )
-from subunit.progress_model import  ProgressModel
-
-
-class GTKTestResult(unittest.TestResult):
-
-    def __init__(self):
-        super(GTKTestResult, self).__init__()
-        # Instance variables (in addition to TestResult)
-        self.window = None
-        self.run_label = None
-        self.ok_label = None
-        self.not_ok_label = None
-        self.total_tests = None
-
-        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
-        self.window.set_resizable(True)
-
-        self.window.connect("destroy", gtk.main_quit)
-        self.window.set_title("Tests...")
-        self.window.set_border_width(0)
-
-        vbox = gtk.VBox(False, 5)
-        vbox.set_border_width(10)
-        self.window.add(vbox)
-        vbox.show()
-
-        # Create a centering alignment object
-        align = gtk.Alignment(0.5, 0.5, 0, 0)
-        vbox.pack_start(align, False, False, 5)
-        align.show()
-
-        # Create the ProgressBar
-        self.pbar = gtk.ProgressBar()
-        align.add(self.pbar)
-        self.pbar.set_text("Running")
-        self.pbar.show()
-        self.progress_model = ProgressModel()
-
-        separator = gtk.HSeparator()
-        vbox.pack_start(separator, False, False, 0)
-        separator.show()
-
-        # rows, columns, homogeneous
-        table = gtk.Table(2, 3, False)
-        vbox.pack_start(table, False, True, 0)
-        table.show()
-        # Show summary details about the run. Could use an expander.
-        label = gtk.Label("Run:")
-        table.attach(label, 0, 1, 1, 2, gtk.EXPAND | gtk.FILL,
-            gtk.EXPAND | gtk.FILL, 5, 5)
-        label.show()
-        self.run_label = gtk.Label("N/A")
-        table.attach(self.run_label, 1, 2, 1, 2, gtk.EXPAND | gtk.FILL,
-            gtk.EXPAND | gtk.FILL, 5, 5)
-        self.run_label.show()
-
-        label = gtk.Label("OK:")
-        table.attach(label, 0, 1, 2, 3, gtk.EXPAND | gtk.FILL,
-            gtk.EXPAND | gtk.FILL, 5, 5)
-        label.show()
-        self.ok_label = gtk.Label("N/A")
-        table.attach(self.ok_label, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL,
-            gtk.EXPAND | gtk.FILL, 5, 5)
-        self.ok_label.show()
-
-        label = gtk.Label("Not OK:")
-        table.attach(label, 0, 1, 3, 4, gtk.EXPAND | gtk.FILL,
-            gtk.EXPAND | gtk.FILL, 5, 5)
-        label.show()
-        self.not_ok_label = gtk.Label("N/A")
-        table.attach(self.not_ok_label, 1, 2, 3, 4, gtk.EXPAND | gtk.FILL,
-            gtk.EXPAND | gtk.FILL, 5, 5)
-        self.not_ok_label.show()
-
-        self.window.show()
-        # For the demo.
-        self.window.set_keep_above(True)
-        self.window.present()
-
-    def stopTest(self, test):
-        super(GTKTestResult, self).stopTest(test)
-        self.progress_model.advance()
-        if self.progress_model.width() == 0:
-            self.pbar.pulse()
-        else:
-            pos = self.progress_model.pos()
-            width = self.progress_model.width()
-            percentage = (pos / float(width))
-            self.pbar.set_fraction(percentage)
-
-    def stopTestRun(self):
-        try:
-            super(GTKTestResult, self).stopTestRun()
-        except AttributeError:
-            pass
-        self.pbar.set_text('Finished')
-
-    def addError(self, test, err):
-        super(GTKTestResult, self).addError(test, err)
-        self.update_counts()
-
-    def addFailure(self, test, err):
-        super(GTKTestResult, self).addFailure(test, err)
-        self.update_counts()
-
-    def addSuccess(self, test):
-        super(GTKTestResult, self).addSuccess(test)
-        self.update_counts()
-
-    def addSkip(self, test, reason):
-        # addSkip is new in Python 2.7/3.1
-        addSkip = getattr(super(GTKTestResult, self), 'addSkip', None)
-        if callable(addSkip):
-            addSkip(test, reason)
-        self.update_counts()
-
-    def addExpectedFailure(self, test, err):
-        # addExpectedFailure is new in Python 2.7/3.1
-        addExpectedFailure = getattr(super(GTKTestResult, self),
-            'addExpectedFailure', None)
-        if callable(addExpectedFailure):
-            addExpectedFailure(test, err)
-        self.update_counts()
-
-    def addUnexpectedSuccess(self, test):
-        # addUnexpectedSuccess is new in Python 2.7/3.1
-        addUnexpectedSuccess = getattr(super(GTKTestResult, self),
-            'addUnexpectedSuccess', None)
-        if callable(addUnexpectedSuccess):
-            addUnexpectedSuccess(test)
-        self.update_counts()
-
-    def progress(self, offset, whence):
-        if whence == PROGRESS_PUSH:
-            self.progress_model.push()
-        elif whence == PROGRESS_POP:
-            self.progress_model.pop()
-        elif whence == PROGRESS_SET:
-            self.total_tests = offset
-            self.progress_model.set_width(offset)
-        else:
-            self.total_tests += offset
-            self.progress_model.adjust_width(offset)
-
-    def time(self, a_datetime):
-        # We don't try to estimate completion yet.
-        pass
-
-    def update_counts(self):
-        self.run_label.set_text(str(self.testsRun))
-        bad = len(self.failures + self.errors)
-        self.ok_label.set_text(str(self.testsRun - bad))
-        self.not_ok_label.set_text(str(bad))
-
-
-class GIOProtocolTestCase(object):
-
-    def __init__(self, stream, result, on_finish):
-        self.stream = stream
-        self.schedule_read()
-        self.hup_id = gobject.io_add_watch(stream, gobject.IO_HUP, self.hup)
-        self.protocol = TestProtocolServer(result)
-        self.on_finish = on_finish
-
-    def read(self, source, condition, all=False):
-        #NB: \o/ actually blocks
-        line = source.readline()
-        if not line:
-            self.protocol.lostConnection()
-            self.on_finish()
-            return False
-        self.protocol.lineReceived(line)
-        # schedule more IO shortly - if we say we're willing to do it
-        # immediately we starve things.
-        if not all:
-            source_id = gobject.timeout_add(1, self.schedule_read)
-            return False
-        else:
-            return True
-
-    def schedule_read(self):
-        self.read_id = gobject.io_add_watch(self.stream, gobject.IO_IN, self.read)
-
-    def hup(self, source, condition):
-        while self.read(source, condition, all=True): pass
-        self.protocol.lostConnection()
-        gobject.source_remove(self.read_id)
-        self.on_finish()
-        return False
-
-
-result = GTKTestResult()
-test = GIOProtocolTestCase(sys.stdin, result, result.stopTestRun)
-gtk.main()
-if result.wasSuccessful():
-    exit_code = 0
-else:
-    exit_code = 1
-sys.exit(exit_code)
diff --git a/lib/subunit/filters/subunit2junitxml b/lib/subunit/filters/subunit2junitxml
deleted file mode 100755
index d568c71dd4..0000000000
--- a/lib/subunit/filters/subunit2junitxml
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-"""Filter a subunit stream to get aggregate statistics."""
-
-
-import sys
-from subunit.filters import run_filter_script
-
-try:
-    from junitxml import JUnitXmlResult
-except ImportError:
-    sys.stderr.write("python-junitxml (https://launchpad.net/pyjunitxml or "
-        "http://pypi.python.org/pypi/junitxml) is required for this filter.")
-    raise
-
-
-run_filter_script(JUnitXmlResult, __doc__)
diff --git a/lib/subunit/filters/subunit2pyunit b/lib/subunit/filters/subunit2pyunit
deleted file mode 100755
index 83a23d14d1..0000000000
--- a/lib/subunit/filters/subunit2pyunit
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-"""Display a subunit stream through python's unittest test runner."""
-
-from optparse import OptionParser
-import sys
-import unittest
-
-from subunit import DiscardStream, ProtocolTestCase, TestProtocolServer
-
-parser = OptionParser(description=__doc__)
-parser.add_option("--no-passthrough", action="store_true",
-    help="Hide all non subunit input.", default=False, dest="no_passthrough")
-parser.add_option("--progress", action="store_true",
-    help="Use bzrlib's test reporter (requires bzrlib)",
-        default=False)
-(options, args) = parser.parse_args()
-if options.no_passthrough:
-    passthrough_stream = DiscardStream()
-else:
-    passthrough_stream = None
-test = ProtocolTestCase(sys.stdin, passthrough=passthrough_stream)
-if options.progress:
-    from bzrlib.tests import TextTestRunner
-    from bzrlib import ui
-    ui.ui_factory = ui.make_ui_for_terminal(None, sys.stdout, sys.stderr)
-    runner = TextTestRunner()
-else:
-    runner = unittest.TextTestRunner(verbosity=2)
-if runner.run(test).wasSuccessful():
-    exit_code = 0
-else:
-    exit_code = 1
-sys.exit(exit_code)
diff --git a/lib/subunit/filters/tap2subunit b/lib/subunit/filters/tap2subunit
deleted file mode 100755
index c571972225..0000000000
--- a/lib/subunit/filters/tap2subunit
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/env python
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-"""A filter that reads a TAP stream and outputs a subunit stream.
-
-More information on TAP is available at
-http://testanything.org/wiki/index.php/Main_Page.
-"""
-
-import sys
-
-from subunit import TAP2SubUnit
-sys.exit(TAP2SubUnit(sys.stdin, sys.stdout))
diff --git a/lib/subunit/libcppunit_subunit.pc.in b/lib/subunit/libcppunit_subunit.pc.in
deleted file mode 100644
index 98982c78ae..0000000000
--- a/lib/subunit/libcppunit_subunit.pc.in
+++ /dev/null
@@ -1,11 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: cppunit subunit listener
-Description: Subunit output listener for the CPPUnit test library.
-URL: http://launchpad.net/subunit
-Version: @VERSION@
-Libs: -L${libdir} -lsubunit
-Cflags: -I${includedir}
diff --git a/lib/subunit/libsubunit.pc.in b/lib/subunit/libsubunit.pc.in
deleted file mode 100644
index 67564148e8..0000000000
--- a/lib/subunit/libsubunit.pc.in
+++ /dev/null
@@ -1,11 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: subunit
-Description: Subunit test protocol library.
-URL: http://launchpad.net/subunit
-Version: @VERSION@
-Libs: -L${libdir} -lsubunit
-Cflags: -I${includedir}
diff --git a/lib/subunit/perl/Makefile.PL.in b/lib/subunit/perl/Makefile.PL.in
deleted file mode 100755
index cf5e6c4c76..0000000000
--- a/lib/subunit/perl/Makefile.PL.in
+++ /dev/null
@@ -1,21 +0,0 @@
-use ExtUtils::MakeMaker;
-WriteMakefile(
-    'INSTALL_BASE' => '@prefix@',
-    'NAME'	=> 'Subunit',
-    'VERSION' => '@SUBUNIT_VERSION@',
-    'test' => { 'TESTS' => 'tests/*.pl' },
-    'PMLIBDIRS' => [ 'lib' ],
-    'EXE_FILES' => [ '@abs_srcdir@/subunit-diff' ],
-);
-sub MY::postamble {
-<<'EOT';
-check: # test
-
-uninstall_distcheck:
-	rm -fr $(DESTINSTALLARCHLIB)
-	rm MYMETA.yml
-
-VPATH = @srcdir@
-.PHONY: uninstall_distcheck
-EOT
-}
diff --git a/lib/subunit/perl/lib/Subunit.pm b/lib/subunit/perl/lib/Subunit.pm
deleted file mode 100644
index 72aa1ebd66..0000000000
--- a/lib/subunit/perl/lib/Subunit.pm
+++ /dev/null
@@ -1,183 +0,0 @@
-# Perl module for parsing and generating the Subunit protocol
-# Copyright (C) 2008-2009 Jelmer Vernooij <jelmer@samba.org>
-#
-#  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.
-
-package Subunit;
-use POSIX;
-
-require Exporter;
-@ISA = qw(Exporter);
-@EXPORT_OK = qw(parse_results $VERSION);
-
-use vars qw ( $VERSION );
-
-$VERSION = '0.0.2';
-
-use strict;
-
-sub parse_results($$$)
-{
-	my ($msg_ops, $statistics, $fh) = @_;
-	my $expected_fail = 0;
-	my $unexpected_fail = 0;
-	my $unexpected_err = 0;
-	my $open_tests = [];
-
-	while(<$fh>) {
-		if (/^test: (.+)\n/) {
-			$msg_ops->control_msg($_);
-			$msg_ops->start_test($1);
-			push (@$open_tests, $1);
-		} elsif (/^time: (\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)Z\n/) {
-			$msg_ops->report_time(mktime($6, $5, $4, $3, $2, $1-1900));
-		} elsif (/^(success|successful|failure|fail|skip|knownfail|error|xfail): (.*?)( \[)?([ \t]*)\n/) {
-			$msg_ops->control_msg($_);
-			my $result = $1;
-			my $testname = $2;
-			my $reason = undef;
-			if ($3) {
-				$reason = "";
-				# reason may be specified in next lines
-				my $terminated = 0;
-				while(<$fh>) {
-					$msg_ops->control_msg($_);
-					if ($_ eq "]\n") { $terminated = 1; last; } else { $reason .= $_; }
-				}
-				
-				unless ($terminated) {
-					$statistics->{TESTS_ERROR}++;
-					$msg_ops->end_test($testname, "error", 1, "reason ($result) interrupted");
-					return 1;
-				}
-			}
-			if ($result eq "success" or $result eq "successful") {
-				pop(@$open_tests); #FIXME: Check that popped value == $testname 
-				$statistics->{TESTS_EXPECTED_OK}++;
-				$msg_ops->end_test($testname, $result, 0, $reason);
-			} elsif ($result eq "xfail" or $result eq "knownfail") {
-				pop(@$open_tests); #FIXME: Check that popped value == $testname
-				$statistics->{TESTS_EXPECTED_FAIL}++;
-				$msg_ops->end_test($testname, $result, 0, $reason);
-				$expected_fail++;
-			} elsif ($result eq "failure" or $result eq "fail") {
-				pop(@$open_tests); #FIXME: Check that popped value == $testname
-				$statistics->{TESTS_UNEXPECTED_FAIL}++;
-				$msg_ops->end_test($testname, $result, 1, $reason);
-				$unexpected_fail++;
-			} elsif ($result eq "skip") {
-				$statistics->{TESTS_SKIP}++;
-				my $last = pop(@$open_tests);
-				if (defined($last) and $last ne $testname) {
-					push (@$open_tests, $testname);
-				}
-				$msg_ops->end_test($testname, $result, 0, $reason);
-			} elsif ($result eq "error") {
-				$statistics->{TESTS_ERROR}++;
-				pop(@$open_tests); #FIXME: Check that popped value == $testname
-				$msg_ops->end_test($testname, $result, 1, $reason);
-				$unexpected_err++;
-			} 
-		} else {
-			$msg_ops->output_msg($_);
-		}
-	}
-
-	while ($#$open_tests+1 > 0) {
-		$msg_ops->end_test(pop(@$open_tests), "error", 1,
-				   "was started but never finished!");
-		$statistics->{TESTS_ERROR}++;
-		$unexpected_err++;
-	}
-
-	return 1 if $unexpected_err > 0;
-	return 1 if $unexpected_fail > 0;
-	return 0;
-}
-
-sub start_test($)
-{
-	my ($testname) = @_;
-	print "test: $testname\n";
-}
-
-sub end_test($$;$)
-{
-	my $name = shift;
-	my $result = shift;
-	my $reason = shift;
-	if ($reason) {
-		print "$result: $name [\n";
-		print "$reason";
-		print "]\n";
-	} else {
-		print "$result: $name\n";
-	}
-}
-
-sub skip_test($;$)
-{
-	my $name = shift;
-	my $reason = shift;
-	end_test($name, "skip", $reason);
-}
-
-sub fail_test($;$)
-{
-	my $name = shift;
-	my $reason = shift;
-	end_test($name, "failure", $reason);
-}
-
-sub success_test($;$)
-{
-	my $name = shift;
-	my $reason = shift;
-	end_test($name, "success", $reason);
-}
-
-sub xfail_test($;$)
-{
-	my $name = shift;
-	my $reason = shift;
-	end_test($name, "xfail", $reason);
-}
-
-sub report_time($)
-{
-	my ($time) = @_;
-	my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime($time);
-	printf "time: %04d-%02d-%02d %02d:%02d:%02dZ\n", $year+1900, $mon, $mday, $hour, $min, $sec;
-}
-
-sub progress_pop()
-{
-	print "progress: pop\n";
-}
-
-sub progress_push()
-{
-	print "progress: push\n";
-}
-
-sub progress($;$)
-{
-	my ($count, $whence) = @_;
-
-	unless(defined($whence)) {
-		$whence = "";
-	}
-
-	print "progress: $whence$count\n";
-}
-
-1;
diff --git a/lib/subunit/perl/lib/Subunit/Diff.pm b/lib/subunit/perl/lib/Subunit/Diff.pm
deleted file mode 100644
index e7841c3b00..0000000000
--- a/lib/subunit/perl/lib/Subunit/Diff.pm
+++ /dev/null
@@ -1,85 +0,0 @@
-#!/usr/bin/perl
-# Diff two subunit streams
-# Copyright (C) Jelmer Vernooij <jelmer@samba.org>
-#
-#  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.
-
-package Subunit::Diff;
-
-use strict;
-
-use Subunit qw(parse_results);
-
-sub control_msg() { }
-sub report_time($$) { }
-
-sub output_msg($$)
-{
-	my ($self, $msg) = @_;
-
-	# No output for now, perhaps later diff this as well ?
-}
-
-sub start_test($$)
-{
-	my ($self, $testname) = @_;
-}
-
-sub end_test($$$$$)
-{
-	my ($self, $testname, $result, $unexpected, $reason) = @_;
-
-	$self->{$testname} = $result;
-}
-
-sub new {
-	my ($class) = @_;
-
-	my $self = { 
-	};
-	bless($self, $class);
-}
-
-sub from_file($)
-{
-	my ($path) = @_;
-	my $statistics = {
-		TESTS_UNEXPECTED_OK => 0,
-		TESTS_EXPECTED_OK => 0,
-		TESTS_UNEXPECTED_FAIL => 0,
-		TESTS_EXPECTED_FAIL => 0,
-		TESTS_ERROR => 0,
-		TESTS_SKIP => 0,
-	};
-
-	my $ret = new Subunit::Diff();
-	open(IN, $path) or return;
-	parse_results($ret, $statistics, *IN);
-	close(IN);
-	return $ret;
-}
-
-sub diff($$)
-{
-	my ($old, $new) = @_;
-	my $ret = {};
-
-	foreach my $testname (keys %$old) {
-		if ($new->{$testname} ne $old->{$testname}) {
-			$ret->{$testname} = [$old->{$testname}, $new->{$testname}];
-		}
-	}
-
-	return $ret;
-}
-
-1;
diff --git a/lib/subunit/perl/subunit-diff b/lib/subunit/perl/subunit-diff
deleted file mode 100755
index 581e832ae3..0000000000
--- a/lib/subunit/perl/subunit-diff
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/perl
-# Diff two subunit streams
-# Copyright (C) Jelmer Vernooij <jelmer@samba.org>
-#
-#  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.
-
-use Getopt::Long;
-use strict;
-use FindBin qw($RealBin $Script);
-use lib "$RealBin/lib";
-use Subunit::Diff;
-
-my $old = Subunit::Diff::from_file($ARGV[0]);
-my $new = Subunit::Diff::from_file($ARGV[1]);
-
-my $ret = Subunit::Diff::diff($old, $new);
-
-foreach my $e (sort(keys %$ret)) {
-	printf "%s: %s -> %s\n", $e, $ret->{$e}[0], $ret->{$e}[1];
-}
-
-0;
diff --git a/lib/subunit/python/iso8601/LICENSE b/lib/subunit/python/iso8601/LICENSE
deleted file mode 100644
index 5ca93dae79..0000000000
--- a/lib/subunit/python/iso8601/LICENSE
+++ /dev/null
@@ -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.
diff --git a/lib/subunit/python/iso8601/README b/lib/subunit/python/iso8601/README
deleted file mode 100644
index 5ec9d45597..0000000000
--- a/lib/subunit/python/iso8601/README
+++ /dev/null
@@ -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.
diff --git a/lib/subunit/python/iso8601/README.subunit b/lib/subunit/python/iso8601/README.subunit
deleted file mode 100644
index d1ed8a11a6..0000000000
--- a/lib/subunit/python/iso8601/README.subunit
+++ /dev/null
@@ -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.
diff --git a/lib/subunit/python/iso8601/setup.py b/lib/subunit/python/iso8601/setup.py
deleted file mode 100644
index cdb61ecf6a..0000000000
--- a/lib/subunit/python/iso8601/setup.py
+++ /dev/null
@@ -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="micktwomey+iso8601@gmail.com",
-    url="http://code.google.com/p/pyiso8601/",
-    packages=["iso8601"],
-    license="MIT",
-)
diff --git a/lib/subunit/python/iso8601/test_iso8601.py b/lib/subunit/python/iso8601/test_iso8601.py
deleted file mode 100644
index ff9e2731cf..0000000000
--- a/lib/subunit/python/iso8601/test_iso8601.py
+++ /dev/null
@@ -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
diff --git a/lib/subunit/python/subunit/__init__.py b/lib/subunit/python/subunit/__init__.py
deleted file mode 100644
index 42dcf297e4..0000000000
--- a/lib/subunit/python/subunit/__init__.py
+++ /dev/null
@@ -1,1314 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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 subsequent 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 occurred 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
-if sys.version_info > (3, 0):
-    from io import UnsupportedOperation as _UnsupportedOperation
-else:
-    _UnsupportedOperation = AttributeError
-
-
-from testtools import content, content_type, ExtendedToOriginalDecorator
-from testtools.content import TracebackContent
-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
-
-# 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, 0, 9, 'final', 0)
-
-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 fileno(self):
-        raise _UnsupportedOperation()
-
-    def write(self, bytes):
-        pass
-
-    def read(self, len=0):
-        return _b('')
-
-
-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)
-        stream = _make_stream_binary(stream)
-        self._stream = 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)
-        if self.failfast:
-            self.stop()
-
-    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)
-        if self.failfast:
-            self.stop()
-
-    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: " % outcome) + self._test_id(test))
-        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)
-            tb_content = TracebackContent(error, test)
-            for bytes in tb_content.iter_bytes():
-                self._stream.write(bytes)
-        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)
-        if self.failfast:
-            self.stop()
-
-    def _test_id(self, test):
-        result = test.id()
-        if type(result) is not bytes:
-            result = result.encode('utf8')
-        return result
-
-    def startTest(self, test):
-        """Mark a test as starting its test run."""
-        super(TestProtocolClient, self).startTest(test)
-        self._stream.write(_b("test: ") + self._test_id(test) + _b("\n"))
-        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 tags(self, new_tags, gone_tags):
-        """Inform the client about tags added/removed from the stream."""
-        if not new_tags and not gone_tags:
-            return
-        tags = set([tag.encode('utf8') for tag in new_tags])
-        tags.update([_b("-") + tag.encode('utf8') for tag in gone_tags])
-        tag_line = _b("tags: ") + _b(" ").join(tags) + _b("\n")
-        self._stream.write(tag_line)
-
-    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=None):
-        """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.
-        """
-        stream = _make_stream_binary(stream)
-        self._stream = stream
-        self._passthrough = passthrough
-        if forward is not None:
-            forward = _make_stream_binary(forward)
-        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
-
-
-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.
-    
-    :return: A binary version of the same stream (some streams cannot be
-        'fixed' but can be unwrapped).
-    """
-    try:
-        fileno = stream.fileno()
-    except _UnsupportedOperation:
-        pass
-    else:
-        _make_binary_on_windows(fileno)
-    return _unwrap_text(stream)
-
-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)
-
-
-def _unwrap_text(stream):
-    """Unwrap stream if it is a text stream to get the original buffer."""
-    if sys.version_info > (3, 0):
-        try:
-            # Read streams
-            if type(stream.read(0)) is str:
-                return stream.buffer
-        except (_UnsupportedOperation, IOError):
-            # Cannot read from the stream: try via writes
-            try:
-                stream.write(_b(''))
-            except TypeError:
-                return stream.buffer
-    return stream
diff --git a/lib/subunit/python/subunit/chunked.py b/lib/subunit/python/subunit/chunked.py
deleted file mode 100644
index b9921291ea..0000000000
--- a/lib/subunit/python/subunit/chunked.py
+++ /dev/null
@@ -1,185 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#  Copyright (C) 2011  Martin Pool <mbp@sourcefrog.net>
-#
-#  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"))
diff --git a/lib/subunit/python/subunit/details.py b/lib/subunit/python/subunit/details.py
deleted file mode 100644
index 9e5e005864..0000000000
--- a/lib/subunit/python/subunit/details.py
+++ /dev/null
@@ -1,119 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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)
diff --git a/lib/subunit/python/subunit/filters.py b/lib/subunit/python/subunit/filters.py
deleted file mode 100644
index dc3fd8aedb..0000000000
--- a/lib/subunit/python/subunit/filters.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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 optparse import OptionParser
-import sys
-
-from subunit import DiscardStream, ProtocolTestCase
-
-
-def make_options(description):
-    parser = OptionParser(description=description)
-    parser.add_option(
-        "--no-passthrough", action="store_true",
-        help="Hide all non subunit input.", default=False,
-        dest="no_passthrough")
-    parser.add_option(
-        "-o", "--output-to",
-        help="Send the output to this path rather than stdout.")
-    parser.add_option(
-        "-f", "--forward", action="store_true", default=False,
-        help="Forward subunit stream on stdout.")
-    return parser
-
-
-def run_tests_from_stream(input_stream, result, passthrough_stream=None,
-                          forward_stream=None):
-    """Run tests from a subunit input stream through 'result'.
-
-    :param input_stream: A stream containing subunit input.
-    :param result: A TestResult that will receive the test events.
-    :param passthrough_stream: All non-subunit input received will be
-        sent to this stream.  If not provided, uses the ``TestProtocolServer``
-        default, which is ``sys.stdout``.
-    :param forward_stream: All subunit input received will be forwarded
-        to this stream.  If not provided, uses the ``TestProtocolServer``
-        default, which is to not forward any input.
-    """
-    test = ProtocolTestCase(
-        input_stream, passthrough=passthrough_stream,
-        forward=forward_stream)
-    result.startTestRun()
-    test.run(result)
-    result.stopTestRun()
-
-
-def filter_by_result(result_factory, output_path, passthrough, forward,
-                     input_stream=sys.stdin):
-    """Filter an input stream using a test result.
-
-    :param result_factory: A callable that when passed an output stream
-        returns a TestResult.  It is expected that this result will output
-        to the given stream.
-    :param output_path: A path send output to.  If None, output will be go
-        to ``sys.stdout``.
-    :param passthrough: If True, all non-subunit input will be sent to
-        ``sys.stdout``.  If False, that input will be discarded.
-    :param forward: If True, all subunit input will be forwarded directly to
-        ``sys.stdout`` as well as to the ``TestResult``.
-    :param input_stream: The source of subunit input.  Defaults to
-        ``sys.stdin``.
-    :return: A test result with the resultts of the run.
-    """
-    if passthrough:
-        passthrough_stream = sys.stdout
-    else:
-        passthrough_stream = DiscardStream()
-
-    if forward:
-        forward_stream = sys.stdout
-    else:
-        forward_stream = DiscardStream()
-
-    if output_path is None:
-        output_to = sys.stdout
-    else:
-        output_to = file(output_path, 'wb')
-
-    try:
-        result = result_factory(output_to)
-        run_tests_from_stream(
-            input_stream, result, passthrough_stream, forward_stream)
-    finally:
-        if output_path:
-            output_to.close()
-    return result
-
-
-def run_filter_script(result_factory, description, post_run_hook=None):
-    """Main function for simple subunit filter scripts.
-
-    Many subunit filter scripts take a stream of subunit input and use a
-    TestResult to handle the events generated by that stream.  This function
-    wraps a lot of the boiler-plate around that by making a script with
-    options for handling passthrough information and stream forwarding, and
-    that will exit with a successful return code (i.e. 0) if the input stream
-    represents a successful test run.
-
-    :param result_factory: A callable that takes an output stream and returns
-        a test result that outputs to that stream.
-    :param description: A description of the filter script.
-    """
-    parser = make_options(description)
-    (options, args) = parser.parse_args()
-    result = filter_by_result(
-        result_factory, options.output_to, not options.no_passthrough,
-        options.forward)
-    if post_run_hook:
-        post_run_hook(result)
-    if result.wasSuccessful():
-        sys.exit(0)
-    else:
-        sys.exit(1)
diff --git a/lib/subunit/python/subunit/iso8601.py b/lib/subunit/python/subunit/iso8601.py
deleted file mode 100644
index 07855d0975..0000000000
--- a/lib/subunit/python/subunit/iso8601.py
+++ /dev/null
@@ -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"].decode()) * 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)
diff --git a/lib/subunit/python/subunit/progress_model.py b/lib/subunit/python/subunit/progress_model.py
deleted file mode 100644
index 3a6af89a33..0000000000
--- a/lib/subunit/python/subunit/progress_model.py
+++ /dev/null
@@ -1,106 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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]
-
diff --git a/lib/subunit/python/subunit/run.py b/lib/subunit/python/subunit/run.py
deleted file mode 100755
index b5ccea449d..0000000000
--- a/lib/subunit/python/subunit/run.py
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/usr/bin/python
-#
-# Simple subunit testrunner for python
-# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 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 subunit.test_results import AutoTimingTestResultDecorator
-from testtools.run import (
-    BUFFEROUTPUT,
-    CATCHBREAK,
-    FAILFAST,
-    TestProgram,
-    USAGE_AS_MAIN,
-    )
-
-
-class SubunitTestRunner(object):
-    def __init__(self, verbosity=None, failfast=None, buffer=None, stream=None):
-        """Create a TestToolsTestRunner.
-
-        :param verbosity: Ignored.
-        :param failfast: Stop running tests at the first failure.
-        :param buffer: Ignored.
-        """
-        self.failfast = failfast
-        self.stream = stream or sys.stdout
-
-    def run(self, test):
-        "Run the given test case or test suite."
-        result = TestProtocolClient(self.stream)
-        result = AutoTimingTestResultDecorator(result)
-        if self.failfast is not None:
-            result.failfast = self.failfast
-        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
-    SubunitTestProgram(module=None, argv=sys.argv, testRunner=runner,
-        stdout=sys.stdout)
diff --git a/lib/subunit/python/subunit/test_results.py b/lib/subunit/python/subunit/test_results.py
deleted file mode 100644
index 91c9bbdc1e..0000000000
--- a/lib/subunit/python/subunit/test_results.py
+++ /dev/null
@@ -1,678 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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 csv
-import datetime
-
-import testtools
-from testtools.compat import all
-from testtools.content import (
-    text_content,
-    TracebackContent,
-    )
-
-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.
-    """
-
-    # XXX: Since lp:testtools r250, this is in testtools. Once it's released,
-    # we should gut this and just use that.
-
-    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 _get_failfast(self):
-        return getattr(self.decorated, 'failfast', False)
-
-    def _set_failfast(self, value):
-        self.decorated.failfast = value
-    failfast = property(_get_failfast, _set_failfast)
-
-    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 TagsMixin(object):
-
-    def __init__(self):
-        self._clear_tags()
-
-    def _clear_tags(self):
-        self._global_tags = set(), set()
-        self._test_tags = None
-
-    def _get_active_tags(self):
-        global_new, global_gone = self._global_tags
-        if self._test_tags is None:
-            return set(global_new)
-        test_new, test_gone = self._test_tags
-        return global_new.difference(test_gone).union(test_new)
-
-    def _get_current_scope(self):
-        if self._test_tags:
-            return self._test_tags
-        return self._global_tags
-
-    def _flush_current_scope(self, tag_receiver):
-        new_tags, gone_tags = self._get_current_scope()
-        if new_tags or gone_tags:
-            tag_receiver.tags(new_tags, gone_tags)
-        if self._test_tags:
-            self._test_tags = set(), set()
-        else:
-            self._global_tags = set(), set()
-
-    def startTestRun(self):
-        self._clear_tags()
-
-    def startTest(self, test):
-        self._test_tags = set(), set()
-
-    def stopTest(self, test):
-        self._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.
-        """
-        current_new_tags, current_gone_tags = self._get_current_scope()
-        current_new_tags.update(new_tags)
-        current_new_tags.difference_update(gone_tags)
-        current_gone_tags.update(gone_tags)
-        current_gone_tags.difference_update(new_tags)
-
-
-class TagCollapsingDecorator(HookedTestResultDecorator, TagsMixin):
-    """Collapses many 'tags' calls into one where possible."""
-
-    def __init__(self, result):
-        super(TagCollapsingDecorator, self).__init__(result)
-        self._clear_tags()
-
-    def _before_event(self):
-        self._flush_current_scope(self.decorated)
-
-    def tags(self, new_tags, gone_tags):
-        TagsMixin.tags(self, 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 and_predicates(predicates):
-    """Return a predicate that is true iff all predicates are true."""
-    # XXX: Should probably be in testtools to be better used by matchers. jml
-    return lambda *args, **kwargs: all(p(*args, **kwargs) for p in predicates)
-
-
-def make_tag_filter(with_tags, without_tags):
-    """Make a callback that checks tests against tags."""
-
-    with_tags = with_tags and set(with_tags) or None
-    without_tags = without_tags and set(without_tags) or None
-
-    def check_tags(test, outcome, err, details, tags):
-        if with_tags and not with_tags <= tags:
-            return False
-        if without_tags and bool(without_tags & tags):
-            return False
-        return True
-
-    return check_tags
-
-
-class _PredicateFilter(TestResultDecorator, TagsMixin):
-
-    def __init__(self, result, predicate):
-        super(_PredicateFilter, self).__init__(result)
-        self._clear_tags()
-        self.decorated = TimeCollapsingDecorator(
-            TagCollapsingDecorator(self.decorated))
-        self._predicate = predicate
-        # 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 = []
-
-    def filter_predicate(self, test, outcome, error, details):
-        return self._predicate(
-            test, outcome, error, details, self._get_active_tags())
-
-    def addError(self, test, err=None, details=None):
-        if (self.filter_predicate(test, 'error', err, details)):
-            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)):
-            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 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 addSuccess(self, test, details=None):
-        if (self.filter_predicate(test, 'success', None, details)):
-            self._buffered_calls.append(
-                ('addSuccess', [test], {'details': details}))
-        else:
-            self._filtered()
-
-    def _filtered(self):
-        self._current_test_filtered = True
-
-    def startTest(self, test):
-        """Start a test.
-
-        Not directly passed to the client, but used for handling of tags
-        correctly.
-        """
-        TagsMixin.startTest(self, test)
-        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:
-            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 = []
-        TagsMixin.stopTest(self, test)
-
-    def tags(self, new_tags, gone_tags):
-        TagsMixin.tags(self, new_tags, gone_tags)
-        if self._current_test is not None:
-            self._buffered_calls.append(('tags', [new_tags, gone_tags], {}))
-        else:
-            return super(_PredicateFilter, self).tags(new_tags, gone_tags)
-
-    def time(self, a_time):
-        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 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_xfail=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_xfail: Filter out expected failure tests.
-        :param filter_predicate: A callable taking (test, outcome, err,
-            details, tags) 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'. tags is new in 0.0.8; 0.0.7 filters
-            are still supported but should be updated to accept the tags
-            parameter for efficiency.
-        :param fixup_expected_failures: Set of test ids to consider known
-            failing.
-        """
-        predicates = []
-        if filter_error:
-            predicates.append(
-                lambda t, outcome, e, d, tags: outcome != 'error')
-        if filter_failure:
-            predicates.append(
-                lambda t, outcome, e, d, tags: outcome != 'failure')
-        if filter_success:
-            predicates.append(
-                lambda t, outcome, e, d, tags: outcome != 'success')
-        if filter_skip:
-            predicates.append(
-                lambda t, outcome, e, d, tags: outcome != 'skip')
-        if filter_xfail:
-            predicates.append(
-                lambda t, outcome, e, d, tags: outcome != 'expectedfailure')
-        if filter_predicate is not None:
-            def compat(test, outcome, error, details, tags):
-                # 0.0.7 and earlier did not support the 'tags' parameter.
-                try:
-                    return filter_predicate(
-                        test, outcome, error, details, tags)
-                except TypeError:
-                    return filter_predicate(test, outcome, error, details)
-            predicates.append(compat)
-        predicate = and_predicates(predicates)
-        super(TestResultFilter, self).__init__(
-            _PredicateFilter(result, predicate))
-        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._failure_expected(test):
-            self.addExpectedFailure(test, err=err, details=details)
-        else:
-            super(TestResultFilter, self).addError(
-                test, err=err, details=details)
-
-    def addFailure(self, test, err=None, details=None):
-        if self._failure_expected(test):
-            self.addExpectedFailure(test, err=err, details=details)
-        else:
-            super(TestResultFilter, self).addFailure(
-                test, err=err, details=details)
-
-    def addSuccess(self, test, details=None):
-        if self._failure_expected(test):
-            self.addUnexpectedSuccess(test, details=details)
-        else:
-            super(TestResultFilter, self).addSuccess(test, details=details)
-
-    def _failure_expected(self, test):
-        return (test.id() in self._fixup_expected_failures)
-
-
-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
-
-
-class TestByTestResult(testtools.TestResult):
-    """Call something every time a test completes."""
-
-# XXX: In testtools since lp:testtools r249.  Once that's released, just
-# import that.
-
-    def __init__(self, on_test):
-        """Construct a ``TestByTestResult``.
-
-        :param on_test: A callable that take a test case, a status (one of
-            "success", "failure", "error", "skip", or "xfail"), a start time
-            (a ``datetime`` with timezone), a stop time, an iterable of tags,
-            and a details dict. Is called at the end of each test (i.e. on
-            ``stopTest``) with the accumulated values for that test.
-        """
-        super(TestByTestResult, self).__init__()
-        self._on_test = on_test
-
-    def startTest(self, test):
-        super(TestByTestResult, self).startTest(test)
-        self._start_time = self._now()
-        # There's no supported (i.e. tested) behaviour that relies on these
-        # being set, but it makes me more comfortable all the same. -- jml
-        self._status = None
-        self._details = None
-        self._stop_time = None
-
-    def stopTest(self, test):
-        self._stop_time = self._now()
-        super(TestByTestResult, self).stopTest(test)
-        self._on_test(
-            test=test,
-            status=self._status,
-            start_time=self._start_time,
-            stop_time=self._stop_time,
-            # current_tags is new in testtools 0.9.13.
-            tags=getattr(self, 'current_tags', None),
-            details=self._details)
-
-    def _err_to_details(self, test, err, details):
-        if details:
-            return details
-        return {'traceback': TracebackContent(err, test)}
-
-    def addSuccess(self, test, details=None):
-        super(TestByTestResult, self).addSuccess(test)
-        self._status = 'success'
-        self._details = details
-
-    def addFailure(self, test, err=None, details=None):
-        super(TestByTestResult, self).addFailure(test, err, details)
-        self._status = 'failure'
-        self._details = self._err_to_details(test, err, details)
-
-    def addError(self, test, err=None, details=None):
-        super(TestByTestResult, self).addError(test, err, details)
-        self._status = 'error'
-        self._details = self._err_to_details(test, err, details)
-
-    def addSkip(self, test, reason=None, details=None):
-        super(TestByTestResult, self).addSkip(test, reason, details)
-        self._status = 'skip'
-        if details is None:
-            details = {'reason': text_content(reason)}
-        elif reason:
-            # XXX: What if details already has 'reason' key?
-            details['reason'] = text_content(reason)
-        self._details = details
-
-    def addExpectedFailure(self, test, err=None, details=None):
-        super(TestByTestResult, self).addExpectedFailure(test, err, details)
-        self._status = 'xfail'
-        self._details = self._err_to_details(test, err, details)
-
-    def addUnexpectedSuccess(self, test, details=None):
-        super(TestByTestResult, self).addUnexpectedSuccess(test, details)
-        self._status = 'success'
-        self._details = details
-
-
-class CsvResult(TestByTestResult):
-
-    def __init__(self, stream):
-        super(CsvResult, self).__init__(self._on_test)
-        self._write_row = csv.writer(stream).writerow
-
-    def _on_test(self, test, status, start_time, stop_time, tags, details):
-        self._write_row([test.id(), status, start_time, stop_time])
-
-    def startTestRun(self):
-        super(CsvResult, self).startTestRun()
-        self._write_row(['test', 'status', 'start_time', 'stop_time'])
diff --git a/lib/subunit/python/subunit/tests/TestUtil.py b/lib/subunit/python/subunit/tests/TestUtil.py
deleted file mode 100644
index 39d901e0a9..0000000000
--- a/lib/subunit/python/subunit/tests/TestUtil.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# Copyright (c) 2004 Canonical Limited
-#       Author: Robert Collins <robert.collins@canonical.com>
-#
-# 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
diff --git a/lib/subunit/python/subunit/tests/__init__.py b/lib/subunit/python/subunit/tests/__init__.py
deleted file mode 100644
index e0e1eb1b04..0000000000
--- a/lib/subunit/python/subunit/tests/__init__.py
+++ /dev/null
@@ -1,43 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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_run,
-    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())
-    result.addTest(test_run.test_suite())
-    return result
diff --git a/lib/subunit/python/subunit/tests/sample-script.py b/lib/subunit/python/subunit/tests/sample-script.py
deleted file mode 100755
index 91838f6d6f..0000000000
--- a/lib/subunit/python/subunit/tests/sample-script.py
+++ /dev/null
@@ -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)
diff --git a/lib/subunit/python/subunit/tests/sample-two-script.py b/lib/subunit/python/subunit/tests/sample-two-script.py
deleted file mode 100755
index fc73dfc409..0000000000
--- a/lib/subunit/python/subunit/tests/sample-two-script.py
+++ /dev/null
@@ -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)
diff --git a/lib/subunit/python/subunit/tests/test_chunked.py b/lib/subunit/python/subunit/tests/test_chunked.py
deleted file mode 100644
index e0742f1af3..0000000000
--- a/lib/subunit/python/subunit/tests/test_chunked.py
+++ /dev/null
@@ -1,152 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#  Copyright (C) 2011  Martin Pool <mbp@sourcefrog.net>
-#
-#  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())
diff --git a/lib/subunit/python/subunit/tests/test_details.py b/lib/subunit/python/subunit/tests/test_details.py
deleted file mode 100644
index 746aa041e5..0000000000
--- a/lib/subunit/python/subunit/tests/test_details.py
+++ /dev/null
@@ -1,112 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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()))
diff --git a/lib/subunit/python/subunit/tests/test_progress_model.py b/lib/subunit/python/subunit/tests/test_progress_model.py
deleted file mode 100644
index 76200c6107..0000000000
--- a/lib/subunit/python/subunit/tests/test_progress_model.py
+++ /dev/null
@@ -1,118 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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
diff --git a/lib/subunit/python/subunit/tests/test_run.py b/lib/subunit/python/subunit/tests/test_run.py
deleted file mode 100644
index 10519ed086..0000000000
--- a/lib/subunit/python/subunit/tests/test_run.py
+++ /dev/null
@@ -1,52 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2011  Robert Collins <robertc@robertcollins.net>
-#
-#  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 testtools.compat import BytesIO
-import unittest
-
-from testtools import PlaceHolder
-
-import subunit
-from subunit.run import SubunitTestRunner
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result
-
-
-class TimeCollectingTestResult(unittest.TestResult):
-
-    def __init__(self, *args, **kwargs):
-        super(TimeCollectingTestResult, self).__init__(*args, **kwargs)
-        self.time_called = []
-
-    def time(self, a_time):
-        self.time_called.append(a_time)
-
-
-class TestSubunitTestRunner(unittest.TestCase):
-
-    def test_includes_timing_output(self):
-        io = BytesIO()
-        runner = SubunitTestRunner(stream=io)
-        test = PlaceHolder('name')
-        runner.run(test)
-        client = TimeCollectingTestResult()
-        io.seek(0)
-        subunit.TestProtocolServer(client).readFrom(io)
-        self.assertTrue(len(client.time_called) > 0)
diff --git a/lib/subunit/python/subunit/tests/test_subunit_filter.py b/lib/subunit/python/subunit/tests/test_subunit_filter.py
deleted file mode 100644
index 33b924824d..0000000000
--- a/lib/subunit/python/subunit/tests/test_subunit_filter.py
+++ /dev/null
@@ -1,370 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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
-import os
-import subprocess
-import sys
-from subunit import iso8601
-import unittest
-
-from testtools import TestCase
-from testtools.compat import _b, BytesIO
-from testtools.testresult.doubles import ExtendedTestResult
-
-import subunit
-from subunit.test_results import make_tag_filter, 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_tag_filter(self):
-        tag_filter = make_tag_filter(['global'], ['local'])
-        result = ExtendedTestResult()
-        result_filter = TestResultFilter(
-            result, filter_success=False, filter_predicate=tag_filter)
-        self.run_tests(result_filter)
-        tests_included = [
-            event[1] for event in result._events if event[0] == 'startTest']
-        tests_expected = list(map(
-            subunit.RemotedTestCase,
-            ['passed', 'error', 'skipped', 'todo']))
-        self.assertEquals(tests_expected, tests_included)
-
-    def test_tags_tracked_correctly(self):
-        tag_filter = make_tag_filter(['a'], [])
-        result = ExtendedTestResult()
-        result_filter = TestResultFilter(
-            result, filter_success=False, filter_predicate=tag_filter)
-        input_stream = _b(
-            "test: foo\n"
-            "tags: a\n"
-            "successful: foo\n"
-            "test: bar\n"
-            "successful: bar\n")
-        self.run_tests(result_filter, input_stream)
-        foo = subunit.RemotedTestCase('foo')
-        self.assertEquals(
-            [('startTest', foo),
-             ('tags', set(['a']), set()),
-             ('addSuccess', foo),
-             ('stopTest', foo),
-             ],
-            result._events)
-
-    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"""
-        # 0.0.7 and earlier did not support the 'tags' parameter, so we need
-        # to test that we still support behaviour without it.
-        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_filter_predicate_with_tags(self):
-        """You can filter by predicate callbacks that accept tags"""
-        filtered_result = unittest.TestResult()
-        def filter_cb(test, outcome, err, details, tags):
-            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.maxDiff = None
-        self.assertEqual(
-            [('time', date_a),
-             ('time', date_b),
-             ('startTest', foo),
-             ('addError', foo, {}),
-             ('stopTest', foo),
-             ('time', date_c)], result._events)
-
-    def test_time_passes_through_filtered_tests(self):
-        # Passing a subunit stream through TestResultFilter preserves 'time'
-        # directives even if a specific test is filtered out.
-        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",
-            "success: foo",
-            "time: %s",
-            ""]) % (date_a, date_b, date_c))
-        result = ExtendedTestResult()
-        result_filter = TestResultFilter(result)
-        result_filter.startTestRun()
-        self.run_tests(result_filter, subunit_stream)
-        result_filter.stopTestRun()
-        foo = subunit.RemotedTestCase('foo')
-        self.maxDiff = None
-        self.assertEqual(
-            [('startTestRun',),
-             ('time', date_a),
-             ('time', date_c),
-             ('stopTestRun',),], 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)
-
-    if sys.version_info < (2, 7):
-        # These tests require Python >=2.7.
-        del test_fixup_expected_failures, test_fixup_expected_errors, test_fixup_unexpected_success
-
-
-class TestFilterCommand(TestCase):
-
-    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_command(self, args, stream):
-        root = os.path.dirname(
-            os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
-        script_path = os.path.join(root, 'filters', 'subunit-filter')
-        command = [sys.executable, script_path] + list(args)
-        ps = subprocess.Popen(
-            command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE)
-        out, err = ps.communicate(stream)
-        if ps.returncode != 0:
-            raise RuntimeError("%s failed: %s" % (command, err))
-        return out
-
-    def to_events(self, stream):
-        test = subunit.ProtocolTestCase(BytesIO(stream))
-        result = ExtendedTestResult()
-        test.run(result)
-        return result._events
-
-    def test_default(self):
-        output = self.run_command([], _b(
-                "test: foo\n"
-                "skip: foo\n"
-                ))
-        events = self.to_events(output)
-        foo = subunit.RemotedTestCase('foo')
-        self.assertEqual(
-            [('startTest', foo),
-             ('addSkip', foo, {}),
-             ('stopTest', foo)],
-            events)
-
-    def test_tags(self):
-        output = self.run_command(['-s', '--with-tag', 'a'], _b(
-                "tags: a\n"
-                "test: foo\n"
-                "success: foo\n"
-                "tags: -a\n"
-                "test: bar\n"
-                "success: bar\n"
-                "test: baz\n"
-                "tags: a\n"
-                "success: baz\n"
-                ))
-        events = self.to_events(output)
-        foo = subunit.RemotedTestCase('foo')
-        baz = subunit.RemotedTestCase('baz')
-        self.assertEqual(
-            [('tags', set(['a']), set()),
-             ('startTest', foo),
-             ('addSuccess', foo),
-             ('stopTest', foo),
-             ('tags', set(), set(['a'])),
-             ('startTest', baz),
-             ('tags', set(['a']), set()),
-             ('addSuccess', baz),
-             ('stopTest', baz),
-             ],
-            events)
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result
diff --git a/lib/subunit/python/subunit/tests/test_subunit_stats.py b/lib/subunit/python/subunit/tests/test_subunit_stats.py
deleted file mode 100644
index 6fd3301060..0000000000
--- a/lib/subunit/python/subunit/tests/test_subunit_stats.py
+++ /dev/null
@@ -1,84 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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
diff --git a/lib/subunit/python/subunit/tests/test_subunit_tags.py b/lib/subunit/python/subunit/tests/test_subunit_tags.py
deleted file mode 100644
index c98506a737..0000000000
--- a/lib/subunit/python/subunit/tests/test_subunit_tags.py
+++ /dev/null
@@ -1,69 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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
diff --git a/lib/subunit/python/subunit/tests/test_tap2subunit.py b/lib/subunit/python/subunit/tests/test_tap2subunit.py
deleted file mode 100644
index 11bc1916b3..0000000000
--- a/lib/subunit/python/subunit/tests/test_tap2subunit.py
+++ /dev/null
@@ -1,445 +0,0 @@
-#
-#  subunit: extensions to python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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
diff --git a/lib/subunit/python/subunit/tests/test_test_protocol.py b/lib/subunit/python/subunit/tests/test_test_protocol.py
deleted file mode 100644
index 7831ba16cd..0000000000
--- a/lib/subunit/python/subunit/tests/test_test_protocol.py
+++ /dev/null
@@ -1,1337 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#
-#  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 PlaceHolder, skipIf, TestCase, TestResult
-from testtools.compat import _b, _u, BytesIO
-from testtools.content import Content, TracebackContent, text_content
-from testtools.content_type import ContentType
-try:
-    from testtools.testresult.doubles import (
-        Python26TestResult,
-        Python27TestResult,
-        ExtendedTestResult,
-        )
-except ImportError:
-    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
-
-
-def details_to_str(details):
-    return TestResult()._err_details_to_string(None, details=details)
-
-
-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)
-        traceback = "foo.c:53:ERROR invalid state\n"
-        pipe = BytesIO(_b("test old mcdonald\n"
-                        "success old mcdonald\n"
-                        "test bing crosby\n"
-                        "failure bing crosby [\n"
-                        +  traceback +
-                        "]\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 + ": "
-              + details_to_str({'traceback': text_content(traceback)}) + "\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"))
-        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("]\n"))
-        self.assertEqual(self.stdout.getvalue(), _b(""))
-        details = {}
-        details['traceback'] = Content(ContentType("text", "x-traceback",
-            {'charset': 'utf8'}),
-            lambda:[_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, details),
-            ('stopTest', self.test),
-            ])
-
-    def test_stdout_passthrough(self):
-        """Lines received which cannot be interpreted as any protocol action
-        should be passed through to sys.stdout.
-        """
-        bytes = _b("randombytes\n")
-        self.protocol.lineReceived(bytes)
-        self.assertEqual(self.stdout.getvalue(), bytes)
-
-
-class TestTestProtocolServerLostConnection(unittest.TestCase):
-
-    def setUp(self):
-        self.client = Python26TestResult()
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.test = subunit.RemotedTestCase("old mcdonald")
-
-    def test_lost_connection_no_input(self):
-        self.protocol.lostConnection()
-        self.assertEqual([], self.client._events)
-
-    def test_lost_connection_after_start(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lostConnection()
-        failure = subunit.RemoteError(
-            _u("lost connection during test 'old mcdonald'"))
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addError', self.test, failure),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_lost_connected_after_error(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("error old mcdonald\n"))
-        self.protocol.lostConnection()
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addError', self.test, subunit.RemoteError(_u(""))),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def do_connection_lost(self, outcome, opening):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("%s old mcdonald %s" % (outcome, opening)))
-        self.protocol.lostConnection()
-        failure = subunit.RemoteError(
-            _u("lost connection during %s report of test 'old mcdonald'") %
-            outcome)
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addError', self.test, failure),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_lost_connection_during_error(self):
-        self.do_connection_lost("error", "[\n")
-
-    def test_lost_connection_during_error_details(self):
-        self.do_connection_lost("error", "[ multipart\n")
-
-    def test_lost_connected_after_failure(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("failure old mcdonald\n"))
-        self.protocol.lostConnection()
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addFailure', self.test, subunit.RemoteError(_u(""))),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_lost_connection_during_failure(self):
-        self.do_connection_lost("failure", "[\n")
-
-    def test_lost_connection_during_failure_details(self):
-        self.do_connection_lost("failure", "[ multipart\n")
-
-    def test_lost_connection_after_success(self):
-        self.protocol.lineReceived(_b("test old mcdonald\n"))
-        self.protocol.lineReceived(_b("success old mcdonald\n"))
-        self.protocol.lostConnection()
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addSuccess', self.test),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_lost_connection_during_success(self):
-        self.do_connection_lost("success", "[\n")
-
-    def test_lost_connection_during_success_details(self):
-        self.do_connection_lost("success", "[ multipart\n")
-
-    def test_lost_connection_during_skip(self):
-        self.do_connection_lost("skip", "[\n")
-
-    def test_lost_connection_during_skip_details(self):
-        self.do_connection_lost("skip", "[ multipart\n")
-
-    def test_lost_connection_during_xfail(self):
-        self.do_connection_lost("xfail", "[\n")
-
-    def test_lost_connection_during_xfail_details(self):
-        self.do_connection_lost("xfail", "[ multipart\n")
-
-    def test_lost_connection_during_uxsuccess(self):
-        self.do_connection_lost("uxsuccess", "[\n")
-
-    def test_lost_connection_during_uxsuccess_details(self):
-        self.do_connection_lost("uxsuccess", "[ multipart\n")
-
-
-class TestInTestMultipart(unittest.TestCase):
-
-    def setUp(self):
-        self.client = ExtendedTestResult()
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        self.test = subunit.RemotedTestCase(_u("mcdonalds farm"))
-
-    def test__outcome_sets_details_parser(self):
-        self.protocol._reading_success_details.details_parser = None
-        self.protocol._state._outcome(0, _b("mcdonalds farm [ multipart\n"),
-            None, self.protocol._reading_success_details)
-        parser = self.protocol._reading_success_details.details_parser
-        self.assertNotEqual(None, parser)
-        self.assertTrue(isinstance(parser,
-            subunit.details.MultipartDetailsParser))
-
-
-class TestTestProtocolServerAddError(unittest.TestCase):
-
-    def setUp(self):
-        self.client = ExtendedTestResult()
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        self.test = subunit.RemotedTestCase("mcdonalds farm")
-
-    def simple_error_keyword(self, keyword):
-        self.protocol.lineReceived(_b("%s mcdonalds farm\n" % keyword))
-        details = {}
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addError', self.test, details),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_simple_error(self):
-        self.simple_error_keyword("error")
-
-    def test_simple_error_colon(self):
-        self.simple_error_keyword("error:")
-
-    def test_error_empty_message(self):
-        self.protocol.lineReceived(_b("error mcdonalds farm [\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        details = {}
-        details['traceback'] = Content(ContentType("text", "x-traceback",
-            {'charset': 'utf8'}), lambda:[_b("")])
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addError', self.test, details),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def error_quoted_bracket(self, keyword):
-        self.protocol.lineReceived(_b("%s mcdonalds farm [\n" % keyword))
-        self.protocol.lineReceived(_b(" ]\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        details = {}
-        details['traceback'] = Content(ContentType("text", "x-traceback",
-            {'charset': 'utf8'}), lambda:[_b("]\n")])
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addError', self.test, details),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_error_quoted_bracket(self):
-        self.error_quoted_bracket("error")
-
-    def test_error_colon_quoted_bracket(self):
-        self.error_quoted_bracket("error:")
-
-
-class TestTestProtocolServerAddFailure(unittest.TestCase):
-
-    def setUp(self):
-        self.client = ExtendedTestResult()
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        self.test = subunit.RemotedTestCase("mcdonalds farm")
-
-    def assertFailure(self, details):
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addFailure', self.test, details),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def simple_failure_keyword(self, keyword):
-        self.protocol.lineReceived(_b("%s mcdonalds farm\n" % keyword))
-        details = {}
-        self.assertFailure(details)
-
-    def test_simple_failure(self):
-        self.simple_failure_keyword("failure")
-
-    def test_simple_failure_colon(self):
-        self.simple_failure_keyword("failure:")
-
-    def test_failure_empty_message(self):
-        self.protocol.lineReceived(_b("failure mcdonalds farm [\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        details = {}
-        details['traceback'] = Content(ContentType("text", "x-traceback",
-            {'charset': 'utf8'}), lambda:[_b("")])
-        self.assertFailure(details)
-
-    def failure_quoted_bracket(self, keyword):
-        self.protocol.lineReceived(_b("%s mcdonalds farm [\n" % keyword))
-        self.protocol.lineReceived(_b(" ]\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        details = {}
-        details['traceback'] = Content(ContentType("text", "x-traceback",
-            {'charset': 'utf8'}), lambda:[_b("]\n")])
-        self.assertFailure(details)
-
-    def test_failure_quoted_bracket(self):
-        self.failure_quoted_bracket("failure")
-
-    def test_failure_colon_quoted_bracket(self):
-        self.failure_quoted_bracket("failure:")
-
-
-class TestTestProtocolServerAddxFail(unittest.TestCase):
-    """Tests for the xfail keyword.
-
-    In Python this can thunk through to Success due to stdlib limitations (see
-    README).
-    """
-
-    def capture_expected_failure(self, test, err):
-        self._events.append((test, err))
-
-    def setup_python26(self):
-        """Setup a test object ready to be xfailed and thunk to success."""
-        self.client = Python26TestResult()
-        self.setup_protocol()
-
-    def setup_python27(self):
-        """Setup a test object ready to be xfailed."""
-        self.client = Python27TestResult()
-        self.setup_protocol()
-
-    def setup_python_ex(self):
-        """Setup a test object ready to be xfailed with details."""
-        self.client = ExtendedTestResult()
-        self.setup_protocol()
-
-    def setup_protocol(self):
-        """Setup the protocol based on self.client."""
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        self.test = self.client._events[-1][-1]
-
-    def simple_xfail_keyword(self, keyword, as_success):
-        self.protocol.lineReceived(_b("%s mcdonalds farm\n" % keyword))
-        self.check_success_or_xfail(as_success)
-
-    def check_success_or_xfail(self, as_success, error_message=None):
-        if as_success:
-            self.assertEqual([
-                ('startTest', self.test),
-                ('addSuccess', self.test),
-                ('stopTest', self.test),
-                ], self.client._events)
-        else:
-            details = {}
-            if error_message is not None:
-                details['traceback'] = Content(
-                    ContentType("text", "x-traceback", {'charset': 'utf8'}),
-                    lambda:[_b(error_message)])
-            if isinstance(self.client, ExtendedTestResult):
-                value = details
-            else:
-                if error_message is not None:
-                    value = subunit.RemoteError(details_to_str(details))
-                else:
-                    value = subunit.RemoteError()
-            self.assertEqual([
-                ('startTest', self.test),
-                ('addExpectedFailure', self.test, value),
-                ('stopTest', self.test),
-                ], self.client._events)
-
-    def test_simple_xfail(self):
-        self.setup_python26()
-        self.simple_xfail_keyword("xfail", True)
-        self.setup_python27()
-        self.simple_xfail_keyword("xfail",  False)
-        self.setup_python_ex()
-        self.simple_xfail_keyword("xfail",  False)
-
-    def test_simple_xfail_colon(self):
-        self.setup_python26()
-        self.simple_xfail_keyword("xfail:", True)
-        self.setup_python27()
-        self.simple_xfail_keyword("xfail:", False)
-        self.setup_python_ex()
-        self.simple_xfail_keyword("xfail:", False)
-
-    def test_xfail_empty_message(self):
-        self.setup_python26()
-        self.empty_message(True)
-        self.setup_python27()
-        self.empty_message(False)
-        self.setup_python_ex()
-        self.empty_message(False, error_message="")
-
-    def empty_message(self, as_success, error_message="\n"):
-        self.protocol.lineReceived(_b("xfail mcdonalds farm [\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.check_success_or_xfail(as_success, error_message)
-
-    def xfail_quoted_bracket(self, keyword, as_success):
-        # This tests it is accepted, but cannot test it is used today, because
-        # of not having a way to expose it in Python so far.
-        self.protocol.lineReceived(_b("%s mcdonalds farm [\n" % keyword))
-        self.protocol.lineReceived(_b(" ]\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.check_success_or_xfail(as_success, "]\n")
-
-    def test_xfail_quoted_bracket(self):
-        self.setup_python26()
-        self.xfail_quoted_bracket("xfail", True)
-        self.setup_python27()
-        self.xfail_quoted_bracket("xfail", False)
-        self.setup_python_ex()
-        self.xfail_quoted_bracket("xfail", False)
-
-    def test_xfail_colon_quoted_bracket(self):
-        self.setup_python26()
-        self.xfail_quoted_bracket("xfail:", True)
-        self.setup_python27()
-        self.xfail_quoted_bracket("xfail:", False)
-        self.setup_python_ex()
-        self.xfail_quoted_bracket("xfail:", False)
-
-
-class TestTestProtocolServerAddunexpectedSuccess(TestCase):
-    """Tests for the uxsuccess keyword."""
-
-    def capture_expected_failure(self, test, err):
-        self._events.append((test, err))
-
-    def setup_python26(self):
-        """Setup a test object ready to be xfailed and thunk to success."""
-        self.client = Python26TestResult()
-        self.setup_protocol()
-
-    def setup_python27(self):
-        """Setup a test object ready to be xfailed."""
-        self.client = Python27TestResult()
-        self.setup_protocol()
-
-    def setup_python_ex(self):
-        """Setup a test object ready to be xfailed with details."""
-        self.client = ExtendedTestResult()
-        self.setup_protocol()
-
-    def setup_protocol(self):
-        """Setup the protocol based on self.client."""
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        self.test = self.client._events[-1][-1]
-
-    def simple_uxsuccess_keyword(self, keyword, as_fail):
-        self.protocol.lineReceived(_b("%s mcdonalds farm\n" % keyword))
-        self.check_fail_or_uxsuccess(as_fail)
-
-    def check_fail_or_uxsuccess(self, as_fail, error_message=None):
-        details = {}
-        if error_message is not None:
-            details['traceback'] = Content(
-                ContentType("text", "x-traceback", {'charset': 'utf8'}),
-                lambda:[_b(error_message)])
-        if isinstance(self.client, ExtendedTestResult):
-            value = details
-        else:
-            value = None
-        if as_fail:
-            self.client._events[1] = self.client._events[1][:2]
-            # The value is generated within the extended to original decorator:
-            # todo use the testtools matcher to check on this.
-            self.assertEqual([
-                ('startTest', self.test),
-                ('addFailure', self.test),
-                ('stopTest', self.test),
-                ], self.client._events)
-        elif value:
-            self.assertEqual([
-                ('startTest', self.test),
-                ('addUnexpectedSuccess', self.test, value),
-                ('stopTest', self.test),
-                ], self.client._events)
-        else:
-            self.assertEqual([
-                ('startTest', self.test),
-                ('addUnexpectedSuccess', self.test),
-                ('stopTest', self.test),
-                ], self.client._events)
-
-    def test_simple_uxsuccess(self):
-        self.setup_python26()
-        self.simple_uxsuccess_keyword("uxsuccess", True)
-        self.setup_python27()
-        self.simple_uxsuccess_keyword("uxsuccess",  False)
-        self.setup_python_ex()
-        self.simple_uxsuccess_keyword("uxsuccess",  False)
-
-    def test_simple_uxsuccess_colon(self):
-        self.setup_python26()
-        self.simple_uxsuccess_keyword("uxsuccess:", True)
-        self.setup_python27()
-        self.simple_uxsuccess_keyword("uxsuccess:", False)
-        self.setup_python_ex()
-        self.simple_uxsuccess_keyword("uxsuccess:", False)
-
-    def test_uxsuccess_empty_message(self):
-        self.setup_python26()
-        self.empty_message(True)
-        self.setup_python27()
-        self.empty_message(False)
-        self.setup_python_ex()
-        self.empty_message(False, error_message="")
-
-    def empty_message(self, as_fail, error_message="\n"):
-        self.protocol.lineReceived(_b("uxsuccess mcdonalds farm [\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.check_fail_or_uxsuccess(as_fail, error_message)
-
-    def uxsuccess_quoted_bracket(self, keyword, as_fail):
-        self.protocol.lineReceived(_b("%s mcdonalds farm [\n" % keyword))
-        self.protocol.lineReceived(_b(" ]\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.check_fail_or_uxsuccess(as_fail, "]\n")
-
-    def test_uxsuccess_quoted_bracket(self):
-        self.setup_python26()
-        self.uxsuccess_quoted_bracket("uxsuccess", True)
-        self.setup_python27()
-        self.uxsuccess_quoted_bracket("uxsuccess", False)
-        self.setup_python_ex()
-        self.uxsuccess_quoted_bracket("uxsuccess", False)
-
-    def test_uxsuccess_colon_quoted_bracket(self):
-        self.setup_python26()
-        self.uxsuccess_quoted_bracket("uxsuccess:", True)
-        self.setup_python27()
-        self.uxsuccess_quoted_bracket("uxsuccess:", False)
-        self.setup_python_ex()
-        self.uxsuccess_quoted_bracket("uxsuccess:", False)
-
-
-class TestTestProtocolServerAddSkip(unittest.TestCase):
-    """Tests for the skip keyword.
-
-    In Python this meets the testtools extended TestResult contract.
-    (See https://launchpad.net/testtools).
-    """
-
-    def setUp(self):
-        """Setup a test object ready to be skipped."""
-        self.client = ExtendedTestResult()
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        self.test = self.client._events[-1][-1]
-
-    def assertSkip(self, reason):
-        details = {}
-        if reason is not None:
-            details['reason'] = Content(
-                ContentType("text", "plain"), lambda:[reason])
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addSkip', self.test, details),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def simple_skip_keyword(self, keyword):
-        self.protocol.lineReceived(_b("%s mcdonalds farm\n" % keyword))
-        self.assertSkip(None)
-
-    def test_simple_skip(self):
-        self.simple_skip_keyword("skip")
-
-    def test_simple_skip_colon(self):
-        self.simple_skip_keyword("skip:")
-
-    def test_skip_empty_message(self):
-        self.protocol.lineReceived(_b("skip mcdonalds farm [\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.assertSkip(_b(""))
-
-    def skip_quoted_bracket(self, keyword):
-        # This tests it is accepted, but cannot test it is used today, because
-        # of not having a way to expose it in Python so far.
-        self.protocol.lineReceived(_b("%s mcdonalds farm [\n" % keyword))
-        self.protocol.lineReceived(_b(" ]\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        self.assertSkip(_b("]\n"))
-
-    def test_skip_quoted_bracket(self):
-        self.skip_quoted_bracket("skip")
-
-    def test_skip_colon_quoted_bracket(self):
-        self.skip_quoted_bracket("skip:")
-
-
-class TestTestProtocolServerAddSuccess(unittest.TestCase):
-
-    def setUp(self):
-        self.client = ExtendedTestResult()
-        self.protocol = subunit.TestProtocolServer(self.client)
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        self.test = subunit.RemotedTestCase("mcdonalds farm")
-
-    def simple_success_keyword(self, keyword):
-        self.protocol.lineReceived(_b("%s mcdonalds farm\n" % keyword))
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addSuccess', self.test),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_simple_success(self):
-        self.simple_success_keyword("successful")
-
-    def test_simple_success_colon(self):
-        self.simple_success_keyword("successful:")
-
-    def assertSuccess(self, details):
-        self.assertEqual([
-            ('startTest', self.test),
-            ('addSuccess', self.test, details),
-            ('stopTest', self.test),
-            ], self.client._events)
-
-    def test_success_empty_message(self):
-        self.protocol.lineReceived(_b("success mcdonalds farm [\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        details = {}
-        details['message'] = Content(ContentType("text", "plain"),
-            lambda:[_b("")])
-        self.assertSuccess(details)
-
-    def success_quoted_bracket(self, keyword):
-        # This tests it is accepted, but cannot test it is used today, because
-        # of not having a way to expose it in Python so far.
-        self.protocol.lineReceived(_b("%s mcdonalds farm [\n" % keyword))
-        self.protocol.lineReceived(_b(" ]\n"))
-        self.protocol.lineReceived(_b("]\n"))
-        details = {}
-        details['message'] = Content(ContentType("text", "plain"),
-            lambda:[_b("]\n")])
-        self.assertSuccess(details)
-
-    def test_success_quoted_bracket(self):
-        self.success_quoted_bracket("success")
-
-    def test_success_colon_quoted_bracket(self):
-        self.success_quoted_bracket("success:")
-
-
-class TestTestProtocolServerProgress(unittest.TestCase):
-    """Test receipt of progress: directives."""
-
-    def test_progress_accepted_stdlib(self):
-        self.result = Python26TestResult()
-        self.stream = BytesIO()
-        self.protocol = subunit.TestProtocolServer(self.result,
-            stream=self.stream)
-        self.protocol.lineReceived(_b("progress: 23"))
-        self.protocol.lineReceived(_b("progress: -2"))
-        self.protocol.lineReceived(_b("progress: +4"))
-        self.assertEqual(_b(""), self.stream.getvalue())
-
-    def test_progress_accepted_extended(self):
-        # With a progress capable TestResult, progress events are emitted.
-        self.result = ExtendedTestResult()
-        self.stream = BytesIO()
-        self.protocol = subunit.TestProtocolServer(self.result,
-            stream=self.stream)
-        self.protocol.lineReceived(_b("progress: 23"))
-        self.protocol.lineReceived(_b("progress: push"))
-        self.protocol.lineReceived(_b("progress: -2"))
-        self.protocol.lineReceived(_b("progress: pop"))
-        self.protocol.lineReceived(_b("progress: +4"))
-        self.assertEqual(_b(""), self.stream.getvalue())
-        self.assertEqual([
-            ('progress', 23, subunit.PROGRESS_SET),
-            ('progress', None, subunit.PROGRESS_PUSH),
-            ('progress', -2, subunit.PROGRESS_CUR),
-            ('progress', None, subunit.PROGRESS_POP),
-            ('progress', 4, subunit.PROGRESS_CUR),
-            ], self.result._events)
-
-
-class TestTestProtocolServerStreamTags(unittest.TestCase):
-    """Test managing tags on the protocol level."""
-
-    def setUp(self):
-        self.client = ExtendedTestResult()
-        self.protocol = subunit.TestProtocolServer(self.client)
-
-    def test_initial_tags(self):
-        self.protocol.lineReceived(_b("tags: foo bar:baz  quux\n"))
-        self.assertEqual([
-            ('tags', set(["foo", "bar:baz", "quux"]), set()),
-            ], self.client._events)
-
-    def test_minus_removes_tags(self):
-        self.protocol.lineReceived(_b("tags: -bar quux\n"))
-        self.assertEqual([
-            ('tags', set(["quux"]), set(["bar"])),
-            ], self.client._events)
-
-    def test_tags_do_not_get_set_on_test(self):
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        test = self.client._events[0][-1]
-        self.assertEqual(None, getattr(test, 'tags', None))
-
-    def test_tags_do_not_get_set_on_global_tags(self):
-        self.protocol.lineReceived(_b("tags: foo bar\n"))
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        test = self.client._events[-1][-1]
-        self.assertEqual(None, getattr(test, 'tags', None))
-
-    def test_tags_get_set_on_test_tags(self):
-        self.protocol.lineReceived(_b("test mcdonalds farm\n"))
-        test = self.client._events[-1][-1]
-        self.protocol.lineReceived(_b("tags: foo bar\n"))
-        self.protocol.lineReceived(_b("success mcdonalds farm\n"))
-        self.assertEqual(None, getattr(test, 'tags', None))
-
-
-class TestTestProtocolServerStreamTime(unittest.TestCase):
-    """Test managing time information at the protocol level."""
-
-    def test_time_accepted_stdlib(self):
-        self.result = Python26TestResult()
-        self.stream = BytesIO()
-        self.protocol = subunit.TestProtocolServer(self.result,
-            stream=self.stream)
-        self.protocol.lineReceived(_b("time: 2001-12-12 12:59:59Z\n"))
-        self.assertEqual(_b(""), self.stream.getvalue())
-
-    def test_time_accepted_extended(self):
-        self.result = ExtendedTestResult()
-        self.stream = BytesIO()
-        self.protocol = subunit.TestProtocolServer(self.result,
-            stream=self.stream)
-        self.protocol.lineReceived(_b("time: 2001-12-12 12:59:59Z\n"))
-        self.assertEqual(_b(""), self.stream.getvalue())
-        self.assertEqual([
-            ('time', datetime.datetime(2001, 12, 12, 12, 59, 59, 0,
-            iso8601.Utc()))
-            ], self.result._events)
-
-
-class TestRemotedTestCase(unittest.TestCase):
-
-    def test_simple(self):
-        test = subunit.RemotedTestCase("A test description")
-        self.assertRaises(NotImplementedError, test.setUp)
-        self.assertRaises(NotImplementedError, test.tearDown)
-        self.assertEqual("A test description",
-                         test.shortDescription())
-        self.assertEqual("A test description",
-                         test.id())
-        self.assertEqual("A test description (subunit.RemotedTestCase)", "%s" % test)
-        self.assertEqual("<subunit.RemotedTestCase description="
-                         "'A test description'>", "%r" % test)
-        result = unittest.TestResult()
-        test.run(result)
-        self.assertEqual([(test, _remote_exception_str + ": "
-                                 "Cannot run RemotedTestCases.\n\n")],
-                         result.errors)
-        self.assertEqual(1, result.testsRun)
-        another_test = subunit.RemotedTestCase("A test description")
-        self.assertEqual(test, another_test)
-        different_test = subunit.RemotedTestCase("ofo")
-        self.assertNotEqual(test, different_test)
-        self.assertNotEqual(another_test, different_test)
-
-
-class TestRemoteError(unittest.TestCase):
-
-    def test_eq(self):
-        error = subunit.RemoteError(_u("Something went wrong"))
-        another_error = subunit.RemoteError(_u("Something went wrong"))
-        different_error = subunit.RemoteError(_u("boo!"))
-        self.assertEqual(error, another_error)
-        self.assertNotEqual(error, different_error)
-        self.assertNotEqual(different_error, another_error)
-
-    def test_empty_constructor(self):
-        self.assertEqual(subunit.RemoteError(), subunit.RemoteError(_u("")))
-
-
-class TestExecTestCase(unittest.TestCase):
-
-    class SampleExecTestCase(subunit.ExecTestCase):
-
-        def test_sample_method(self):
-            """sample-script.py"""
-            # the sample script runs three tests, one each
-            # that fails, errors and succeeds
-
-        def test_sample_method_args(self):
-            """sample-script.py foo"""
-            # sample that will run just one test.
-
-    def test_construct(self):
-        test = self.SampleExecTestCase("test_sample_method")
-        self.assertEqual(test.script,
-                         subunit.join_dir(__file__, 'sample-script.py'))
-
-    def test_args(self):
-        result = unittest.TestResult()
-        test = self.SampleExecTestCase("test_sample_method_args")
-        test.run(result)
-        self.assertEqual(1, result.testsRun)
-
-    def test_run(self):
-        result = ExtendedTestResult()
-        test = self.SampleExecTestCase("test_sample_method")
-        test.run(result)
-        mcdonald = subunit.RemotedTestCase("old mcdonald")
-        bing = subunit.RemotedTestCase("bing crosby")
-        bing_details = {}
-        bing_details['traceback'] = Content(ContentType("text", "x-traceback",
-            {'charset': 'utf8'}), lambda:[_b("foo.c:53:ERROR invalid state\n")])
-        an_error = subunit.RemotedTestCase("an error")
-        error_details = {}
-        self.assertEqual([
-            ('startTest', mcdonald),
-            ('addSuccess', mcdonald),
-            ('stopTest', mcdonald),
-            ('startTest', bing),
-            ('addFailure', bing, bing_details),
-            ('stopTest', bing),
-            ('startTest', an_error),
-            ('addError', an_error, error_details),
-            ('stopTest', an_error),
-            ], result._events)
-
-    def test_debug(self):
-        test = self.SampleExecTestCase("test_sample_method")
-        test.debug()
-
-    def test_count_test_cases(self):
-        """TODO run the child process and count responses to determine the count."""
-
-    def test_join_dir(self):
-        sibling = subunit.join_dir(__file__, 'foo')
-        filedir = os.path.abspath(os.path.dirname(__file__))
-        expected = os.path.join(filedir, 'foo')
-        self.assertEqual(sibling, expected)
-
-
-class DoExecTestCase(subunit.ExecTestCase):
-
-    def test_working_script(self):
-        """sample-two-script.py"""
-
-
-class TestIsolatedTestCase(TestCase):
-
-    class SampleIsolatedTestCase(subunit.IsolatedTestCase):
-
-        SETUP = False
-        TEARDOWN = False
-        TEST = False
-
-        def setUp(self):
-            TestIsolatedTestCase.SampleIsolatedTestCase.SETUP = True
-
-        def tearDown(self):
-            TestIsolatedTestCase.SampleIsolatedTestCase.TEARDOWN = True
-
-        def test_sets_global_state(self):
-            TestIsolatedTestCase.SampleIsolatedTestCase.TEST = True
-
-
-    def test_construct(self):
-        self.SampleIsolatedTestCase("test_sets_global_state")
-
-    @skipIf(os.name != "posix", "Need a posix system for forking tests")
-    def test_run(self):
-        result = unittest.TestResult()
-        test = self.SampleIsolatedTestCase("test_sets_global_state")
-        test.run(result)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(self.SampleIsolatedTestCase.SETUP, False)
-        self.assertEqual(self.SampleIsolatedTestCase.TEARDOWN, False)
-        self.assertEqual(self.SampleIsolatedTestCase.TEST, False)
-
-    def test_debug(self):
-        pass
-        #test = self.SampleExecTestCase("test_sample_method")
-        #test.debug()
-
-
-class TestIsolatedTestSuite(TestCase):
-
-    class SampleTestToIsolate(unittest.TestCase):
-
-        SETUP = False
-        TEARDOWN = False
-        TEST = False
-
-        def setUp(self):
-            TestIsolatedTestSuite.SampleTestToIsolate.SETUP = True
-
-        def tearDown(self):
-            TestIsolatedTestSuite.SampleTestToIsolate.TEARDOWN = True
-
-        def test_sets_global_state(self):
-            TestIsolatedTestSuite.SampleTestToIsolate.TEST = True
-
-
-    def test_construct(self):
-        subunit.IsolatedTestSuite()
-
-    @skipIf(os.name != "posix", "Need a posix system for forking tests")
-    def test_run(self):
-        result = unittest.TestResult()
-        suite = subunit.IsolatedTestSuite()
-        sub_suite = unittest.TestSuite()
-        sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
-        sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
-        suite.addTest(sub_suite)
-        suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
-        suite.run(result)
-        self.assertEqual(result.testsRun, 3)
-        self.assertEqual(self.SampleTestToIsolate.SETUP, False)
-        self.assertEqual(self.SampleTestToIsolate.TEARDOWN, False)
-        self.assertEqual(self.SampleTestToIsolate.TEST, False)
-
-
-class TestTestProtocolClient(unittest.TestCase):
-
-    def setUp(self):
-        self.io = BytesIO()
-        self.protocol = subunit.TestProtocolClient(self.io)
-        self.unicode_test = PlaceHolder(_u('\u2603'))
-        self.test = TestTestProtocolClient("test_start_test")
-        self.sample_details = {'something':Content(
-            ContentType('text', 'plain'), lambda:[_b('serialised\nform')])}
-        self.sample_tb_details = dict(self.sample_details)
-        self.sample_tb_details['traceback'] = TracebackContent(
-            subunit.RemoteError(_u("boo qux")), self.test)
-
-    def test_start_test(self):
-        """Test startTest on a TestProtocolClient."""
-        self.protocol.startTest(self.test)
-        self.assertEqual(self.io.getvalue(), _b("test: %s\n" % self.test.id()))
-
-    def test_start_test_unicode_id(self):
-        """Test startTest on a TestProtocolClient."""
-        self.protocol.startTest(self.unicode_test)
-        expected = _b("test: ") + _u('\u2603').encode('utf8') + _b("\n")
-        self.assertEqual(expected, self.io.getvalue())
-
-    def test_stop_test(self):
-        # stopTest doesn't output anything.
-        self.protocol.stopTest(self.test)
-        self.assertEqual(self.io.getvalue(), _b(""))
-
-    def test_add_success(self):
-        """Test addSuccess on a TestProtocolClient."""
-        self.protocol.addSuccess(self.test)
-        self.assertEqual(
-            self.io.getvalue(), _b("successful: %s\n" % self.test.id()))
-
-    def test_add_outcome_unicode_id(self):
-        """Test addSuccess on a TestProtocolClient."""
-        self.protocol.addSuccess(self.unicode_test)
-        expected = _b("successful: ") + _u('\u2603').encode('utf8') + _b("\n")
-        self.assertEqual(expected, self.io.getvalue())
-
-    def test_add_success_details(self):
-        """Test addSuccess on a TestProtocolClient with details."""
-        self.protocol.addSuccess(self.test, details=self.sample_details)
-        self.assertEqual(
-            self.io.getvalue(), _b("successful: %s [ multipart\n"
-                "Content-Type: text/plain\n"
-                "something\n"
-                "F\r\nserialised\nform0\r\n]\n" % self.test.id()))
-
-    def test_add_failure(self):
-        """Test addFailure on a TestProtocolClient."""
-        self.protocol.addFailure(
-            self.test, subunit.RemoteError(_u("boo qux")))
-        self.assertEqual(
-            self.io.getvalue(),
-            _b(('failure: %s [\n' + _remote_exception_str + ': boo qux\n]\n')
-            % self.test.id()))
-
-    def test_add_failure_details(self):
-        """Test addFailure on a TestProtocolClient with details."""
-        self.protocol.addFailure(
-            self.test, details=self.sample_tb_details)
-        self.assertEqual(
-            self.io.getvalue(),
-            _b(("failure: %s [ multipart\n"
-            "Content-Type: text/plain\n"
-            "something\n"
-            "F\r\nserialised\nform0\r\n"
-            "Content-Type: text/x-traceback;charset=utf8,language=python\n"
-            "traceback\n" + _remote_exception_str_chunked + ": boo qux\n0\r\n"
-            "]\n") % self.test.id()))
-
-    def test_add_error(self):
-        """Test stopTest on a TestProtocolClient."""
-        self.protocol.addError(
-            self.test, subunit.RemoteError(_u("phwoar crikey")))
-        self.assertEqual(
-            self.io.getvalue(),
-            _b(('error: %s [\n' +
-            _remote_exception_str + ": phwoar crikey\n"
-            "]\n") % self.test.id()))
-
-    def test_add_error_details(self):
-        """Test stopTest on a TestProtocolClient with details."""
-        self.protocol.addError(
-            self.test, details=self.sample_tb_details)
-        self.assertEqual(
-            self.io.getvalue(),
-            _b(("error: %s [ multipart\n"
-            "Content-Type: text/plain\n"
-            "something\n"
-            "F\r\nserialised\nform0\r\n"
-            "Content-Type: text/x-traceback;charset=utf8,language=python\n"
-            "traceback\n" + _remote_exception_str_chunked + ": boo qux\n0\r\n"
-            "]\n") % self.test.id()))
-
-    def test_add_expected_failure(self):
-        """Test addExpectedFailure on a TestProtocolClient."""
-        self.protocol.addExpectedFailure(
-            self.test, subunit.RemoteError(_u("phwoar crikey")))
-        self.assertEqual(
-            self.io.getvalue(),
-            _b(('xfail: %s [\n' +
-            _remote_exception_str + ": phwoar crikey\n"
-            "]\n") % self.test.id()))
-
-    def test_add_expected_failure_details(self):
-        """Test addExpectedFailure on a TestProtocolClient with details."""
-        self.protocol.addExpectedFailure(
-            self.test, details=self.sample_tb_details)
-        self.assertEqual(
-            self.io.getvalue(),
-            _b(("xfail: %s [ multipart\n"
-            "Content-Type: text/plain\n"
-            "something\n"
-            "F\r\nserialised\nform0\r\n"
-            "Content-Type: text/x-traceback;charset=utf8,language=python\n"
-            "traceback\n" + _remote_exception_str_chunked + ": boo qux\n0\r\n"
-            "]\n") % self.test.id()))
-
-
-    def test_add_skip(self):
-        """Test addSkip on a TestProtocolClient."""
-        self.protocol.addSkip(
-            self.test, "Has it really?")
-        self.assertEqual(
-            self.io.getvalue(),
-            _b('skip: %s [\nHas it really?\n]\n' % self.test.id()))
-
-    def test_add_skip_details(self):
-        """Test addSkip on a TestProtocolClient with details."""
-        details = {'reason':Content(
-            ContentType('text', 'plain'), lambda:[_b('Has it really?')])}
-        self.protocol.addSkip(self.test, details=details)
-        self.assertEqual(
-            self.io.getvalue(),
-            _b("skip: %s [ multipart\n"
-            "Content-Type: text/plain\n"
-            "reason\n"
-            "E\r\nHas it really?0\r\n"
-            "]\n" % self.test.id()))
-
-    def test_progress_set(self):
-        self.protocol.progress(23, subunit.PROGRESS_SET)
-        self.assertEqual(self.io.getvalue(), _b('progress: 23\n'))
-
-    def test_progress_neg_cur(self):
-        self.protocol.progress(-23, subunit.PROGRESS_CUR)
-        self.assertEqual(self.io.getvalue(), _b('progress: -23\n'))
-
-    def test_progress_pos_cur(self):
-        self.protocol.progress(23, subunit.PROGRESS_CUR)
-        self.assertEqual(self.io.getvalue(), _b('progress: +23\n'))
-
-    def test_progress_pop(self):
-        self.protocol.progress(1234, subunit.PROGRESS_POP)
-        self.assertEqual(self.io.getvalue(), _b('progress: pop\n'))
-
-    def test_progress_push(self):
-        self.protocol.progress(1234, subunit.PROGRESS_PUSH)
-        self.assertEqual(self.io.getvalue(), _b('progress: push\n'))
-
-    def test_time(self):
-        # Calling time() outputs a time signal immediately.
-        self.protocol.time(
-            datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc()))
-        self.assertEqual(
-            _b("time: 2009-10-11 12:13:14.000015Z\n"),
-            self.io.getvalue())
-
-    def test_add_unexpected_success(self):
-        """Test addUnexpectedSuccess on a TestProtocolClient."""
-        self.protocol.addUnexpectedSuccess(self.test)
-        self.assertEqual(
-            self.io.getvalue(), _b("uxsuccess: %s\n" % self.test.id()))
-
-    def test_add_unexpected_success_details(self):
-        """Test addUnexpectedSuccess on a TestProtocolClient with details."""
-        self.protocol.addUnexpectedSuccess(self.test, details=self.sample_details)
-        self.assertEqual(
-            self.io.getvalue(), _b("uxsuccess: %s [ multipart\n"
-                "Content-Type: text/plain\n"
-                "something\n"
-                "F\r\nserialised\nform0\r\n]\n" % self.test.id()))
-
-    def test_tags_empty(self):
-        self.protocol.tags(set(), set())
-        self.assertEqual(_b(""), self.io.getvalue())
-
-    def test_tags_add(self):
-        self.protocol.tags(set(['foo']), set())
-        self.assertEqual(_b("tags: foo\n"), self.io.getvalue())
-
-    def test_tags_both(self):
-        self.protocol.tags(set(['quux']), set(['bar']))
-        self.assertEqual(_b("tags: quux -bar\n"), self.io.getvalue())
-
-    def test_tags_gone(self):
-        self.protocol.tags(set(), set(['bar']))
-        self.assertEqual(_b("tags: -bar\n"), self.io.getvalue())
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result
diff --git a/lib/subunit/python/subunit/tests/test_test_results.py b/lib/subunit/python/subunit/tests/test_test_results.py
deleted file mode 100644
index ff74b9a818..0000000000
--- a/lib/subunit/python/subunit/tests/test_test_results.py
+++ /dev/null
@@ -1,572 +0,0 @@
-#
-#  subunit: extensions to Python unittest to get test results from subprocesses.
-#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
-#
-#  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 csv
-import datetime
-import sys
-import unittest
-
-from testtools import TestCase
-from testtools.compat import StringIO
-from testtools.content import (
-    text_content,
-    TracebackContent,
-    )
-from testtools.testresult.doubles import ExtendedTestResult
-
-import subunit
-import subunit.iso8601 as iso8601
-import subunit.test_results
-
-import testtools
-
-
-class LoggingDecorator(subunit.test_results.HookedTestResultDecorator):
-
-    def __init__(self, decorated):
-        self._calls = 0
-        super(LoggingDecorator, self).__init__(decorated)
-
-    def _before_event(self):
-        self._calls += 1
-
-
-class AssertBeforeTestResult(LoggingDecorator):
-    """A TestResult for checking preconditions."""
-
-    def __init__(self, decorated, test):
-        self.test = test
-        super(AssertBeforeTestResult, self).__init__(decorated)
-
-    def _before_event(self):
-        self.test.assertEqual(1, self.earlier._calls)
-        super(AssertBeforeTestResult, self)._before_event()
-
-
-class TimeCapturingResult(unittest.TestResult):
-
-    def __init__(self):
-        super(TimeCapturingResult, self).__init__()
-        self._calls = []
-        self.failfast = False
-
-    def time(self, a_datetime):
-        self._calls.append(a_datetime)
-
-
-class TestHookedTestResultDecorator(unittest.TestCase):
-
-    def setUp(self):
-        # An end to the chain
-        terminal = unittest.TestResult()
-        # Asserts that the call was made to self.result before asserter was
-        # called.
-        asserter = AssertBeforeTestResult(terminal, self)
-        # The result object we call, which much increase its call count.
-        self.result = LoggingDecorator(asserter)
-        asserter.earlier = self.result
-        self.decorated = asserter
-
-    def tearDown(self):
-        # The hook in self.result must have been called
-        self.assertEqual(1, self.result._calls)
-        # The hook in asserter must have been called too, otherwise the
-        # assertion about ordering won't have completed.
-        self.assertEqual(1, self.decorated._calls)
-
-    def test_startTest(self):
-        self.result.startTest(self)
-
-    def test_startTestRun(self):
-        self.result.startTestRun()
-
-    def test_stopTest(self):
-        self.result.stopTest(self)
-
-    def test_stopTestRun(self):
-        self.result.stopTestRun()
-
-    def test_addError(self):
-        self.result.addError(self, subunit.RemoteError())
-
-    def test_addError_details(self):
-        self.result.addError(self, details={})
-
-    def test_addFailure(self):
-        self.result.addFailure(self, subunit.RemoteError())
-
-    def test_addFailure_details(self):
-        self.result.addFailure(self, details={})
-
-    def test_addSuccess(self):
-        self.result.addSuccess(self)
-
-    def test_addSuccess_details(self):
-        self.result.addSuccess(self, details={})
-
-    def test_addSkip(self):
-        self.result.addSkip(self, "foo")
-
-    def test_addSkip_details(self):
-        self.result.addSkip(self, details={})
-
-    def test_addExpectedFailure(self):
-        self.result.addExpectedFailure(self, subunit.RemoteError())
-
-    def test_addExpectedFailure_details(self):
-        self.result.addExpectedFailure(self, details={})
-
-    def test_addUnexpectedSuccess(self):
-        self.result.addUnexpectedSuccess(self)
-
-    def test_addUnexpectedSuccess_details(self):
-        self.result.addUnexpectedSuccess(self, details={})
-
-    def test_progress(self):
-        self.result.progress(1, subunit.PROGRESS_SET)
-
-    def test_wasSuccessful(self):
-        self.result.wasSuccessful()
-
-    def test_shouldStop(self):
-        self.result.shouldStop
-
-    def test_stop(self):
-        self.result.stop()
-
-    def test_time(self):
-        self.result.time(None)
-
-
-class TestAutoTimingTestResultDecorator(unittest.TestCase):
-
-    def setUp(self):
-        # And end to the chain which captures time events.
-        terminal = TimeCapturingResult()
-        # The result object under test.
-        self.result = subunit.test_results.AutoTimingTestResultDecorator(
-            terminal)
-        self.decorated = terminal
-
-    def test_without_time_calls_time_is_called_and_not_None(self):
-        self.result.startTest(self)
-        self.assertEqual(1, len(self.decorated._calls))
-        self.assertNotEqual(None, self.decorated._calls[0])
-
-    def test_no_time_from_progress(self):
-        self.result.progress(1, subunit.PROGRESS_CUR)
-        self.assertEqual(0, len(self.decorated._calls))
-
-    def test_no_time_from_shouldStop(self):
-        self.decorated.stop()
-        self.result.shouldStop
-        self.assertEqual(0, len(self.decorated._calls))
-
-    def test_calling_time_inhibits_automatic_time(self):
-        # Calling time() outputs a time signal immediately and prevents
-        # automatically adding one when other methods are called.
-        time = datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc())
-        self.result.time(time)
-        self.result.startTest(self)
-        self.result.stopTest(self)
-        self.assertEqual(1, len(self.decorated._calls))
-        self.assertEqual(time, self.decorated._calls[0])
-
-    def test_calling_time_None_enables_automatic_time(self):
-        time = datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc())
-        self.result.time(time)
-        self.assertEqual(1, len(self.decorated._calls))
-        self.assertEqual(time, self.decorated._calls[0])
-        # Calling None passes the None through, in case other results care.
-        self.result.time(None)
-        self.assertEqual(2, len(self.decorated._calls))
-        self.assertEqual(None, self.decorated._calls[1])
-        # Calling other methods doesn't generate an automatic time event.
-        self.result.startTest(self)
-        self.assertEqual(3, len(self.decorated._calls))
-        self.assertNotEqual(None, self.decorated._calls[2])
-
-    def test_set_failfast_True(self):
-        self.assertFalse(self.decorated.failfast)
-        self.result.failfast = True
-        self.assertTrue(self.decorated.failfast)
-
-
-class TestTagCollapsingDecorator(TestCase):
-
-    def test_tags_collapsed_outside_of_tests(self):
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TagCollapsingDecorator(result)
-        tag_collapser.tags(set(['a']), set())
-        tag_collapser.tags(set(['b']), set())
-        tag_collapser.startTest(self)
-        self.assertEquals(
-            [('tags', set(['a', 'b']), set([])),
-             ('startTest', self),
-             ], result._events)
-
-    def test_tags_collapsed_outside_of_tests_are_flushed(self):
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TagCollapsingDecorator(result)
-        tag_collapser.startTestRun()
-        tag_collapser.tags(set(['a']), set())
-        tag_collapser.tags(set(['b']), set())
-        tag_collapser.startTest(self)
-        tag_collapser.addSuccess(self)
-        tag_collapser.stopTest(self)
-        tag_collapser.stopTestRun()
-        self.assertEquals(
-            [('startTestRun',),
-             ('tags', set(['a', 'b']), set([])),
-             ('startTest', self),
-             ('addSuccess', self),
-             ('stopTest', self),
-             ('stopTestRun',),
-             ], result._events)
-
-    def test_tags_forwarded_after_tests(self):
-        test = subunit.RemotedTestCase('foo')
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TagCollapsingDecorator(result)
-        tag_collapser.startTestRun()
-        tag_collapser.startTest(test)
-        tag_collapser.addSuccess(test)
-        tag_collapser.stopTest(test)
-        tag_collapser.tags(set(['a']), set(['b']))
-        tag_collapser.stopTestRun()
-        self.assertEqual(
-            [('startTestRun',),
-             ('startTest', test),
-             ('addSuccess', test),
-             ('stopTest', test),
-             ('tags', set(['a']), set(['b'])),
-             ('stopTestRun',),
-             ],
-            result._events)
-
-    def test_tags_collapsed_inside_of_tests(self):
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TagCollapsingDecorator(result)
-        test = subunit.RemotedTestCase('foo')
-        tag_collapser.startTest(test)
-        tag_collapser.tags(set(['a']), set())
-        tag_collapser.tags(set(['b']), set(['a']))
-        tag_collapser.tags(set(['c']), set())
-        tag_collapser.stopTest(test)
-        self.assertEquals(
-            [('startTest', test),
-             ('tags', set(['b', 'c']), set(['a'])),
-             ('stopTest', test)],
-            result._events)
-
-    def test_tags_collapsed_inside_of_tests_different_ordering(self):
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TagCollapsingDecorator(result)
-        test = subunit.RemotedTestCase('foo')
-        tag_collapser.startTest(test)
-        tag_collapser.tags(set(), set(['a']))
-        tag_collapser.tags(set(['a', 'b']), set())
-        tag_collapser.tags(set(['c']), set())
-        tag_collapser.stopTest(test)
-        self.assertEquals(
-            [('startTest', test),
-             ('tags', set(['a', 'b', 'c']), set()),
-             ('stopTest', test)],
-            result._events)
-
-    def test_tags_sent_before_result(self):
-        # Because addSuccess and friends tend to send subunit output
-        # immediately, and because 'tags:' before a result line means
-        # something different to 'tags:' after a result line, we need to be
-        # sure that tags are emitted before 'addSuccess' (or whatever).
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TagCollapsingDecorator(result)
-        test = subunit.RemotedTestCase('foo')
-        tag_collapser.startTest(test)
-        tag_collapser.tags(set(['a']), set())
-        tag_collapser.addSuccess(test)
-        tag_collapser.stopTest(test)
-        self.assertEquals(
-            [('startTest', test),
-             ('tags', set(['a']), set()),
-             ('addSuccess', test),
-             ('stopTest', test)],
-            result._events)
-
-
-class TestTimeCollapsingDecorator(TestCase):
-
-    def make_time(self):
-        # Heh heh.
-        return datetime.datetime(
-            2000, 1, self.getUniqueInteger(), tzinfo=iso8601.UTC)
-
-    def test_initial_time_forwarded(self):
-        # We always forward the first time event we see.
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TimeCollapsingDecorator(result)
-        a_time = self.make_time()
-        tag_collapser.time(a_time)
-        self.assertEquals([('time', a_time)], result._events)
-
-    def test_time_collapsed_to_first_and_last(self):
-        # If there are many consecutive time events, only the first and last
-        # are sent through.
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TimeCollapsingDecorator(result)
-        times = [self.make_time() for i in range(5)]
-        for a_time in times:
-            tag_collapser.time(a_time)
-        tag_collapser.startTest(subunit.RemotedTestCase('foo'))
-        self.assertEquals(
-            [('time', times[0]), ('time', times[-1])], result._events[:-1])
-
-    def test_only_one_time_sent(self):
-        # If we receive a single time event followed by a non-time event, we
-        # send exactly one time event.
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TimeCollapsingDecorator(result)
-        a_time = self.make_time()
-        tag_collapser.time(a_time)
-        tag_collapser.startTest(subunit.RemotedTestCase('foo'))
-        self.assertEquals([('time', a_time)], result._events[:-1])
-
-    def test_duplicate_times_not_sent(self):
-        # Many time events with the exact same time are collapsed into one
-        # time event.
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TimeCollapsingDecorator(result)
-        a_time = self.make_time()
-        for i in range(5):
-            tag_collapser.time(a_time)
-        tag_collapser.startTest(subunit.RemotedTestCase('foo'))
-        self.assertEquals([('time', a_time)], result._events[:-1])
-
-    def test_no_times_inserted(self):
-        result = ExtendedTestResult()
-        tag_collapser = subunit.test_results.TimeCollapsingDecorator(result)
-        a_time = self.make_time()
-        tag_collapser.time(a_time)
-        foo = subunit.RemotedTestCase('foo')
-        tag_collapser.startTest(foo)
-        tag_collapser.addSuccess(foo)
-        tag_collapser.stopTest(foo)
-        self.assertEquals(
-            [('time', a_time),
-             ('startTest', foo),
-             ('addSuccess', foo),
-             ('stopTest', foo)], result._events)
-
-
-class TestByTestResultTests(testtools.TestCase):
-
-    def setUp(self):
-        super(TestByTestResultTests, self).setUp()
-        self.log = []
-        self.result = subunit.test_results.TestByTestResult(self.on_test)
-        if sys.version_info >= (3, 0):
-            self.result._now = iter(range(5)).__next__
-        else:
-            self.result._now = iter(range(5)).next
-
-    def assertCalled(self, **kwargs):
-        defaults = {
-            'test': self,
-            'tags': set(),
-            'details': None,
-            'start_time': 0,
-            'stop_time': 1,
-            }
-        defaults.update(kwargs)
-        self.assertEqual([defaults], self.log)
-
-    def on_test(self, **kwargs):
-        self.log.append(kwargs)
-
-    def test_no_tests_nothing_reported(self):
-        self.result.startTestRun()
-        self.result.stopTestRun()
-        self.assertEqual([], self.log)
-
-    def test_add_success(self):
-        self.result.startTest(self)
-        self.result.addSuccess(self)
-        self.result.stopTest(self)
-        self.assertCalled(status='success')
-
-    def test_add_success_details(self):
-        self.result.startTest(self)
-        details = {'foo': 'bar'}
-        self.result.addSuccess(self, details=details)
-        self.result.stopTest(self)
-        self.assertCalled(status='success', details=details)
-
-    def test_tags(self):
-        if not getattr(self.result, 'tags', None):
-            self.skipTest("No tags in testtools")
-        self.result.tags(['foo'], [])
-        self.result.startTest(self)
-        self.result.addSuccess(self)
-        self.result.stopTest(self)
-        self.assertCalled(status='success', tags=set(['foo']))
-
-    def test_add_error(self):
-        self.result.startTest(self)
-        try:
-            1/0
-        except ZeroDivisionError:
-            error = sys.exc_info()
-        self.result.addError(self, error)
-        self.result.stopTest(self)
-        self.assertCalled(
-            status='error',
-            details={'traceback': TracebackContent(error, self)})
-
-    def test_add_error_details(self):
-        self.result.startTest(self)
-        details = {"foo": text_content("bar")}
-        self.result.addError(self, details=details)
-        self.result.stopTest(self)
-        self.assertCalled(status='error', details=details)
-
-    def test_add_failure(self):
-        self.result.startTest(self)
-        try:
-            self.fail("intentional failure")
-        except self.failureException:
-            failure = sys.exc_info()
-        self.result.addFailure(self, failure)
-        self.result.stopTest(self)
-        self.assertCalled(
-            status='failure',
-            details={'traceback': TracebackContent(failure, self)})
-
-    def test_add_failure_details(self):
-        self.result.startTest(self)
-        details = {"foo": text_content("bar")}
-        self.result.addFailure(self, details=details)
-        self.result.stopTest(self)
-        self.assertCalled(status='failure', details=details)
-
-    def test_add_xfail(self):
-        self.result.startTest(self)
-        try:
-            1/0
-        except ZeroDivisionError:
-            error = sys.exc_info()
-        self.result.addExpectedFailure(self, error)
-        self.result.stopTest(self)
-        self.assertCalled(
-            status='xfail',
-            details={'traceback': TracebackContent(error, self)})
-
-    def test_add_xfail_details(self):
-        self.result.startTest(self)
-        details = {"foo": text_content("bar")}
-        self.result.addExpectedFailure(self, details=details)
-        self.result.stopTest(self)
-        self.assertCalled(status='xfail', details=details)
-
-    def test_add_unexpected_success(self):
-        self.result.startTest(self)
-        details = {'foo': 'bar'}
-        self.result.addUnexpectedSuccess(self, details=details)
-        self.result.stopTest(self)
-        self.assertCalled(status='success', details=details)
-
-    def test_add_skip_reason(self):
-        self.result.startTest(self)
-        reason = self.getUniqueString()
-        self.result.addSkip(self, reason)
-        self.result.stopTest(self)
-        self.assertCalled(
-            status='skip', details={'reason': text_content(reason)})
-
-    def test_add_skip_details(self):
-        self.result.startTest(self)
-        details = {'foo': 'bar'}
-        self.result.addSkip(self, details=details)
-        self.result.stopTest(self)
-        self.assertCalled(status='skip', details=details)
-
-    def test_twice(self):
-        self.result.startTest(self)
-        self.result.addSuccess(self, details={'foo': 'bar'})
-        self.result.stopTest(self)
-        self.result.startTest(self)
-        self.result.addSuccess(self)
-        self.result.stopTest(self)
-        self.assertEqual(
-            [{'test': self,
-              'status': 'success',
-              'start_time': 0,
-              'stop_time': 1,
-              'tags': set(),
-              'details': {'foo': 'bar'}},
-             {'test': self,
-              'status': 'success',
-              'start_time': 2,
-              'stop_time': 3,
-              'tags': set(),
-              'details': None},
-             ],
-            self.log)
-
-
-class TestCsvResult(testtools.TestCase):
-
-    def parse_stream(self, stream):
-        stream.seek(0)
-        reader = csv.reader(stream)
-        return list(reader)
-
-    def test_csv_output(self):
-        stream = StringIO()
-        result = subunit.test_results.CsvResult(stream)
-        if sys.version_info >= (3, 0):
-            result._now = iter(range(5)).__next__
-        else:
-            result._now = iter(range(5)).next
-        result.startTestRun()
-        result.startTest(self)
-        result.addSuccess(self)
-        result.stopTest(self)
-        result.stopTestRun()
-        self.assertEqual(
-            [['test', 'status', 'start_time', 'stop_time'],
-             [self.id(), 'success', '0', '1'],
-             ],
-            self.parse_stream(stream))
-
-    def test_just_header_when_no_tests(self):
-        stream = StringIO()
-        result = subunit.test_results.CsvResult(stream)
-        result.startTestRun()
-        result.stopTestRun()
-        self.assertEqual(
-            [['test', 'status', 'start_time', 'stop_time']],
-            self.parse_stream(stream))
-
-    def test_no_output_before_events(self):
-        stream = StringIO()
-        subunit.test_results.CsvResult(stream)
-        self.assertEqual([], self.parse_stream(stream))
-
-
-def test_suite():
-    loader = subunit.tests.TestUtil.TestLoader()
-    result = loader.loadTestsFromName(__name__)
-    return result
diff --git a/lib/subunit/runtests.py b/lib/subunit/runtests.py
deleted file mode 100755
index 8ecc6cd3fb..0000000000
--- a/lib/subunit/runtests.py
+++ /dev/null
@@ -1,138 +0,0 @@
-#!/usr/bin/env python
-# -*- Mode: python -*-
-#
-# Copyright (C) 2004 Canonical.com
-#       Author:      Robert Collins <robert.collins@canonical.com>
-#
-# 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 unittest
-from subunit.tests.TestUtil import TestVisitor, TestSuite
-import subunit
-import sys
-import os
-import shutil
-import logging
-
-class ParameterisableTextTestRunner(unittest.TextTestRunner):
-    """I am a TextTestRunner whose result class is
-    parameterisable without further subclassing"""
-    def __init__(self, **args):
-        unittest.TextTestRunner.__init__(self, **args)
-        self._resultFactory=None
-    def resultFactory(self, *args):
-        """set or retrieve the result factory"""
-        if args:
-            self._resultFactory=args[0]
-            return self
-        if self._resultFactory is None:
-            self._resultFactory=unittest._TextTestResult
-        return self._resultFactory
-
-    def _makeResult(self):
-        return self.resultFactory()(self.stream, self.descriptions, self.verbosity)
-
-
-class EarlyStoppingTextTestResult(unittest._TextTestResult):
-    """I am a TextTestResult that can optionally stop at the first failure
-    or error"""
-
-    def addError(self, test, err):
-        unittest._TextTestResult.addError(self, test, err)
-        if self.stopOnError():
-            self.stop()
-
-    def addFailure(self, test, err):
-        unittest._TextTestResult.addError(self, test, err)
-        if self.stopOnFailure():
-            self.stop()
-
-    def stopOnError(self, *args):
-        """should this result indicate an abort when an error occurs?
-        TODO parameterise this"""
-        return True
-
-    def stopOnFailure(self, *args):
-        """should this result indicate an abort when a failure error occurs?
-        TODO parameterise this"""
-        return True
-
-
-def earlyStopFactory(*args, **kwargs):
-    """return a an early stopping text test result"""
-    result=EarlyStoppingTextTestResult(*args, **kwargs)
-    return result
-
-
-class ShellTests(subunit.ExecTestCase):
-
-    def test_sourcing(self):
-        """./shell/tests/test_source_library.sh"""
-
-    def test_functions(self):
-        """./shell/tests/test_function_output.sh"""
-
-
-def test_suite():
-    result = TestSuite()
-    result.addTest(subunit.test_suite())
-    result.addTest(ShellTests('test_sourcing'))
-    result.addTest(ShellTests('test_functions'))
-    return result
-
-
-class filteringVisitor(TestVisitor):
-    """I accrue all the testCases I visit that pass a regexp filter on id
-    into my suite
-    """
-
-    def __init__(self, filter):
-        import re
-        TestVisitor.__init__(self)
-        self._suite=None
-        self.filter=re.compile(filter)
-
-    def suite(self):
-        """answer the suite we are building"""
-        if self._suite is None:
-            self._suite=TestSuite()
-        return self._suite
-
-    def visitCase(self, aCase):
-        if self.filter.match(aCase.id()):
-            self.suite().addTest(aCase)
-
-
-def main(argv):
-    """To parameterise what tests are run, run this script like so:
-    python test_all.py REGEX
-    i.e.
-    python test_all.py .*Protocol.*
-    to run all tests with Protocol in their id."""
-    if len(argv) > 1:
-        pattern = argv[1]
-    else:
-        pattern = ".*"
-    visitor = filteringVisitor(pattern)
-    test_suite().visit(visitor)
-    runner = ParameterisableTextTestRunner(verbosity=2)
-    runner.resultFactory(unittest._TextTestResult)
-    if not runner.run(visitor.suite()).wasSuccessful():
-        return 1
-    return 0
-
-if __name__ == '__main__':
-    sys.exit(main(sys.argv))
diff --git a/lib/subunit/setup.py b/lib/subunit/setup.py
deleted file mode 100755
index 1a0b192b1b..0000000000
--- a/lib/subunit/setup.py
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/usr/bin/env python
-try:
-    # If the user has setuptools / distribute installed, use it
-    from setuptools import setup
-except ImportError:
-    # Otherwise, fall back to distutils.
-    from distutils.core import setup
-    extra = {}
-else:
-    extra = {
-        'install_requires': [
-            'testtools>=0.9.23',
-        ]
-    }
-
-
-def _get_version_from_file(filename, start_of_line, split_marker):
-    """Extract version from file, giving last matching value or None"""
-    try:
-        return [x for x in open(filename)
-            if x.startswith(start_of_line)][-1].split(split_marker)[1].strip()
-    except (IOError, IndexError):
-        return None
-
-
-VERSION = (
-    # Assume we are in a distribution, which has PKG-INFO
-    _get_version_from_file('PKG-INFO', 'Version:', ':')
-    # Must be a development checkout, so use the Makefile
-    or _get_version_from_file('Makefile', 'VERSION', '=')
-    or "0.0")
-
-
-setup(
-    name='python-subunit',
-    version=VERSION,
-    description=('Python implementation of subunit test streaming protocol'),
-    long_description=open('README').read(),
-    classifiers=[
-        'Intended Audience :: Developers',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python',
-        'Topic :: Software Development :: Testing',
-    ],
-    keywords='python test streaming',
-    author='Robert Collins',
-    author_email='subunit-dev@lists.launchpad.net',
-    url='http://launchpad.net/subunit',
-    packages=['subunit', 'subunit.tests'],
-    package_dir={'subunit': 'python/subunit'},
-    scripts = [
-        'filters/subunit2gtk',
-        'filters/subunit2junitxml',
-        'filters/subunit2pyunit',
-        'filters/subunit-filter',
-        'filters/subunit-ls',
-        'filters/subunit-notify',
-        'filters/subunit-stats',
-        'filters/subunit-tags',
-        'filters/tap2subunit',
-    ],
-    **extra
-)
diff --git a/lib/subunit/shell/README b/lib/subunit/shell/README
deleted file mode 100644
index af894a2bd3..0000000000
--- a/lib/subunit/shell/README
+++ /dev/null
@@ -1,62 +0,0 @@
-#
-#  subunit shell bindings.
-#  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-This tree contains shell bindings to the subunit protocol. They are written
-entirely in shell, and unit tested in shell. See the tests/ directory for the
-test scripts. You can use `make check` to run the tests. There is a trivial
-python test_shell.py which uses the pyunit gui to expose the test results in a
-compact form.
-
-The shell bindings consist of four functions which you can use to output test
-metadata trivially. See share/subunit.sh for the functions and comments.
-
-However, this is not a full test environment, its support code for reporting to
-subunit. You can look at ShUnit (http://shunit.sourceforge.net) for 'proper'
-shell based xUnit functionality. There is a patch for ShUnit 1.3
-(subunit-ui.patch) in the subunit source tree. I hope to have that integrated
-upstream in the near future. I will delete the copy of the patch in the subunit
-tree a release or two later.
-
-If you are a test environment maintainer - either homegrown, or ShUnit or some
-such, you will need to see how the subunit calls should be used. Here is what
-a manually written test using the bindings might look like:
-
-
-subunit_start_test "test name"
-# determine if test passes or fails
-result=$(something)
-if [ $result == 0 ]; then
-  subunit_pass_test "test name"
-else
-  subunit_fail_test "test name" <<END
-Something went wrong running something:
-exited with result: '$func_status'
-END
-fi
-
-Which when run with a subunit test runner will generate something like:
-test name ... ok
-
-on success, and:
-
-test name ... FAIL
-
-======================================================================
-FAIL: test name
-----------------------------------------------------------------------
-RemoteError:
-Something went wrong running something:
-exited with result: '1'
diff --git a/lib/subunit/shell/share/subunit.sh b/lib/subunit/shell/share/subunit.sh
deleted file mode 100644
index a532388252..0000000000
--- a/lib/subunit/shell/share/subunit.sh
+++ /dev/null
@@ -1,61 +0,0 @@
-#
-#  subunit.sh: shell functions to report test status via the subunit protocol.
-#  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
-#
-#  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_start_test () {
-  # emit the current protocol start-marker for test $1
-  echo "time: `date -u '+%Y-%m-%d %H:%M:%SZ'`"
-  echo "test: $1"
-}
-
-
-subunit_pass_test () {
-  # emit the current protocol test passed marker for test $1
-  echo "time: `date -u '+%Y-%m-%d %H:%M:%SZ'`"
-  echo "success: $1"
-}
-
-
-subunit_fail_test () {
-  # emit the current protocol fail-marker for test $1, and emit stdin as
-  # the error text.
-  # we use stdin because the failure message can be arbitrarily long, and this
-  # makes it convenient to write in scripts (using <<END syntax.
-  echo "time: `date -u '+%Y-%m-%d %H:%M:%SZ'`"
-  echo "failure: $1 ["
-  cat -
-  echo "]"
-}
-
-
-subunit_error_test () {
-  # emit the current protocol error-marker for test $1, and emit stdin as
-  # the error text.
-  # we use stdin because the failure message can be arbitrarily long, and this
-  # makes it convenient to write in scripts (using <<END syntax.
-  echo "time: `date -u '+%Y-%m-%d %H:%M:%SZ'`"
-  echo "error: $1 ["
-  cat -
-  echo "]"
-}
-
-
-subunit_skip_test () {
-  # emit the current protocol test skipped marker for test $1
-  echo "time: `date -u '+%Y-%m-%d %H:%M:%SZ'`"
-  echo "skip: $1"
-}
-
-
diff --git a/lib/subunit/shell/tests/test_function_output.sh b/lib/subunit/shell/tests/test_function_output.sh
deleted file mode 100755
index 00b0844dda..0000000000
--- a/lib/subunit/shell/tests/test_function_output.sh
+++ /dev/null
@@ -1,97 +0,0 @@
-#!/bin/bash
-#  subunit shell bindings.
-#  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-
-# this script tests the output of the methods. As each is tested we start using
-# it.
-# So the first test manually implements the entire protocol, the next uses the
-# start method and so on.
-# it is assumed that we are running from the 'shell' tree root in the source
-# of subunit, and that the library sourcing tests have all passed - if they 
-# have not, this test script may well fail strangely.
-
-# import the library.
-. ${SHELL_SHARE}subunit.sh
-
-echo 'test: subunit_start_test output'
-func_output=$(subunit_start_test "foo bar"|grep -v 'time:')
-func_status=$?
-if [ $func_status == 0 -a "x$func_output" = "xtest: foo bar" ]; then
-  echo 'success: subunit_start_test output'
-else
-  echo 'failure: subunit_start_test output ['
-  echo 'got an error code or incorrect output:'
-  echo "exit: $func_status"
-  echo "output: '$func_output'"
-  echo ']' ;
-fi
-
-subunit_start_test "subunit_pass_test output"
-func_output=$(subunit_pass_test "foo bar"|grep -v 'time:')
-func_status=$?
-if [ $func_status == 0 -a "x$func_output" = "xsuccess: foo bar" ]; then
-  subunit_pass_test "subunit_pass_test output"
-else
-  echo 'failure: subunit_pass_test output ['
-  echo 'got an error code or incorrect output:'
-  echo "exit: $func_status"
-  echo "output: '$func_output'"
-  echo ']' ;
-fi
-
-subunit_start_test "subunit_fail_test output"
-func_output=$((subunit_fail_test "foo bar" <<END
-something
-  wrong
-here
-END
-)|grep -v 'time:')
-func_status=$?
-if [ $func_status == 0 -a "x$func_output" = "xfailure: foo bar [
-something
-  wrong
-here
-]" ]; then
-  subunit_pass_test "subunit_fail_test output"
-else
-  echo 'failure: subunit_fail_test output ['
-  echo 'got an error code or incorrect output:'
-  echo "exit: $func_status"
-  echo "output: '$func_output'"
-  echo ']' ;
-fi
-
-subunit_start_test "subunit_error_test output"
-func_output=$((subunit_error_test "foo bar" <<END
-something
-  died
-here
-END
-)| grep -v 'time:')
-func_status=$?
-if [ $func_status == 0 -a "x$func_output" = "xerror: foo bar [
-something
-  died
-here
-]" ]; then
-  subunit_pass_test "subunit_error_test output"
-else
-  subunit_fail_test "subunit_error_test output" <<END
-got an error code or incorrect output:
-exit: $func_status
-output: '$func_output'
-END
-fi
diff --git a/lib/subunit/shell/tests/test_source_library.sh b/lib/subunit/shell/tests/test_source_library.sh
deleted file mode 100755
index 699f1281bc..0000000000
--- a/lib/subunit/shell/tests/test_source_library.sh
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/bin/bash
-#  subunit shell bindings.
-#  Copyright (C) 2006  Robert Collins <robertc@robertcollins.net>
-#
-#  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.
-#
-
-
-# this script tests that we can source the subunit shell bindings successfully.
-# It manually implements the control protocol so that it des not depend on the
-# bindings being complete yet.
-
-# we expect to be run from the tree root.
-
-echo 'test: shell bindings can be sourced'
-# if any output occurs, this has failed to source cleanly
-source_output=$(. ${SHELL_SHARE}subunit.sh 2>&1)
-if [ $? == 0 -a "x$source_output" = "x" ]; then
-  echo 'success: shell bindings can be sourced'
-else
-  echo 'failure: shell bindings can be sourced ['
-  echo 'got an error code or output during sourcing.:'
-  echo $source_output
-  echo ']' ;
-fi
-
-# now source it for real
-. ${SHELL_SHARE}subunit.sh
-
-# we should have a start_test function
-echo 'test: subunit_start_test exists'
-found_type=$(type -t subunit_start_test)
-status=$?
-if [ $status == 0 -a "x$found_type" = "xfunction" ]; then
-  echo 'success: subunit_start_test exists'
-else
-  echo 'failure: subunit_start_test exists ['
-  echo 'subunit_start_test is not a function:'
-  echo "type -t status: $status"
-  echo "output: $found_type"
-  echo ']' ;
-fi
-
-# we should have a pass_test function
-echo 'test: subunit_pass_test exists'
-found_type=$(type -t subunit_pass_test)
-status=$?
-if [ $status == 0 -a "x$found_type" = "xfunction" ]; then
-  echo 'success: subunit_pass_test exists'
-else
-  echo 'failure: subunit_pass_test exists ['
-  echo 'subunit_pass_test is not a function:'
-  echo "type -t status: $status"
-  echo "output: $found_type"
-  echo ']' ;
-fi
-
-# we should have a fail_test function
-echo 'test: subunit_fail_test exists'
-found_type=$(type -t subunit_fail_test)
-status=$?
-if [ $status == 0 -a "x$found_type" = "xfunction" ]; then
-  echo 'success: subunit_fail_test exists'
-else
-  echo 'failure: subunit_fail_test exists ['
-  echo 'subunit_fail_test is not a function:'
-  echo "type -t status: $status"
-  echo "output: $found_type"
-  echo ']' ;
-fi
-
-# we should have a error_test function
-echo 'test: subunit_error_test exists'
-found_type=$(type -t subunit_error_test)
-status=$?
-if [ $status == 0 -a "x$found_type" = "xfunction" ]; then
-  echo 'success: subunit_error_test exists'
-else
-  echo 'failure: subunit_error_test exists ['
-  echo 'subunit_error_test is not a function:'
-  echo "type -t status: $status"
-  echo "output: $found_type"
-  echo ']' ;
-fi
-
-# we should have a skip_test function
-echo 'test: subunit_skip_test exists'
-found_type=$(type -t subunit_skip_test)
-status=$?
-if [ $status == 0 -a "x$found_type" = "xfunction" ]; then
-  echo 'success: subunit_skip_test exists'
-else
-  echo 'failure: subunit_skip_test exists ['
-  echo 'subunit_skip_test is not a function:'
-  echo "type -t status: $status"
-  echo "output: $found_type"
-  echo ']' ;
-fi
-
diff --git a/lib/update-external.sh b/lib/update-external.sh
index c2f7ef4fa5..00f1d97e6b 100755
--- a/lib/update-external.sh
+++ b/lib/update-external.sh
@@ -9,11 +9,6 @@ THIRD_PARTY_DIR="`dirname $0`/../third_party"
 LIBDIR="`dirname $0`"
 WORKDIR="`mktemp -d`"
 
-echo "Updating subunit..."
-git clone git://github.com/testing-cabal/subunit "$WORKDIR/subunit"
-rm -rf "$WORKDIR/subunit/.git"
-rsync -avz --delete "$WORKDIR/subunit/" "$LIBDIR/subunit/"
-
 echo "Updating testtools..."
 git clone git://github.com/testing-cabal/testtools "$WORKDIR/testtools"
 rm -rf "$WORKDIR/testtools/.git"
diff --git a/lib/wscript_build b/lib/wscript_build
index 5712712253..7e8693bd39 100644
--- a/lib/wscript_build
+++ b/lib/wscript_build
@@ -4,7 +4,6 @@ import os, Options
 
 # work out what python external libraries we need to install
 external_libs = {
-    "subunit": "subunit/python/subunit",
     "testtools": "testtools/testtools",
     "extras": "extras/extras",
     "mimeparse": "mimeparse/mimeparse",