class DebugRunner(compat.doctest.DocTestRunner):

def __init__(self, checker=None, verbose=None, optionflags=0):

    """

        Create a new test runner.

        Optional keyword arg `checker` is the `OutputChecker` that

        should be used to compare the expected outputs and actual

        outputs of doctest examples.

        Optional keyword arg 'verbose' prints lots of stuff if true,

        only failures if false; by default, it's true iff '-v' is in

        sys.argv.

        Optional argument `optionflags` can be used to control how the

        test runner compares expected output to actual output, and how

        it displays failures.  See the documentation for `testmod` for

        more information.

        """

    self._checker = checker or OutputChecker()

    if verbose is None:

        verbose = '-v' in sys.argv

    self._verbose = verbose

    self.optionflags = optionflags

    self.original_optionflags = optionflags

    # Keep track of the examples we've run.

    self.tries = 0

    self.failures = 0

    self._name2ft = {}

    # Create a fake output target for capturing doctest output.

    self._fakeout = _SpoofOut()

def merge(self, other):

    d = self._name2ft

    for name, (f, t) in other._name2ft.items():

        if name in d:

            print "*** DocTestRunner.merge: '" + name + "' in both" \

                " testers; summing outcomes."

            f2, t2 = d[name]

            f = f + f2

            t = t + t2

        d[name] = f, t

def report_failure(self, out, test, example, got):

    raise DocTestFailure(test, example, got)

def report_start(self, out, test, example):

    """

        Report that the test runner is about to process the given

        example.  (Only displays a message if verbose=True)

        """

    if self._verbose:

        if example.want:

            out('Trying:\n' + _indent(example.source) +

                'Expecting:\n' + _indent(example.want))

        else:

            out('Trying:\n' + _indent(example.source) +

                'Expecting nothing\n')

def report_success(self, out, test, example, got):

    """

        Report that the given example ran successfully.  (Only

        displays a message if verbose=True)

        """

    if self._verbose:

        out("ok\n")

def report_unexpected_exception(self, out, test, example, exc_info):

    raise UnexpectedException(test, example, exc_info)

def run(self, test, compileflags=None, out=None, clear_globs=True):

    r = DocTestRunner.run(self, test, compileflags, out, False)

    if clear_globs:

        test.globs.clear()

    return r

def summarize(self, verbose=None):

    """

        Print a summary of all the test cases that have been run by

        this DocTestRunner, and return a tuple `(f, t)`, where `f` is

        the total number of failed examples, and `t` is the total

        number of tried examples.

        The optional `verbose` argument controls how detailed the

        summary is.  If the verbosity is not specified, then the

        DocTestRunner's verbosity is used.

        """

    if verbose is None:

        verbose = self._verbose

    notests = []

    passed = []

    failed = []

    totalt = totalf = 0

    for x in self._name2ft.items():

        name, (f, t) = x

        assert f <= t

        totalt += t

        totalf += f

        if t == 0:

            notests.append(name)

        elif f == 0:

            passed.append( (name, t) )

        else:

            failed.append(x)

    if verbose:

        if notests:

            print len(notests), "items had no tests:"

            notests.sort()

            for thing in notests:

                print "   ", thing

        if passed:

            print len(passed), "items passed all tests:"

            passed.sort()

            for thing, count in passed:

                print " %3d tests in %s" % (count, thing)

    if failed:

        print self.DIVIDER

        print len(failed), "items had failures:"

        failed.sort()

        for thing, (f, t) in failed:

            print " %3d of %3d in %s" % (f, t, thing)

    if verbose:

        print totalt, "tests in", len(self._name2ft), "items."

        print totalt - totalf, "passed and", totalf, "failed."

    if totalf:

        print "***Test Failed***", totalf, "failures."

    elif verbose:

        print "Test passed."

    return totalf, totalt