Merge lp:~stewart/percona-xtrabackup/1.6-testsuite-fixes into lp:percona-xtrabackup/1.6

[Stewart Smith]

Includes Alexey's fixes, plus some more of mine.

big change is to make run.sh also output subunit, which subunit2junitxml then converts to the JUnit that Jenkins understands. (see http://jenkins.percona.com/view/Percona%20Xtrabackup/job/percona-xtrabackup-param/9/testReport/ for example of what that makes Jenkins do)

I've included needed libraries to run subunit2junitxml and updated the Jenkins percona-xtrabackup-template job to properly run it.

http://jenkins.percona.com/view/Percona%20Xtrabackup/job/percona-xtrabackup-param/10/

(also see branch that is merged with trunk)

=== added file 'test/bootstrap.sh'
--- test/bootstrap.sh	1970-01-01 00:00:00 +0000
+++ test/bootstrap.sh	2011-06-10 09:54:56 +0000
@@ -0,0 +1,88 @@
+#!/bin/bash
+
+set -e
+
+function usage()
+{
+    cat <<EOF
+Usage: 
+$0 xtrabackup_target [installation_directory]
+$0 path_to_server_tarball [installation_directory]
+
+Prepares a server binary directory to be used by run.sh when running XtraBackup
+tests.
+
+If the argument is one of the build targets passed to build.sh 
+(i.e. innodb51_builtin innodb51 innodb55 xtradb51 xtradb55) then the 
+appropriate Linux tarball is downloaded from a pre-defined location and
+unpacked into the specified installation  directory ('./server' by default).
+
+Otherwise the argument is assumed to be a path to a server binary tarball.
+EOF
+}
+
+if [ -z "$1" ]
+then
+    usage
+fi
+
+arch="`uname -m`"
+if [ "$arch" = "i386" ]
+then
+    arch="i686"
+fi
+
+case "$1" in
+    innodb51_builtin | innodb51)
+	url="http://www.percona.com/downloads/community/"
+	tarball="mysql-5.1.49-linux-$arch-glibc23.tar.gz"
+	;;
+    innodb55)
+	url="http://www.percona.com/downloads/community/"
+	tarball="mysql-5.5.6-rc-linux2.6-$arch.tar.gz"
+	;;
+    xtradb51)
+	url="http://www.percona.com/downloads/community/"
+	tarball="Percona-Server-5.1.51-rel11.5-132-Linux-$arch.tar.gz"
+	;;
+    xtradb55)
+	url="http://www.percona.com/downloads/Percona-Server-5.5/Percona-Server-5.5.11-20.2/Linux/binary/"
+	tarball="Percona-Server-5.5.11-rel20.2-116.Linux.$arch.tar.gz"
+	;;
+    *)
+	if ! test -r "$1"
+	then
+	    echo "$1 does not exist"
+	    exit 1
+	fi
+	tarball="$1"
+	;;
+esac
+
+if test -n "$2"
+then
+    destdir="$2"
+else
+    destdir="./server"
+fi
+
+if test -n "$url"
+then
+    echo "Downloading $tarball"
+    wget -c "$url/$tarball"
+fi
+
+if test -d "$destdir"
+then
+    rm -rf "$destdir"
+fi
+mkdir "$destdir"
+
+echo "Unpacking $tarball into $destdir"
+tar zxf $tarball -C $destdir 
+sourcedir="$destdir/`ls $destdir`"
+if test -n "$sourcedir"
+then
+    mv $sourcedir/* $destdir
+    rm -rf $sourcedir
+fi

=== modified file 'test/experimental/xb_race_drop.sh'
--- test/experimental/xb_race_drop.sh	2011-03-01 16:59:27 +0000
+++ test/experimental/xb_race_drop.sh	2011-06-10 09:54:56 +0000
@@ -11,5 +11,3 @@
 vlog "Starting backup"
 xtrabackup --datadir=$mysql_datadir --backup --target-dir=$topdir/data/full
 vlog "Full backup done"
-stop_mysqld
-clean 

=== modified file 'test/inc/common.sh'
--- test/inc/common.sh	2011-03-14 18:46:12 +0000
+++ test/inc/common.sh	2011-06-10 09:54:56 +0000
@@ -1,16 +1,20 @@
 #!/bin/env bash
 
 set -eu
-topdir="`pwd`/var"
-mysql_datadir="$topdir/mysql"
-mysql_port="3306"
-mysql_socket=${mysql_socket:-"/tmp/xtrabackup.mysql.sock"}
-
-OUTFILE=results/`basename $0`_innobackupex.out
+
+function innobackupex()
+{
+    run_cmd `which innobackupex` $IB_ARGS $*
+}
+
+function xtrabackup()
+{
+    run_cmd `which $XB_BIN` $XB_ARGS $*
+}
 
 function vlog
 {
-    echo "`date +"%F %T"`: `basename "$0"`: $@"
+    echo "`date +"%F %T"`: `basename "$0"`: $@" >> $OUTFILE
 }
 
 function clean_datadir()
@@ -53,105 +57,6 @@
     mkdir -p "$mysql_datadir"
 }
 
-function init_mysql()
-{
-	url="http://www.percona.com/downloads/community/"
-	case "$MYSQL_VERSION" in
-		system)
-			echo "Using MySQL installed in the system"
-			MYSQL=mysql
-			MYSQLADMIN=mysqladmin
-			MYSQL_INSTALL_DB=mysql_install_db
-			MYSQL_ARGS="--no-defaults --socket=${mysql_socket} --user=root"
-			MYSQLD=mysqld
-			MYSQL_BASEDIR="/usr"
-			MYSQLD_ARGS="--no-defaults --basedir=${MYSQL_BASEDIR} --socket=${mysql_socket} --datadir=$mysql_datadir"
-			IB_BIN="innobackupex --defaults-file=$topdir/my.cnf"
-			XB_BIN=xtrabackup
-			;;
-		5.0)
-			echo "Using MySQL 5.0"
-			version="5.0.91-linux-`uname -m`-glibc23"
-			cd $topdir
-			wget "$url/mysql-$version.tar.gz" >/dev/null 2>&1
-			tar zxf mysql-$version.tar.gz
-			MYSQL=$topdir/mysql-$version/bin/mysql
-			MYSQLADMIN=$topdir/mysql-$version/bin/mysqladmin
-			MYSQL_INSTALL_DB=$topdir/mysql-$version/scripts/mysql_install_db
-			MYSQLD=$topdir/mysql-$version/bin/mysqld
-			MYSQL_BASEDIR=$topdir/mysql-$version
-			MYSQLD_ARGS="--no-defaults --basedir=${MYSQL_BASEDIR} --socket=${mysql_socket} --datadir=$mysql_datadir"
-			MYSQL_ARGS="--no-defaults --socket=${mysql_socket} --user=root"
-			IB_BIN="innobackupex --defaults-file=$topdir/my.cnf"
-			XB_BIN=xtrabackup_51
-			cd -
-			;;
-		5.1)
-			echo "Using MySQL 5.1"
-			version="5.1.49-linux-`uname -m`-glibc23"
-			cd $topdir
-			wget "$url/mysql-$version.tar.gz" >/dev/null 2>&1
-			tar zxf mysql-$version.tar.gz
-			MYSQL=$topdir/mysql-$version/bin/mysql
-			MYSQLADMIN=$topdir/mysql-$version/bin/mysqladmin
-			MYSQL_INSTALL_DB=$topdir/mysql-$version/scripts/mysql_install_db
-			MYSQLD=$topdir/mysql-$version/bin/mysqld
-			MYSQL_BASEDIR=$topdir/mysql-$version
-			MYSQLD_ARGS="--no-defaults --basedir=${MYSQL_BASEDIR} --socket=${mysql_socket} --datadir=$mysql_datadir"
-			MYSQL_ARGS="--no-defaults --socket=${mysql_socket} --user=root"
-			IB_BIN="innobackupex --defaults-file=$topdir/my.cnf"
-			XB_BIN=xtrabackup
-			cd -
-			;;
-		5.5)
-			echo "Using MySQL 5.5"
-			version="5.5.6-rc-linux2.6-`uname -m`"
-			cd $topdir
-			wget "$url/mysql-$version.tar.gz" >/dev/null 2>&1
-			tar zxf mysql-$version.tar.gz
-			MYSQL=$topdir/mysql-$version/bin/mysql
-			MYSQLADMIN=$topdir/mysql-$version/bin/mysqladmin
-			MYSQL_INSTALL_DB=$topdir/mysql-$version/scripts/mysql_install_db
-			MYSQLD=$topdir/mysql-$version/bin/mysqld
-			MYSQL_BASEDIR=$topdir/mysql-$version
-			MYSQLD_ARGS="--no-defaults --basedir=${MYSQL_BASEDIR} --socket=${mysql_socket} --datadir=$mysql_datadir"
-			MYSQL_ARGS="--no-defaults --socket=${mysql_socket} --user=root"
-			IB_BIN="innobackupex --defaults-file=$topdir/my.cnf"
-			XB_BIN=xtrabackup_55
-			cd -
-			;;
-		percona)
-			echo "Using Percona Server"
-			version="5.1.51-rel11.5-132-Linux-`uname -m`"
-			cd $topdir
-			wget "$url/Percona-Server-$version.tar.gz" >/dev/null 2>&1
-			tar zxf Percona-Server-$version.tar.gz
-			MYSQL=$topdir/Percona-Server-$version/bin/mysql
-			MYSQLADMIN=$topdir/Percona-Server-$version/bin/mysqladmin
-			MYSQL_INSTALL_DB=$topdir/Percona-Server-$version/bin/mysql_install_db
-			MYSQLD=$topdir/Percona-Server-$version/libexec/mysqld
-			MYSQL_BASEDIR=$topdir/Percona-Server-$version
-			MYSQLD_ARGS="--no-defaults --basedir=${MYSQL_BASEDIR} --socket=${mysql_socket} --datadir=$mysql_datadir"
-			MYSQL_ARGS="--no-defaults --socket=${mysql_socket} --user=root"
-			set +u
-			export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$topdir/Percona-Server-$version/lib/mysql
-			set -u
-			IB_BIN="innobackupex --defaults-file=$topdir/my.cnf"
-			XB_BIN=xtrabackup
-
-			cd -
-			;;
-		*)
-			usage
-			exit -1
-			;;
-	esac
-	if [ "`whoami`" = "root" ]
-	then
-		MYSQLD_ARGS="$MYSQLD_ARGS --user=root"
-	fi
-}
-
 function init_mysql_dir()
 {
     vlog "Creating MySQL database"
@@ -189,13 +94,45 @@
         result="0"
     fi
     echo $result
-    }
-
+}
+
+function get_xtrabackup_version()
+{
+    if [ "${MYSQL_VERSION:0:3}" = "5.1" ]
+    then
+	if [ -z "$INNODB_VERSION" ]
+	then
+	    XB_BIN="xtrabackup_51" # InnoDB 5.1 builtin
+	else
+	    XB_BIN="xtrabackup"    # InnoDB 5.1 plugin or Percona Server 5.1
+	fi
+    elif [ "${MYSQL_VERSION:0:3}" = "5.5" ]
+    then
+	XB_BIN="xtrabackup_55"
+    else
+	vlog "Uknown MySQL/InnoDB version: $MYSQL_VERSION/$INNODB_VERSION"
+	exit -1
+    fi
+    XTRADB_VERSION=`echo $INNODB_VERSION  | sed 's/[0-9]\.[0-9]\.[0-9][0-9]*\(-[0-9][0-9]*\.[0-9][0-9]*\)*$/\1/'`
+    vlog "Using '$XB_BIN' as xtrabackup binary"
+    # Set the correct binary for innobackupex
+    IB_ARGS="$IB_ARGS --ibbackup=$XB_BIN"
+}
+
+function kill_leftovers()
+{
+    while test -f "$PWD/mysqld.pid" 
+    do
+	vlog "Found a leftover mysqld processes with PID `cat $PWD/mysqld.pid`, stopping it"
+	stop_mysqld 2> /dev/null
+    done
+}
 
 function run_mysqld()
 {
     local c=0
-    ${MYSQLD} ${MYSQLD_ARGS} $* --port=$mysql_port &
+    kill_leftovers
+    ${MYSQLD} ${MYSQLD_ARGS} $* --pid-file="$PWD/mysqld.pid" &
     while [ "`mysql_ping`" != "1" ]
     do
         if [ ${c} -eq 100 ]
@@ -206,8 +143,13 @@
         let c=${c}+1
         sleep 1
     done
+    # Get MySQL and InnoDB versions
+    MYSQL_VERSION=`$MYSQL ${MYSQL_ARGS} -Nsf -e "SHOW VARIABLES LIKE 'version'"`
+    MYSQL_VERSION=${MYSQL_VERSION#"version	"}
+    INNODB_VERSION=`$MYSQL ${MYSQL_ARGS} -Nsf -e "SHOW VARIABLES LIKE 'innodb_version'"`
+    INNODB_VERSION=${INNODB_VERSION#"innodb_version	"}
+    get_xtrabackup_version
     vlog "MySQL started successfully"
-
 }
 
 function run_cmd()
@@ -218,8 +160,17 @@
 
 function stop_mysqld()
 {
-    ${MYSQLADMIN} ${MYSQL_ARGS} shutdown 
-    vlog "Database server has been stopped"
+    if [ -f "$PWD/mysqld.pid" ]
+    then
+	${MYSQLADMIN} ${MYSQL_ARGS} shutdown 
+	vlog "Database server has been stopped"
+	if [ -f "$PWD/mysqld.pid" ]
+	then
+	    sleep 1;
+	    kill -9 `cat $PWD/mysqld.pid`
+	    rm -f $PWD/mysqld.pid
+	fi
+    fi
 }
 
 function load_sakila()
@@ -254,9 +205,7 @@
 function init()
 {
 initdir
-init_mysql
 init_mysql_dir
-set_mysl_port
 echo "
 [mysqld]
 datadir=$mysql_datadir" > $topdir/my.cnf

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

=== added directory 'test/python/iso8601'
=== added file 'test/python/iso8601/LICENSE'
--- test/python/iso8601/LICENSE	1970-01-01 00:00:00 +0000
+++ test/python/iso8601/LICENSE	2011-06-10 09:54:56 +0000
@@ -0,0 +1,20 @@
+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.

=== added file 'test/python/iso8601/README'
--- test/python/iso8601/README	1970-01-01 00:00:00 +0000
+++ test/python/iso8601/README	2011-06-10 09:54:56 +0000
@@ -0,0 +1,26 @@
+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.

=== added file 'test/python/iso8601/README.subunit'
--- test/python/iso8601/README.subunit	1970-01-01 00:00:00 +0000
+++ test/python/iso8601/README.subunit	2011-06-10 09:54:56 +0000
@@ -0,0 +1,5 @@
+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.

=== added file 'test/python/iso8601/setup.py'
--- test/python/iso8601/setup.py	1970-01-01 00:00:00 +0000
+++ test/python/iso8601/setup.py	2011-06-10 09:54:56 +0000
@@ -0,0 +1,58 @@
+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.
[phone]T20:34:22+00:00) into datetime objects.
+
+>>> import iso8601
+>>> iso8601.parse_date("2007-01-25T12:00:00Z")
+datetime.datetime(2007, 1, 25, 12, 0, tzinfo=<iso8601.iso8601.Utc ...>)
+>>>
+
+Changes
+=======
+
+0.1.4
+-----
+
+* The default_timezone argument wasn't being passed through correctly,
+  UTC was being used in every case. Fixes issue 10.
+
+0.1.3
+-----
+
+* Fixed the microsecond handling, the generated microsecond values were 
+  way too small. Fixes issue 9.
+
+0.1.2
+-----
+
+* Adding ParseError to __all__ in iso8601 module, allows people to import it.
+  Addresses issue 7.
+* Be a little more flexible when dealing with dates without leading zeroes.
+  This violates the spec a little, but handles more dates as seen in the 
+  field. Addresses issue 6.
+* Allow date/time separators other than T.
+
+0.1.1
+-----
+
+* When parsing dates without a timezone the specified default is used. If no
+  default is specified then UTC is used. Addresses issue 4.
+"""
+
+setup(
+    name="iso8601",
+    version="0.1.4",
+    description=long_description.split("\n")[0],
+    long_description=long_description,
+    author="Michael Twomey",
+    author_email="[e-mail]",
+    url="http://code.google.com/p/pyiso8601/",
+    packages=["iso8601"],
+    license="MIT",
+)

=== added file 'test/python/iso8601/test_iso8601.py'
--- test/python/iso8601/test_iso8601.py	1970-01-01 00:00:00 +0000
+++ test/python/iso8601/test_iso8601.py	2011-06-10 09:54:56 +0000
@@ -0,0 +1,111 @@
+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

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

=== added directory 'test/python/junitxml/tests'
=== added file 'test/python/junitxml/tests/__init__.py'
--- test/python/junitxml/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ test/python/junitxml/tests/__init__.py	2011-06-10 09:54:56 +0000
@@ -0,0 +1,16 @@
+#
+#  junitxml: extensions to Python unittest to get output junitxml
+#  Copyright (C) 2009 Robert Collins <[e-mail]>
+#
+#  Copying permitted under the LGPL-3 licence, included with this library.
+
+import unittest
+
+from junitxml.tests import (
+    test_junitxml,
+    )
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromNames([
+        'junitxml.tests.test_junitxml',
+        ])

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

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

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

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

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

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

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

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

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

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

=== added file 'test/python/subunit/tests/sample-script.py'
--- test/python/subunit/tests/sample-script.py	1970-01-01 00:00:00 +0000
+++ test/python/subunit/tests/sample-script.py	2011-06-10 09:54:56 +0000
@@ -0,0 +1,21 @@
+#!/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)

=== added file 'test/python/subunit/tests/sample-two-script.py'
--- test/python/subunit/tests/sample-two-script.py	1970-01-01 00:00:00 +0000
+++ test/python/subunit/tests/sample-two-script.py	2011-06-10 09:54:56 +0000
@@ -0,0 +1,7 @@
+#!/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)

=== added file 'test/python/subunit/tests/test_chunked.py'
--- test/python/subunit/tests/test_chunked.py	1970-01-01 00:00:00 +0000
+++ test/python/subunit/tests/test_chunked.py	2011-06-10 09:54:56 +0000
@@ -0,0 +1,152 @@
+#
+#  subunit: extensions to python unittest to get test results from subprocesses.
+#  Copyright (C) 2005  Robert Collins <[e-mail]>
+#  Copyright (C) 2011  Martin Pool <[e-mail]>
+#
+#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
+#  license at the users choice. A copy of both licenses are available in the
+#  project source as Apache-2.0 and BSD. You may not use this file except in
+#  compliance with one of these two licences.
+#  
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+#  license you chose for the specific language governing permissions and
+#  limitations under that license.
+#
+
+import unittest
+
+from testtools.compat import _b, BytesIO
+
+import subunit.chunked
+
+
+def test_suite():
+    loader = subunit.tests.TestUtil.TestLoader()
+    result = loader.loadTestsFromName(__name__)
+    return result
+
+
+class TestDecode(unittest.TestCase):
+
+    def setUp(self):
+        unittest.TestCase.setUp(self)
+        self.output = BytesIO()
+        self.decoder = subunit.chunked.Decoder(self.output)
+
+    def test_close_read_length_short_errors(self):
+        self.assertRaises(ValueError, self.decoder.close)
+
+    def test_close_body_short_errors(self):
+        self.assertEqual(None, self.decoder.write(_b('2\r\na')))
+        self.assertRaises(ValueError, self.decoder.close)
+
+    def test_close_body_buffered_data_errors(self):
+        self.assertEqual(None, self.decoder.write(_b('2\r')))
+        self.assertRaises(ValueError, self.decoder.close)
+
+    def test_close_after_finished_stream_safe(self):
+        self.assertEqual(None, self.decoder.write(_b('2\r\nab')))
+        self.assertEqual(_b(''), self.decoder.write(_b('0\r\n')))
+        self.decoder.close()
+
+    def test_decode_nothing(self):
+        self.assertEqual(_b(''), self.decoder.write(_b('0\r\n')))
+        self.assertEqual(_b(''), self.output.getvalue())
+
+    def test_decode_serialised_form(self):
+        self.assertEqual(None, self.decoder.write(_b("F\r\n")))
+        self.assertEqual(None, self.decoder.write(_b("serialised\n")))
+        self.assertEqual(_b(''), self.decoder.write(_b("form0\r\n")))
+
+    def test_decode_short(self):
+        self.assertEqual(_b(''), self.decoder.write(_b('3\r\nabc0\r\n')))
+        self.assertEqual(_b('abc'), self.output.getvalue())
+
+    def test_decode_combines_short(self):
+        self.assertEqual(_b(''), self.decoder.write(_b('6\r\nabcdef0\r\n')))
+        self.assertEqual(_b('abcdef'), self.output.getvalue())
+
+    def test_decode_excess_bytes_from_write(self):
+        self.assertEqual(_b('1234'), self.decoder.write(_b('3\r\nabc0\r\n1234')))
+        self.assertEqual(_b('abc'), self.output.getvalue())
+
+    def test_decode_write_after_finished_errors(self):
+        self.assertEqual(_b('1234'), self.decoder.write(_b('3\r\nabc0\r\n1234')))
+        self.assertRaises(ValueError, self.decoder.write, _b(''))
+
+    def test_decode_hex(self):
+        self.assertEqual(_b(''), self.decoder.write(_b('A\r\n12345678900\r\n')))
+        self.assertEqual(_b('1234567890'), self.output.getvalue())
+
+    def test_decode_long_ranges(self):
+        self.assertEqual(None, self.decoder.write(_b('10000\r\n')))
+        self.assertEqual(None, self.decoder.write(_b('1' * 65536)))
+        self.assertEqual(None, self.decoder.write(_b('10000\r\n')))
+        self.assertEqual(None, self.decoder.write(_b('2' * 65536)))
+        self.assertEqual(_b(''), self.decoder.write(_b('0\r\n')))
+        self.assertEqual(_b('1' * 65536 + '2' * 65536), self.output.getvalue())
+
+    def test_decode_newline_nonstrict(self):
+        """Tolerate chunk markers with no CR character."""
+        # From <http://pad.lv/505078>
+        self.decoder = subunit.chunked.Decoder(self.output, strict=False)
+        self.assertEqual(None, self.decoder.write(_b('a\n')))
+        self.assertEqual(None, self.decoder.write(_b('abcdeabcde')))
+        self.assertEqual(_b(''), self.decoder.write(_b('0\n')))
+        self.assertEqual(_b('abcdeabcde'), self.output.getvalue())
+
+    def test_decode_strict_newline_only(self):
+        """Reject chunk markers with no CR character in strict mode."""
+        # From <http://pad.lv/505078>
+        self.assertRaises(ValueError,
+            self.decoder.write, _b('a\n'))
+
+    def test_decode_strict_multiple_crs(self):
+        self.assertRaises(ValueError,
+            self.decoder.write, _b('a\r\r\n'))
+
+    def test_decode_short_header(self):
+        self.assertRaises(ValueError,
+            self.decoder.write, _b('\n'))
+
+
+class TestEncode(unittest.TestCase):
+
+    def setUp(self):
+        unittest.TestCase.setUp(self)
+        self.output = BytesIO()
+        self.encoder = subunit.chunked.Encoder(self.output)
+
+    def test_encode_nothing(self):
+        self.encoder.close()
+        self.assertEqual(_b('0\r\n'), self.output.getvalue())
+
+    def test_encode_empty(self):
+        self.encoder.write(_b(''))
+        self.encoder.close()
+        self.assertEqual(_b('0\r\n'), self.output.getvalue())
+
+    def test_encode_short(self):
+        self.encoder.write(_b('abc'))
+        self.encoder.close()
+        self.assertEqual(_b('3\r\nabc0\r\n'), self.output.getvalue())
+
+    def test_encode_combines_short(self):
+        self.encoder.write(_b('abc'))
+        self.encoder.write(_b('def'))
+        self.encoder.close()
+        self.assertEqual(_b('6\r\nabcdef0\r\n'), self.output.getvalue())
+
+    def test_encode_over_9_is_in_hex(self):
+        self.encoder.write(_b('1234567890'))
+        self.encoder.close()
+        self.assertEqual(_b('A\r\n12345678900\r\n'), self.output.getvalue())
+
+    def test_encode_long_ranges_not_combined(self):
+        self.encoder.write(_b('1' * 65536))
+        self.encoder.write(_b('2' * 65536))
+        self.encoder.close()
+        self.assertEqual(_b('10000\r\n' + '1' * 65536 + '10000\r\n' +
+            '2' * 65536 + '0\r\n'), self.output.getvalue())

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

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

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

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

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

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