mhs-xapian 1.0.18a

data/python/smoketest.py

@@ -0,0 +1,328 @@
+# Simple test to ensure that we can load the xapian module and exercise basic
+# functionality successfully.
+#
+# Copyright (C) 2004,2005,2006,2007 Olly Betts
+# Copyright (C) 2007 Lemur Consulting Ltd
+#
+# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+# USA
+
+import sys
+import xapian
+
+from testsuite import *
+
+def test_all():
+    # Test the version number reporting functions give plausible results.
+    v = "%d.%d.%d" % (xapian.major_version(),
+                      xapian.minor_version(),
+                      xapian.revision())
+    v2 = xapian.version_string()
+    expect(v2, v, "Unexpected version output")
+
+    stem = xapian.Stem("english")
+    expect(stem.get_description(), "Xapian::Stem(english)", "Unexpected stem.get_description()")
+
+    doc = xapian.Document()
+    doc.set_data("a\0b")
+    if doc.get_data() == "a":
+        raise TestFail("get_data+set_data truncates at a zero byte")
+    expect(doc.get_data(), "a\0b", "get_data+set_data doesn't transparently handle a zero byte")
+    doc.set_data("is there anybody out there?")
+    doc.add_term("XYzzy")
+    doc.add_posting(stem("is"), 1)
+    doc.add_posting(stem("there"), 2)
+    doc.add_posting(stem("anybody"), 3)
+    doc.add_posting(stem("out"), 4)
+    doc.add_posting(stem("there"), 5)
+
+    db = xapian.inmemory_open()
+    db.add_document(doc)
+    expect(db.get_doccount(), 1, "Unexpected db.get_doccount()")
+    terms = ["smoke", "test", "terms"]
+    expect_query(xapian.Query(xapian.Query.OP_OR, terms),
+                 "(smoke OR test OR terms)")
+    query1 = xapian.Query(xapian.Query.OP_PHRASE, ("smoke", "test", "tuple"))
+    query2 = xapian.Query(xapian.Query.OP_XOR, (xapian.Query("smoke"), query1, "string"))
+    expect_query(query1, "(smoke PHRASE 3 test PHRASE 3 tuple)")
+    expect_query(query2, "(smoke XOR (smoke PHRASE 3 test PHRASE 3 tuple) XOR string)")
+    subqs = ["a", "b"]
+    expect_query(xapian.Query(xapian.Query.OP_OR, subqs), "(a OR b)")
+    expect_query(xapian.Query(xapian.Query.OP_VALUE_RANGE, 0, '1', '4'),
+                 "VALUE_RANGE 0 1 4")
+
+    # Feature test for Query.__iter__
+    term_count = 0
+    for term in query2:
+        term_count += 1
+    expect(term_count, 4, "Unexpected number of terms in query2")
+
+    enq = xapian.Enquire(db)
+    enq.set_query(xapian.Query(xapian.Query.OP_OR, "there", "is"))
+    mset = enq.get_mset(0, 10)
+    expect(mset.size(), 1, "Unexpected mset.size()")
+
+    # Feature test for Enquire.matching_terms(docid)
+    term_count = 0
+    for term in enq.matching_terms(mset.get_hit(0)):
+        term_count += 1
+    expect(term_count, 2, "Unexpected number of matching terms")
+
+    # Feature test for MSet.__iter__
+    msize = 0
+    for match in mset:
+        msize += 1
+    expect(msize, mset.size(), "Unexpected number of entries in mset")
+
+    terms = " ".join(enq.matching_terms(mset.get_hit(0)))
+    expect(terms, "is there", "Unexpected terms")
+
+    # Feature test for ESet.__iter__
+    rset = xapian.RSet()
+    rset.add_document(1)
+    eset = enq.get_eset(10, rset)
+    term_count = 0
+    for term in eset:
+        term_count += 1
+    expect(term_count, 3, "Unexpected number of expand terms")
+
+    # Feature test for Database.__iter__
+    term_count = 0
+    for term in db:
+        term_count += 1
+    expect(term_count, 5, "Unexpected number of terms in db")
+
+    # Feature test for Database.allterms
+    term_count = 0
+    for term in db.allterms():
+        term_count += 1
+    expect(term_count, 5, "Unexpected number of terms in db.allterms")
+
+    # Feature test for Database.postlist
+    count = 0
+    for posting in db.postlist("there"):
+        count += 1
+    expect(count, 1, "Unexpected number of entries in db.postlist('there')")
+
+    # Feature test for Database.postlist with empty term (alldocspostlist)
+    count = 0
+    for posting in db.postlist(""):
+        count += 1
+    expect(count, 1, "Unexpected number of entries in db.postlist('')")
+
+    # Feature test for Database.termlist
+    count = 0
+    for term in db.termlist(1):
+        count += 1
+    expect(count, 5, "Unexpected number of entries in db.termlist(1)")
+
+    # Feature test for Database.positionlist
+    count = 0
+    for term in db.positionlist(1, "there"):
+        count += 1
+    expect(count, 2, "Unexpected number of entries in db.positionlist(1, 'there')")
+
+    # Feature test for Document.termlist
+    count = 0
+    for term in doc.termlist():
+        count += 1
+    expect(count, 5, "Unexpected number of entries in doc.termlist()")
+
+    # Feature test for TermIter.skip_to
+    term = doc.termlist()
+    term.skip_to('n')
+    while True:
+        try:
+            x = term.next()
+        except StopIteration:
+            break
+        if x.term < 'n':
+            raise TestFail("TermIter.skip_to didn't skip term '%s'" % x.term)
+
+    # Feature test for Document.values
+    count = 0
+    for term in doc.values():
+        count += 1
+    expect(count, 0, "Unexpected number of entries in doc.values")
+
+    # Check exception handling for Xapian::DocNotFoundError
+    expect_exception(xapian.DocNotFoundError, "Docid 3 not found", db.get_document, 3)
+
+    # Check value of OP_ELITE_SET
+    expect(xapian.Query.OP_ELITE_SET, 10, "Unexpected value for OP_ELITE_SET")
+
+    # Feature test for MatchDecider
+    doc = xapian.Document()
+    doc.set_data("Two")
+    doc.add_posting(stem("out"), 1)
+    doc.add_posting(stem("outside"), 1)
+    doc.add_posting(stem("source"), 2)
+    doc.add_value(0, "yes")
+    db.add_document(doc)
+
+    class testmatchdecider(xapian.MatchDecider):
+        def __call__(self, doc):
+            return doc.get_value(0) == "yes"
+
+    query = xapian.Query(stem("out"))
+    enquire = xapian.Enquire(db)
+    enquire.set_query(query)
+    mset = enquire.get_mset(0, 10, None, testmatchdecider())
+    expect(mset.size(), 1, "Unexpected number of documents returned by match decider")
+    expect(mset.get_docid(0), 2, "MatchDecider mset has wrong docid in")
+
+    # Feature test for ExpandDecider
+    class testexpanddecider(xapian.ExpandDecider):
+        def __call__(self, term):
+            return (not term.startswith('a'))
+
+    enquire = xapian.Enquire(db)
+    rset = xapian.RSet()
+    rset.add_document(1)
+    eset = enquire.get_eset(10, rset, xapian.Enquire.USE_EXACT_TERMFREQ, 1.0, testexpanddecider())
+    eset_terms = [term[xapian.ESET_TNAME] for term in eset.items]
+    expect(len(eset_terms), eset.size(), "Unexpected number of terms returned by expand")
+    if filter(lambda t: t.startswith('a'), eset_terms):
+        raise TestFail("ExpandDecider was not used")
+
+    # Check QueryParser parsing error.
+    qp = xapian.QueryParser()
+    expect_exception(xapian.QueryParserError, "Syntax: <expression> AND <expression>", qp.parse_query, "test AND")
+
+    # Check QueryParser pure NOT option
+    qp = xapian.QueryParser()
+    expect_query(qp.parse_query("NOT test", qp.FLAG_BOOLEAN + qp.FLAG_PURE_NOT),
+                 "(<alldocuments> AND_NOT test:(pos=1))")
+
+    # Check QueryParser partial option
+    qp = xapian.QueryParser()
+    qp.set_database(db)
+    qp.set_default_op(xapian.Query.OP_AND)
+    qp.set_stemming_strategy(qp.STEM_SOME)
+    qp.set_stemmer(xapian.Stem('en'))
+    expect_query(qp.parse_query("foo o", qp.FLAG_PARTIAL),
+                 "(Zfoo:(pos=1) AND (out:(pos=2) OR outsid:(pos=2) OR Zo:(pos=2)))")
+
+    expect_query(qp.parse_query("foo outside", qp.FLAG_PARTIAL),
+                 "(Zfoo:(pos=1) AND Zoutsid:(pos=2))")
+
+    # Test supplying unicode strings
+    expect_query(xapian.Query(xapian.Query.OP_OR, (u'foo', u'bar')),
+                 '(foo OR bar)')
+    expect_query(xapian.Query(xapian.Query.OP_OR, ('foo', u'bar\xa3')),
+                 '(foo OR bar\xc2\xa3)')
+    expect_query(xapian.Query(xapian.Query.OP_OR, ('foo', 'bar\xc2\xa3')),
+                 '(foo OR bar\xc2\xa3)')
+    expect_query(xapian.Query(xapian.Query.OP_OR, u'foo', u'bar'),
+                 '(foo OR bar)')
+
+    expect_query(qp.parse_query(u"NOT t\xe9st", qp.FLAG_BOOLEAN + qp.FLAG_PURE_NOT),
+                 "(<alldocuments> AND_NOT Zt\xc3\xa9st:(pos=1))")
+
+    doc = xapian.Document()
+    doc.set_data(u"Unicode with an acc\xe9nt")
+    doc.add_posting(stem(u"out\xe9r"), 1)
+    expect(doc.get_data(), u"Unicode with an acc\xe9nt".encode('utf-8'))
+    term = doc.termlist().next().term
+    expect(term, u"out\xe9r".encode('utf-8'))
+
+    # Check simple stopper
+    stop = xapian.SimpleStopper()
+    qp.set_stopper(stop)
+    expect(stop('a'), False)
+    expect_query(qp.parse_query(u"foo bar a", qp.FLAG_BOOLEAN),
+                 "(Zfoo:(pos=1) AND Zbar:(pos=2) AND Za:(pos=3))")
+
+    stop.add('a')
+    expect(stop('a'), True)
+    expect_query(qp.parse_query(u"foo bar a", qp.FLAG_BOOLEAN),
+                 "(Zfoo:(pos=1) AND Zbar:(pos=2))")
+
+    # Feature test for custom Stopper
+    class my_b_stopper(xapian.Stopper):
+        def __call__(self, term):
+            return term == "b"
+
+        def get_description(self):
+            return u"my_b_stopper"
+
+    stop = my_b_stopper()
+    expect(stop.get_description(), u"my_b_stopper")
+    qp.set_stopper(stop)
+    expect(stop('a'), False)
+    expect_query(qp.parse_query(u"foo bar a", qp.FLAG_BOOLEAN),
+                 "(Zfoo:(pos=1) AND Zbar:(pos=2) AND Za:(pos=3))")
+
+    expect(stop('b'), True)
+    expect_query(qp.parse_query(u"foo bar b", qp.FLAG_BOOLEAN),
+                 "(Zfoo:(pos=1) AND Zbar:(pos=2))")
+
+    # Test TermGenerator
+    termgen = xapian.TermGenerator()
+    doc = xapian.Document()
+    termgen.set_document(doc)
+    termgen.index_text('foo bar baz foo')
+    expect([(item.term, item.wdf, [pos for pos in item.positer]) for item in doc.termlist()], [('bar', 1, [2]), ('baz', 1, [3]), ('foo', 2, [1, 4])])
+
+
+    # Check DateValueRangeProcessor works
+    context("checking that DateValueRangeProcessor works")
+    qp = xapian.QueryParser()
+    vrpdate = xapian.DateValueRangeProcessor(1, 1, 1960)
+    qp.add_valuerangeprocessor(vrpdate)
+    query = qp.parse_query('12/03/99..12/04/01')
+    expect(str(query), 'Xapian::Query(VALUE_RANGE 1 19991203 20011204)')
+
+    # Regression test for bug#193, fixed in 1.0.3.
+    context("running regression test for bug#193")
+    vrp = xapian.NumberValueRangeProcessor(0, '$', True)
+    a = '$10'
+    b = '20'
+    slot, a, b = vrp(a, b)
+    expect(slot, 0)
+    expect(xapian.sortable_unserialise(a), 10)
+    expect(xapian.sortable_unserialise(b), 20)
+
+    # Regression tests copied from PHP (probably always worked in python, but
+    # let's check...)
+    context("running regression tests for issues which were found in PHP")
+
+    # PHP overload resolution involving boolean types failed.
+    enq.set_sort_by_value(1, True)
+
+    # Regression test - fixed in 0.9.10.1.
+    oqparser = xapian.QueryParser()
+    oquery = oqparser.parse_query("I like tea")
+
+    # Regression test for bug#192 - fixed in 1.0.3.
+    enq.set_cutoff(100)
+
+    # Test setting and getting metadata
+    expect(db.get_metadata('Foo'), '')
+    db.set_metadata('Foo', 'Foo')
+    expect(db.get_metadata('Foo'), 'Foo')
+    expect_exception(xapian.InvalidArgumentError, "Empty metadata keys are invalid", db.get_metadata, '')
+    expect_exception(xapian.InvalidArgumentError, "Empty metadata keys are invalid", db.set_metadata, '', 'Foo')
+    expect_exception(xapian.InvalidArgumentError, "Empty metadata keys are invalid", db.get_metadata, '')
+
+    # Test OP_SCALE_WEIGHT and corresponding constructor
+    expect_query(xapian.Query(xapian.Query.OP_SCALE_WEIGHT, xapian.Query('foo'), 5),
+                 "5 * foo")
+
+# Run all tests (ie, callables with names starting "test_").
+if not runtests(globals()):
+    sys.exit(1)
+
+# vim:syntax=python:set expandtab:

data/python/testsuite.py

@@ -0,0 +1,382 @@
+# Utility functions for running tests and reporting the results.
+#
+# Copyright (C) 2007 Lemur Consulting Ltd
+#
+# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+# USA
+
+import os as _os
+import os.path as _path
+import sys as _sys
+import traceback as _traceback
+import xapian as _xapian
+
+class TestFail(Exception):
+    pass
+
+class TestRunner(object):
+    def __init__(self):
+        """Initialise the TestRunner.
+
+        """
+
+        self._out = OutProxy(_sys.stdout)
+
+        # _verbose is an integer, higher meaning more verbose
+        self._verbose = _os.environ.get('VERBOSE', '').lower()
+        if self._verbose in ('', '0', 'no', 'off', 'false'):
+            self._verbose = 0
+        else:
+            try:
+                self._verbose = int(self._verbose)
+            except:
+                self._verbose = 1
+
+        # context is a description of what the test is currently checking
+        self._context = None
+
+    def context(self, context):
+        """Set the context.
+
+        This should be a string describing what a test is checking, and will be
+        displayed if the test fails.
+
+        A test may change the context several times - each call will override
+        subsequent calls.
+
+        Set the context to None to remove display of a specific context message.
+        This is performed automatically at the start of each test.
+
+        """
+        self._context = context
+        if context is not None and self._verbose > 1:
+            self._out.start_line()
+            self._out.write("Context: %s\n" % context)
+            self._out.flush()
+
+    def expect(self, got, expected, message="Expected equality"):
+        """Function used to check for a particular expected value.
+
+        """
+        if self._verbose > 2:
+            self._out.start_line()
+            self._out.write("Checking for %r: expecting %r ... " % (message, expected))
+            self._out.flush()
+        if got != expected:
+            if self._verbose > 2:
+                self._out.write_colour(" #red#failed##")
+                self._out.write(": got %r\n" % got)
+                self._out.flush()
+            raise TestFail("%s: got %r, expected %r" % (message, got, expected))
+        if self._verbose > 2:
+            self._out.write_colour(" #green#ok##\n")
+            self._out.flush()
+
+    def expect_query(self, query, expected):
+        """Check that the description of a query is as expected.
+
+        """
+	expected = 'Xapian::Query(' + expected + ')'
+        desc = query.get_description()
+        if self._verbose > 2:
+            self._out.start_line()
+            self._out.write("Checking query.get_description(): expecting %r ... " % expected)
+            self._out.flush()
+        if desc != expected:
+            if self._verbose > 2:
+                self._out.write_colour(" #red#failed##")
+                self._out.write(": got %r\n" % desc)
+                self._out.flush()
+            raise TestFail("Unexpected query.get_description(): got %r, expected %r" % (desc, expected))
+        if self._verbose > 2:
+            self._out.write_colour(" #green#ok##\n")
+            self._out.flush()
+
+    def expect_exception(self, expectedclass, expectedmsg, callable, *args):
+        if self._verbose > 2:
+            self._out.start_line()
+            self._out.write("Checking for exception: %s(%r) ... " % (str(expectedclass), expectedmsg))
+            self._out.flush()
+        try:
+            callable(*args)
+            if self._verbose > 2:
+                self._out.write_colour(" #red#failed##: no exception occurred\n")
+                self._out.flush()
+            raise TestFail("Expected %s(%r) exception" % (str(expectedclass), expectedmsg))
+        except expectedclass, e:
+            if str(e) != expectedmsg:
+                if self._verbose > 2:
+                    self._out.write_colour(" #red#failed##")
+                    self._out.write(": exception string not as expected: got '%s'\n" % str(e))
+                    self._out.flush()
+                raise TestFail("Exception string not as expected: got '%s', expected '%s'" % (str(e), expectedmsg))
+            if e.__class__ != expectedclass:
+                if self._verbose > 2:
+                    self._out.write_colour(" #red#failed##")
+                    self._out.write(": didn't get right exception class: got '%s'\n" % str(e.__class__))
+                    self._out.flush()
+                raise TestFail("Didn't get right exception class: got '%s', expected '%s'" % (str(e.__class__), str(expectedclass)))
+        if self._verbose > 2:
+            self._out.write_colour(" #green#ok##\n")
+            self._out.flush()
+
+    def report_failure(self, name, msg, show_traceback=True):
+        "Report a test failure, with some useful context."
+
+        orig_tb = _traceback.extract_tb(_sys.exc_info()[2])
+        tb = orig_tb
+
+        # Move up the traceback until we get to the line in the test
+        # function which caused the failure.
+        while tb[-1][2] != 'test_' + name:
+            tb = tb[:-1]
+
+        # Display the context in the text function.
+        filepath, linenum, functionname, text = tb[-1]
+        filename = _os.path.basename(filepath)
+
+        self._out.ensure_space()
+        self._out.write_colour("#red#FAILED##\n")
+        if self._verbose > 0:
+            if self._context is None:
+                context = ''
+            else:
+                context = ", when %s" % self._context
+            firstline = "%s:%d" % (filename, linenum)
+            self._out.write("\n%s:%s%s\n" % (firstline, msg, context))
+
+            # Display sourcecode lines
+            lines = open(filepath).readlines()
+            startline = max(linenum - 3, 0)
+            endline = min(linenum + 2, len(lines))
+            for num in xrange(startline, endline):
+                if num + 1 == linenum:
+                    self._out.write('->')
+                else:
+                    self._out.write('  ')
+                self._out.write("%4d %s\n" % (num + 1, lines[num].rstrip()))
+
+            # Display the traceback
+            if show_traceback:
+                self._out.write("Traceback (most recent call last):\n")
+                for line in _traceback.format_list(orig_tb):
+                    self._out.write(line.rstrip() + '\n')
+                self._out.write('\n')
+
+            # Display some information about the xapian version and platform
+            self._out.write("Xapian version: %s\n" % _xapian.version_string())
+            try:
+                import platform
+                platdesc = "%s %s (%s)" % platform.system_alias(platform.system(),
+                                                                platform.release(),
+                                                                platform.version())
+                self._out.write("Platform: %s\n" % platdesc)
+            except:
+                pass
+            self._out.write('\nWhen reporting this problem, please quote all the preceding lines from\n"%s" onwards.\n\n' % firstline)
+
+        self._out.flush()
+
+    def runtest(self, name, test_fn):
+        """Run a single test.
+    
+        """
+        startline = "Running test: %s..." % name
+        self._out.write(startline)
+        self._out.flush()
+        try:
+            test_fn()
+            if self._verbose > 0 or self._out.plain:
+                self._out.ensure_space()
+                self._out.write_colour("#green#ok##\n")
+            else:
+                self._out.clear_line()
+            self._out.flush()
+            return True
+        except TestFail, e:
+            self.report_failure(name, str(e), show_traceback=False)
+        except _xapian.Error, e:
+            self.report_failure(name, "%s: %s" % (str(e.__class__), str(e)))
+        except Exception, e:
+            self.report_failure(name, "%s: %s" % (str(e.__class__), str(e)))
+        return False
+
+    def runtests(self, namedict, runonly=None):
+        """Run a set of tests.
+    
+        Takes a dictionary of name-value pairs and runs all the values which are
+        callables, for which the name begins with "test_".
+
+        Typical usage is to pass "locals()" as the parameter, to run all callables
+        with names starting "test_" in local scope.
+
+        If runonly is supplied, and non-empty, only those tests which appear in
+        runonly will be run.
+
+        """
+        tests = []
+        if isinstance(namedict, dict):
+            for name in namedict:
+                if name.startswith('test_'):
+                    fn = namedict[name]
+                    name = name[5:]
+                    if callable(fn):
+                        tests.append((name, fn))
+            tests.sort()
+        else:
+            tests = namedict
+
+        if runonly is not None and len(runonly) != 0:
+            oldtests = tests
+            tests = []
+            for name, fn in oldtests:
+                if name in runonly:
+                    tests.append((name, fn))
+
+        passed, failed = 0, 0
+        for name, fn in tests:
+            self.context(None)
+            if self.runtest(name, fn):
+                passed += 1
+            else:
+                failed += 1
+        if failed:
+            if self._verbose == 0:
+                self._out.write('Re-run with the VERBOSE environment variable set to "1" to see details.\n')
+            self._out.write_colour("#green#%d## tests passed, #red#%d## tests failed\n" % (passed, failed))
+            return False
+        else:
+            self._out.write_colour("#green#%d## tests passed, no failures\n" % passed)
+            return True
+
+class OutProxy(object):
+    """Proxy output class to make formatting easier.
+
+    Allows colourisation, and keeps track of whether we're mid-line or not.
+
+    """
+
+    def __init__(self, out):
+        self._out = out
+        self._line_pos = 0 # Position on current line
+        self._had_space = True # True iff we're preceded by whitespace (including newline)
+        self.plain = not self._allow_control_sequences()
+        self._colours = self.get_colour_strings()
+
+    def _allow_control_sequences(self):
+        "Return True if output device allows control sequences."
+        mode = _os.environ.get("XAPIAN_TESTSUITE_OUTPUT", '').lower()
+        if mode in ('', 'auto'):
+            if _sys.platform == 'win32':
+                return False
+            elif not hasattr(self._out, "isatty"):
+                return False
+            else:
+                return self._out.isatty()
+        elif mode == 'plain':
+            return False
+        return True
+
+    def get_colour_strings(self):
+        """Return a mapping of colour names to colour output sequences.
+
+        """
+        colours = {
+            'red': "\x1b[1m\x1b[31m",
+            'green': "\x1b[1m\x1b[32m",
+            'yellow': "\x1b[1m\x1b[33m",
+            '': "\x1b[0m",
+        }
+        if self.plain:
+            for key in colours:
+                colours[key] = ''
+        return colours
+
+    def _colourise(self, msg):
+        """Apply colours to a message.
+
+        #colourname# will change the text colour, ## will change the colour back.
+
+        """
+        for colour, val in self._colours.iteritems():
+            msg = msg.replace('#%s#' % colour, val)
+        return msg
+
+    def clear_line(self):
+        """Clear the current line of output, if possible.
+
+        Otherwise, just move to the start of the next line.
+
+        """
+        if self._line_pos == 0:
+            return
+        if self.plain:
+            self.write('\n')
+        else:
+            self.write("\r" + " " * self._line_pos + "\r")
+
+    def start_line(self):
+        """Ensure that we're at the start of a line.
+
+        """
+        if self._line_pos != 0:
+            self.write('\n')
+
+    def ensure_space(self):
+        """Ensure that we're preceded by whitespace.
+
+        """
+        if not self._had_space:
+            self.write(' ')
+
+    def write(self, msg):
+        """Write the message to the output stream.
+
+        """
+        if len(msg) == 0:
+            return
+
+        # Adjust the line position counted
+        nlpos = max(msg.rfind('\n'), msg.rfind('\r'))
+        if nlpos >= 0:
+            subline = msg[nlpos + 1:]
+            self._line_pos = len(subline) # Note - doesn't cope with tabs.
+        else:
+            self._line_pos += len(msg) # Note - doesn't cope with tabs.
+
+        # Record whether we ended with whitespace
+        self._had_space = msg[-1].isspace()
+
+        self._out.write(msg)
+
+    def write_colour(self, msg):
+        """Write a message, first substituting markup for colours.
+
+        """
+        self.write(self._colourise(msg))
+
+    def flush(self):
+        self._out.flush()
+
+
+_runner = TestRunner()
+context = _runner.context
+expect = _runner.expect
+expect_query = _runner.expect_query
+expect_exception = _runner.expect_exception
+runtests = _runner.runtests
+
+__all__ = ('context', 'expect', 'expect_query', 'expect_exception', 'runtests')
+