Revert change to django/test/_doctest.py

# Option constants.

OPTIONFLAGS_BY_NAME = {}

def register_optionflag(name):

    # Create a new flag unless `name` is already known.

    return OPTIONFLAGS_BY_NAME.setdefault(name, 1 << len(OPTIONFLAGS_BY_NAME))

## 1. Utility Functions

######################################################################

def _extract_future_flags(globs):

    """

    Return the compiler-flags associated with the future features that

            flags |= feature.compiler_flag

    return flags

def _normalize_module(module, depth=2):

    """

    Return the module specified by `module`.  In particular:

    else:

        raise TypeError("Expected a module, string, or None")

def _load_testfile(filename, package, module_relative):

    if module_relative:

        package = _normalize_module(package, 3)

    with open(filename) as fp:

        return fp.read(), filename

def _indent(s, indent=4):

    """

    Add the given number of space characters to the beginning every

    # This regexp matches the start of non-blank lines:

    return re.sub('(?m)^(?!$)', indent*' ', s)

def _exception_traceback(exc_info):

    """

    Return a string containing a traceback message for the given

    traceback.print_exception(exc_type, exc_val, exc_tb, file=excout)

    return excout.getvalue()

# Override some StringIO methods.

class _SpoofOut(StringIO):

    def getvalue(self):

        if hasattr(self, "softspace"):

            del self.softspace

# Worst-case linear-time ellipsis matching.

def _ellipsis_match(want, got):

    """

    return True

def _comment_line(line):

    "Return a commented form of the given line"

    line = line.rstrip()

    else:

        return '#'

class _OutputRedirectingPdb(pdb.Pdb):

    """

    A specialized version of the python debugger that redirects stdout

        finally:

            sys.stdout = save_stdout

# [XX] Normalize with respect to os.path.pardir?

def _module_relative_path(module, path):

    if not inspect.ismodule(module):

##   a string (such as an object's docstring).  The DocTest class also

##   includes information about where the string was extracted from.

class Example:

    """

    A single doctest example, consisting of source code and expected

        self.options = options

        self.exc_msg = exc_msg

class DocTest:

    """

    A collection of doctest examples that should be run in a single

        return ('<DocTest %s from %s:%s (%s)>' %

                (self.name, self.filename, self.lineno, examples))

    # This lets us sort tests by name:

    def _cmpkey(self):

        return (self.name, self.filename, self.lineno, id(self))

    def __cmp__(self, other):

        if not isinstance(other, DocTest):

            return -1

## 5. DocTest Runner

######################################################################

class DocTestRunner:

    """

    A class used to run DocTest test cases, and accumulate statistics.

    __LINECACHE_FILENAME_RE = re.compile(r'<doctest '

                                         r'(?P<name>[\w\.]+)'

                                         r'\[(?P<examplenum>\d+)\]>$')

    def __patched_linecache_getlines(self, filename, module_globals=None):

        m = self.__LINECACHE_FILENAME_RE.match(filename)

        if m and m.group('name') == self.test.name:

                t = t + t2

            d[name] = f, t

class OutputChecker:

    """

    A class used to check the whether the actual output from a doctest

        else:

            return 'Expected nothing\nGot nothing\n'

class DocTestFailure(Exception):

    """A DocTest example has failed in debugging mode.

    def __str__(self):

        return str(self.test)

class UnexpectedException(Exception):

    """A DocTest example has encountered an unexpected exception

    def __str__(self):

        return str(self.test)

class DebugRunner(DocTestRunner):

    r"""Run doc tests but raise an exception as soon as there is a failure.

# class, updated by testmod.

master = None

def testmod(m=None, name=None, globs=None, verbose=None,

            report=True, optionflags=0, extraglobs=None,

            raise_on_error=False, exclude_empty=False):

    return runner.failures, runner.tries

def testfile(filename, module_relative=True, name=None, package=None,

             globs=None, verbose=None, report=True, optionflags=0,

             extraglobs=None, raise_on_error=False, parser=DocTestParser(),

    return runner.failures, runner.tries

def run_docstring_examples(f, globs, verbose=False, name="NoName",

                           compileflags=None, optionflags=0):

    """

# This is provided only for backwards compatibility.  It's not

# actually used in any way.

class Tester:

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

_unittest_reportflags = 0

def set_unittest_reportflags(flags):

    """Sets the unittest option flags.

    def shortDescription(self):

        return "Doctest: " + self._dt_test.name

def DocTestSuite(module=None, globs=None, extraglobs=None, test_finder=None,

                 test_class=DocTestCase, **options):

    """

    return suite

class DocFileCase(DocTestCase):

    def id(self):

                % (self._dt_test.name, self._dt_test.filename, err)

                )

def DocFileTest(path, module_relative=True, package=None,

                globs=None, parser=DocTestParser(),

                encoding=None, **options):

    test = parser.get_doctest(doc, globs, name, path, 0)

    return DocFileCase(test, **options)

def DocFileSuite(*paths, **kw):

    """A unittest suite for one or more doctest files.

## 9. Debugging Support

######################################################################

def script_from_examples(s):

    r"""Extract script from text with examples.

    # Combine the output, and return it.

    return '\n'.join(output)

def testsource(module, name):

    """Extract the test sources from a doctest docstring as a script.

    testsrc = script_from_examples(test.docstring)

    return testsrc

def debug_src(src, pm=False, globs=None):

    """Debug a single doctest docstring, in argument `src`'"""

    testsrc = script_from_examples(src)

    debug_script(testsrc, pm, globs)

def debug_script(src, pm=False, globs=None):

    "Debug a test script.  `src` is the script, as a string."

    import pdb

    finally:

        os.remove(srcfilename)

def debug(module, name, pm=False):

    """Debug a single doctest docstring.

######################################################################

## 10. Example Usage

######################################################################

class _TestClass:

    """

    A pointless class, for sanity-checking of docstring testing.

            """,

           }

def _test():

    r = unittest.TextTestRunner()

    r.run(DocTestSuite())