Freelog 116/FreelogNo116-JuilletSeptembre2013.iso/GestionFichiers/metamorphose/metamorphose2_0.8.2_setup.exe/metamorphose2.exe/doctest.pyo

Python Compiled Bytecode | 2011-01-12 | 43KB | 1,327 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

__docformat__ = 'reStructuredText en'
__all__ = [
    'register_optionflag',
    'DONT_ACCEPT_TRUE_FOR_1',
    'DONT_ACCEPT_BLANKLINE',
    'NORMALIZE_WHITESPACE',
    'ELLIPSIS',
    'SKIP',
    'IGNORE_EXCEPTION_DETAIL',
    'COMPARISON_FLAGS',
    'REPORT_UDIFF',
    'REPORT_CDIFF',
    'REPORT_NDIFF',
    'REPORT_ONLY_FIRST_FAILURE',
    'REPORTING_FLAGS',
    'Example',
    'DocTest',
    'DocTestParser',
    'DocTestFinder',
    'DocTestRunner',
    'OutputChecker',
    'DocTestFailure',
    'UnexpectedException',
    'DebugRunner',
    'testmod',
    'testfile',
    'run_docstring_examples',
    'Tester',
    'DocTestSuite',
    'DocFileSuite',
    'set_unittest_reportflags',
    'script_from_examples',
    'testsource',
    'debug_src',
    'debug']
import __future__
import sys
import traceback
import inspect
import linecache
import os
import re
import unittest
import difflib
import pdb
import tempfile
import warnings
from StringIO import StringIO
from collections import namedtuple
TestResults = namedtuple('TestResults', 'failed attempted')
OPTIONFLAGS_BY_NAME = { }

def register_optionflag(name):
    return OPTIONFLAGS_BY_NAME.setdefault(name, 1 << len(OPTIONFLAGS_BY_NAME))

DONT_ACCEPT_TRUE_FOR_1 = register_optionflag('DONT_ACCEPT_TRUE_FOR_1')
DONT_ACCEPT_BLANKLINE = register_optionflag('DONT_ACCEPT_BLANKLINE')
NORMALIZE_WHITESPACE = register_optionflag('NORMALIZE_WHITESPACE')
ELLIPSIS = register_optionflag('ELLIPSIS')
SKIP = register_optionflag('SKIP')
IGNORE_EXCEPTION_DETAIL = register_optionflag('IGNORE_EXCEPTION_DETAIL')
COMPARISON_FLAGS = DONT_ACCEPT_TRUE_FOR_1 | DONT_ACCEPT_BLANKLINE | NORMALIZE_WHITESPACE | ELLIPSIS | SKIP | IGNORE_EXCEPTION_DETAIL
REPORT_UDIFF = register_optionflag('REPORT_UDIFF')
REPORT_CDIFF = register_optionflag('REPORT_CDIFF')
REPORT_NDIFF = register_optionflag('REPORT_NDIFF')
REPORT_ONLY_FIRST_FAILURE = register_optionflag('REPORT_ONLY_FIRST_FAILURE')
REPORTING_FLAGS = REPORT_UDIFF | REPORT_CDIFF | REPORT_NDIFF | REPORT_ONLY_FIRST_FAILURE
BLANKLINE_MARKER = '<BLANKLINE>'
ELLIPSIS_MARKER = '...'

def _extract_future_flags(globs):
    flags = 0
    for fname in __future__.all_feature_names:
        feature = globs.get(fname, None)
        if feature is getattr(__future__, fname):
            flags |= feature.compiler_flag
            continue

    return flags


def _normalize_module(module, depth = 2):
    if inspect.ismodule(module):
        return module
    if isinstance(module, (str, unicode)):
        return __import__(module, globals(), locals(), [
            '*'])
    if module is None:
        return sys.modules[sys._getframe(depth).f_globals['__name__']]
    raise TypeError('Expected a module, string, or None')


def _load_testfile(filename, package, module_relative):
    if module_relative:
        package = _normalize_module(package, 3)
        filename = _module_relative_path(package, filename)
        if hasattr(package, '__loader__'):
            if hasattr(package.__loader__, 'get_data'):
                file_contents = package.__loader__.get_data(filename)
                return (file_contents.replace(os.linesep, '\n'), filename)


    return (open(filename).read(), filename)

if not getattr(sys.__stdout__, 'encoding', None):
    pass
_encoding = 'utf-8'

def _indent(s, indent = 4):
    if isinstance(s, unicode):
        s = s.encode(_encoding, 'backslashreplace')

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


def _exception_traceback(exc_info):
    excout = StringIO()
    (exc_type, exc_val, exc_tb) = exc_info
    traceback.print_exception(exc_type, exc_val, exc_tb, file = excout)
    return excout.getvalue()


class _SpoofOut(StringIO):

    def getvalue(self):
        result = StringIO.getvalue(self)
        if result and not result.endswith('\n'):
            result += '\n'

        if hasattr(self, 'softspace'):
            del self.softspace

        return result


    def truncate(self, size = None):
        StringIO.truncate(self, size)
        if hasattr(self, 'softspace'):
            del self.softspace




def _ellipsis_match(want, got):
    if ELLIPSIS_MARKER not in want:
        return want == got
    ws = want.split(ELLIPSIS_MARKER)
    startpos = 0
    endpos = len(got)
    w = ws[0]
    if w:
        if got.startswith(w):
            startpos = len(w)
            del ws[0]
        else:
            return False
    got.startswith(w)
    w = ws[-1]
    if w:
        if got.endswith(w):
            endpos -= len(w)
            del ws[-1]
        else:
            return False
    got.endswith(w)
    if startpos > endpos:
        return False
    for w in ws:
        startpos = got.find(w, startpos, endpos)
        if startpos < 0:
            return False
        startpos += len(w)

    return True


def _comment_line(line):
    line = line.rstrip()
    if line:
        return '# ' + line
    return '#'


class _OutputRedirectingPdb(pdb.Pdb):

    def __init__(self, out):
        self._OutputRedirectingPdb__out = out
        self._OutputRedirectingPdb__debugger_used = False
        pdb.Pdb.__init__(self, stdout = out)


    def set_trace(self, frame = None):
        self._OutputRedirectingPdb__debugger_used = True
        if frame is None:
            frame = sys._getframe().f_back

        pdb.Pdb.set_trace(self, frame)


    def set_continue(self):
        if self._OutputRedirectingPdb__debugger_used:
            pdb.Pdb.set_continue(self)



    def trace_dispatch(self, *args):
        save_stdout = sys.stdout
        sys.stdout = self._OutputRedirectingPdb__out

        try:
            return pdb.Pdb.trace_dispatch(self, *args)
        finally:
            sys.stdout = save_stdout




def _module_relative_path(module, path):
    if not inspect.ismodule(module):
        raise TypeError, 'Expected a module: %r' % module
    inspect.ismodule(module)
    if path.startswith('/'):
        raise ValueError, 'Module-relative files may not have absolute paths'
    path.startswith('/')
    if hasattr(module, '__file__'):
        basedir = os.path.split(module.__file__)[0]
    elif module.__name__ == '__main__':
        if len(sys.argv) > 0 and sys.argv[0] != '':
            basedir = os.path.split(sys.argv[0])[0]
        else:
            basedir = os.curdir
    else:
        raise ValueError("Can't resolve paths relative to the module " + module + ' (it has no __file__)')
    return hasattr(module, '__file__').path.join(basedir, *path.split('/'))


class Example:

    def __init__(self, source, want, exc_msg = None, lineno = 0, indent = 0, options = None):
        if not source.endswith('\n'):
            source += '\n'

        if want and not want.endswith('\n'):
            want += '\n'

        if exc_msg is not None and not exc_msg.endswith('\n'):
            exc_msg += '\n'

        self.source = source
        self.want = want
        self.lineno = lineno
        self.indent = indent
        if options is None:
            options = { }

        self.options = options
        self.exc_msg = exc_msg



class DocTest:

    def __init__(self, examples, globs, name, filename, lineno, docstring):
        self.examples = examples
        self.docstring = docstring
        self.globs = globs.copy()
        self.name = name
        self.filename = filename
        self.lineno = lineno


    def __repr__(self):
        if len(self.examples) == 0:
            examples = 'no examples'
        elif len(self.examples) == 1:
            examples = '1 example'
        else:
            examples = '%d examples' % len(self.examples)
        return '<DocTest %s from %s:%s (%s)>' % (self.name, self.filename, self.lineno, examples)


    def __cmp__(self, other):
        if not isinstance(other, DocTest):
            return -1
        return cmp((self.name, self.filename, self.lineno, id(self)), (other.name, other.filename, other.lineno, id(other)))



class DocTestParser:
    _EXAMPLE_RE = re.compile('\n        # Source consists of a PS1 line followed by zero or more PS2 lines.\n        (?P<source>\n            (?:^(?P<indent> [ ]*) >>>    .*)    # PS1 line\n            (?:\\n           [ ]*  \\.\\.\\. .*)*)  # PS2 lines\n        \\n?\n        # Want consists of any non-blank lines that do not start with PS1.\n        (?P<want> (?:(?![ ]*$)    # Not a blank line\n                     (?![ ]*>>>)  # Not a line starting with PS1\n                     .*$\\n?       # But any other line\n                  )*)\n        ', re.MULTILINE | re.VERBOSE)
    _EXCEPTION_RE = re.compile("\n        # Grab the traceback header.  Different versions of Python have\n        # said different things on the first traceback line.\n        ^(?P<hdr> Traceback\\ \\(\n            (?: most\\ recent\\ call\\ last\n            |   innermost\\ last\n            ) \\) :\n        )\n        \\s* $                # toss trailing whitespace on the header.\n        (?P<stack> .*?)      # don't blink: absorb stuff until...\n        ^ (?P<msg> \\w+ .*)   #     a line *starts* with alphanum.\n        ", re.VERBOSE | re.MULTILINE | re.DOTALL)
    _IS_BLANK_OR_COMMENT = re.compile('^[ ]*(#.*)?$').match

    def parse(self, string, name = '<string>'):
        string = string.expandtabs()
        min_indent = self._min_indent(string)
        output = []
        (charno, lineno) = (0, 0)
        for m in self._EXAMPLE_RE.finditer(string):
            output.append(string[charno:m.start()])
            lineno += string.count('\n', charno, m.start())
            (source, options, want, exc_msg) = self._parse_example(m, name, lineno)
            if not self._IS_BLANK_OR_COMMENT(source):
                output.append(Example(source, want, exc_msg, lineno = lineno, indent = min_indent + len(m.group('indent')), options = options))

            lineno += string.count('\n', m.start(), m.end())
            charno = m.end()

        output.append(string[charno:])
        return output


    def get_doctest(self, string, globs, name, filename, lineno):
        return DocTest(self.get_examples(string, name), globs, name, filename, lineno, string)


    def get_examples(self, string, name = '<string>'):
        return _[1]


    def _parse_example(self, m, name, lineno):
        indent = len(m.group('indent'))
        source_lines = m.group('source').split('\n')
        self._check_prompt_blank(source_lines, indent, name, lineno)
        self._check_prefix(source_lines[1:], ' ' * indent + '.', name, lineno)
        source = []([ sl[indent + 4:] for sl in source_lines ])
        want = m.group('want')
        want_lines = want.split('\n')
        self._check_prefix(want_lines, ' ' * indent, name, lineno + len(source_lines))
        want = []([ wl[indent:] for wl in want_lines ])
        m = self._EXCEPTION_RE.match(want)
        options = self._find_options(source, name, lineno)
        return (source, options, want, exc_msg)

    _OPTION_DIRECTIVE_RE = re.compile('#\\s*doctest:\\s*([^\\n\\\'"]*)$', re.MULTILINE)

    def _find_options(self, source, name, lineno):
        options = { }
        for m in self._OPTION_DIRECTIVE_RE.finditer(source):
            option_strings = m.group(1).replace(',', ' ').split()
            for option in option_strings:
                if option[0] not in '+-' or option[1:] not in OPTIONFLAGS_BY_NAME:
                    raise ValueError('line %r of the doctest for %s has an invalid option: %r' % (lineno + 1, name, option))
                option[1:] not in OPTIONFLAGS_BY_NAME
                flag = OPTIONFLAGS_BY_NAME[option[1:]]
                options[flag] = option[0] == '+'


        if options and self._IS_BLANK_OR_COMMENT(source):
            raise ValueError('line %r of the doctest for %s has an option directive on a line with no example: %r' % (lineno, name, source))
        self._IS_BLANK_OR_COMMENT(source)
        return options

    _INDENT_RE = re.compile('^([ ]*)(?=\\S)', re.MULTILINE)

    def _min_indent(self, s):
        indents = [ len(indent) for indent in self._INDENT_RE.findall(s) ]
        if len(indents) > 0:
            return min(indents)
        return 0


    def _check_prompt_blank(self, lines, indent, name, lineno):
        for i, line in enumerate(lines):
            if len(line) >= indent + 4 and line[indent + 3] != ' ':
                raise ValueError('line %r of the docstring for %s lacks blank after %s: %r' % (lineno + i + 1, name, line[indent:indent + 3], line))
            line[indent + 3] != ' '



    def _check_prefix(self, lines, prefix, name, lineno):
        for i, line in enumerate(lines):
            if line and not line.startswith(prefix):
                raise ValueError('line %r of the docstring for %s has inconsistent leading whitespace: %r' % (lineno + i + 1, name, line))
            not line.startswith(prefix)




class DocTestFinder:

    def __init__(self, verbose = False, parser = DocTestParser(), recurse = True, exclude_empty = True):
        self._parser = parser
        self._verbose = verbose
        self._recurse = recurse
        self._exclude_empty = exclude_empty


    def find(self, obj, name = None, module = None, globs = None, extraglobs = None):
        if name is None:
            name = getattr(obj, '__name__', None)
            if name is None:
                raise ValueError("DocTestFinder.find: name must be given when obj.__name__ doesn't exist: %r" % (type(obj),))
            name is None

        if module is False:
            module = None
        elif module is None:
            module = inspect.getmodule(obj)


        try:
            if not inspect.getsourcefile(obj):
                pass
            file = inspect.getfile(obj)
            if module is not None:
                source_lines = linecache.getlines(file, module.__dict__)
            else:
                source_lines = linecache.getlines(file)
            if not source_lines:
                source_lines = None
        except TypeError:
            source_lines = None

        if globs is None:
            if module is None:
                globs = { }
            else:
                globs = module.__dict__.copy()
        else:
            globs = globs.copy()
        if extraglobs is not None:
            globs.update(extraglobs)

        if '__name__' not in globs:
            globs['__name__'] = '__main__'

        tests = []
        self._find(tests, obj, name, module, source_lines, globs, { })
        tests.sort()
        return tests


    def _from_module(self, module, object):
        if module is None:
            return True
        if inspect.getmodule(object) is not None:
            return module is inspect.getmodule(object)
        if inspect.isfunction(object):
            return module.__dict__ is object.func_globals
        if inspect.isclass(object):
            return module.__name__ == object.__module__
        if hasattr(object, '__module__'):
            return module.__name__ == object.__module__
        if isinstance(object, property):
            return True
        raise ValueError('object must be a class or function')


    def _find(self, tests, obj, name, module, source_lines, globs, seen):
        if self._verbose:
            print 'Finding tests in %s' % name

        if id(obj) in seen:
            return None
        seen[id(obj)] = 1
        test = self._get_test(obj, name, module, globs, source_lines)
        if test is not None:
            tests.append(test)

        if inspect.ismodule(obj) and self._recurse:
            for valname, val in obj.__dict__.items():
                valname = '%s.%s' % (name, valname)
                if (inspect.isfunction(val) or inspect.isclass(val)) and self._from_module(module, val):
                    self._find(tests, val, valname, module, source_lines, globs, seen)
                    continue


        if inspect.ismodule(obj) and self._recurse:
            for valname, val in getattr(obj, '__test__', { }).items():
                if not isinstance(valname, basestring):
                    raise ValueError('DocTestFinder.find: __test__ keys must be strings: %r' % (type(valname),))
                isinstance(valname, basestring)
                if not inspect.isfunction(val) and inspect.isclass(val) and inspect.ismethod(val) and inspect.ismodule(val) or isinstance(val, basestring):
                    raise ValueError('DocTestFinder.find: __test__ values must be strings, functions, methods, classes, or modules: %r' % (type(val),))
                isinstance(val, basestring)
                valname = '%s.__test__.%s' % (name, valname)
                self._find(tests, val, valname, module, source_lines, globs, seen)


        if inspect.isclass(obj) and self._recurse:
            for valname, val in obj.__dict__.items():
                if isinstance(val, staticmethod):
                    val = getattr(obj, valname)

                if isinstance(val, classmethod):
                    val = getattr(obj, valname).im_func

                if (inspect.isfunction(val) and inspect.isclass(val) or isinstance(val, property)) and self._from_module(module, val):
                    valname = '%s.%s' % (name, valname)
                    self._find(tests, val, valname, module, source_lines, globs, seen)
                    continue




    def _get_test(self, obj, name, module, globs, source_lines):
        if isinstance(obj, basestring):
            docstring = obj
        else:

            try:
                if obj.__doc__ is None:
                    docstring = ''
                else:
                    docstring = obj.__doc__
                    if not isinstance(docstring, basestring):
                        docstring = str(docstring)
            except (TypeError, AttributeError):
                docstring = ''


        lineno = self._find_lineno(obj, source_lines)
        if self._exclude_empty and not docstring:
            return None
        if module is None:
            filename = None
        else:
            filename = getattr(module, '__file__', module.__name__)
            if filename[-4:] in ('.pyc', '.pyo'):
                filename = filename[:-1]

        return self._parser.get_doctest(docstring, globs, name, filename, lineno)


    def _find_lineno(self, obj, source_lines):
        lineno = None
        if inspect.ismodule(obj):
            lineno = 0

        if inspect.isclass(obj):
            if source_lines is None:
                return None
            pat = re.compile('^\\s*class\\s*%s\\b' % getattr(obj, '__name__', '-'))
            for i, line in enumerate(source_lines):
                if pat.match(line):
                    lineno = i
                    break
                    continue
                source_lines is None


        if inspect.ismethod(obj):
            obj = obj.im_func

        if inspect.isfunction(obj):
            obj = obj.func_code

        if inspect.istraceback(obj):
            obj = obj.tb_frame

        if inspect.isframe(obj):
            obj = obj.f_code

        if inspect.iscode(obj):
            lineno = getattr(obj, 'co_firstlineno', None) - 1




class DocTestRunner:
    DIVIDER = '*' * 70

    def __init__(self, checker = None, verbose = None, optionflags = 0):
        if not checker:
            pass
        self._checker = OutputChecker()
        if verbose is None:
            verbose = '-v' in sys.argv

        self._verbose = verbose
        self.optionflags = optionflags
        self.original_optionflags = optionflags
        self.tries = 0
        self.failures = 0
        self._name2ft = { }
        self._fakeout = _SpoofOut()


    def report_start(self, out, test, example):
        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):
        if self._verbose:
            out('ok\n')



    def report_failure(self, out, test, example, got):
        out(self._failure_header(test, example) + self._checker.output_difference(example, got, self.optionflags))


    def report_unexpected_exception(self, out, test, example, exc_info):
        out(self._failure_header(test, example) + 'Exception raised:\n' + _indent(_exception_traceback(exc_info)))


    def _failure_header(self, test, example):
        out = [
            self.DIVIDER]
        if test.filename:
            if test.lineno is not None and example.lineno is not None:
                lineno = test.lineno + example.lineno + 1
            else:
                lineno = '?'
            out.append('File "%s", line %s, in %s' % (test.filename, lineno, test.name))
        else:
            out.append('Line %s, in %s' % (example.lineno + 1, test.name))
        out.append('Failed example:')
        source = example.source
        out.append(_indent(source))
        return '\n'.join(out)


    def __run(self, test, compileflags, out):
        failures = tries = 0
        original_optionflags = self.optionflags
        (SUCCESS, FAILURE, BOOM) = range(3)
        check = self._checker.check_output
        for examplenum, example in enumerate(test.examples):
            if self.optionflags & REPORT_ONLY_FIRST_FAILURE:
                pass
            quiet = failures > 0
            self.optionflags = original_optionflags
            if example.options:
                for optionflag, val in example.options.items():
                    if val:
                        self.optionflags |= optionflag
                        continue
                    self
                    self.optionflags &= ~optionflag


            if self.optionflags & SKIP:
                continue

            tries += 1
            if not quiet:
                self.report_start(out, test, example)

            filename = '<doctest %s[%d]>' % (test.name, examplenum)

            try:
                exec compile(example.source, filename, 'single', compileflags, 1) in test.globs
                self.debugger.set_continue()
                exception = None
            except KeyboardInterrupt:
                raise
            except:
                exception = sys.exc_info()
                self.debugger.set_continue()

            got = self._fakeout.getvalue()
            self._fakeout.truncate(0)
            outcome = FAILURE
            if exception is None:
                if check(example.want, got, self.optionflags):
                    outcome = SUCCESS

            else:
                exc_info = sys.exc_info()
                exc_msg = traceback.format_exception_only(*exc_info[:2])[-1]
                if not quiet:
                    got += _exception_traceback(exc_info)

                if example.exc_msg is None:
                    outcome = BOOM
                elif check(example.exc_msg, exc_msg, self.optionflags):
                    outcome = SUCCESS
                elif self.optionflags & IGNORE_EXCEPTION_DETAIL:
                    m1 = re.match('[^:]*:', example.exc_msg)
                    m2 = re.match('[^:]*:', exc_msg)
                    if m1 and m2 and check(m1.group(0), m2.group(0), self.optionflags):
                        outcome = SUCCESS


            if outcome is SUCCESS:
                if not quiet:
                    self.report_success(out, test, example, got)

            quiet
            if outcome is FAILURE:
                if not quiet:
                    self.report_failure(out, test, example, got)

                failures += 1
                continue
            if outcome is BOOM:
                if not quiet:
                    self.report_unexpected_exception(out, test, example, exc_info)

                failures += 1
                continue

        self.optionflags = original_optionflags
        self._DocTestRunner__record_outcome(test, failures, tries)
        return TestResults(failures, tries)


    def __record_outcome(self, test, f, t):
        (f2, t2) = self._name2ft.get(test.name, (0, 0))
        self._name2ft[test.name] = (f + f2, t + t2)
        self.failures += f
        self.tries += t

    __LINECACHE_FILENAME_RE = re.compile('<doctest (?P<name>[\\w\\.]+)\\[(?P<examplenum>\\d+)\\]>$')

    def __patched_linecache_getlines(self, filename, module_globals = None):
        m = self._DocTestRunner__LINECACHE_FILENAME_RE.match(filename)
        if m and m.group('name') == self.test.name:
            example = self.test.examples[int(m.group('examplenum'))]
            return example.source.splitlines(True)
        return self.save_linecache_getlines(filename, module_globals)


    def run(self, test, compileflags = None, out = None, clear_globs = True):
        self.test = test
        if compileflags is None:
            compileflags = _extract_future_flags(test.globs)

        save_stdout = sys.stdout
        if out is None:
            out = save_stdout.write

        sys.stdout = self._fakeout
        save_set_trace = pdb.set_trace
        self.debugger = _OutputRedirectingPdb(save_stdout)
        self.debugger.reset()
        pdb.set_trace = self.debugger.set_trace
        self.save_linecache_getlines = linecache.getlines
        linecache.getlines = self._DocTestRunner__patched_linecache_getlines

        try:
            return self._DocTestRunner__run(test, compileflags, out)
        finally:
            sys.stdout = save_stdout
            pdb.set_trace = save_set_trace
            linecache.getlines = self.save_linecache_getlines
            if clear_globs:
                test.globs.clear()




    def summarize(self, verbose = None):
        if verbose is None:
            verbose = self._verbose

        notests = []
        passed = []
        failed = []
        totalt = totalf = 0
        for x in self._name2ft.items():
            (f, t) = (name,)
            totalt += t
            totalf += f
            if t == 0:
                notests.append(name)
                continue
            x
            if f == 0:
                passed.append((name, t))
                continue
            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 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 TestResults(totalf, totalt)


    def merge(self, other):
        d = self._name2ft
        for f, t in other._name2ft.items():
            if name in d:
                (f2, t2) = d[name]
                f = f + f2
                t = t + t2

            d[name] = (f, t)




class OutputChecker:

    def check_output(self, want, got, optionflags):
        if got == want:
            return True
        return False


    def _do_a_fancy_diff(self, want, got, optionflags):
        if not optionflags & (REPORT_UDIFF | REPORT_CDIFF | REPORT_NDIFF):
            return False
        return optionflags & REPORT_NDIFF if optionflags & REPORT_NDIFF else got.count('\n') > 2


    def output_difference(self, example, got, optionflags):
        want = example.want
        if not optionflags & DONT_ACCEPT_BLANKLINE:
            got = re.sub('(?m)^[ ]*(?=\n)', BLANKLINE_MARKER, got)

        if self._do_a_fancy_diff(want, got, optionflags):
            want_lines = want.splitlines(True)
            got_lines = got.splitlines(True)
            if optionflags & REPORT_UDIFF:
                diff = difflib.unified_diff(want_lines, got_lines, n = 2)
                diff = list(diff)[2:]
                kind = 'unified diff with -expected +actual'
            elif optionflags & REPORT_CDIFF:
                diff = difflib.context_diff(want_lines, got_lines, n = 2)
                diff = list(diff)[2:]
                kind = 'context diff with expected followed by actual'
            elif optionflags & REPORT_NDIFF:
                engine = difflib.Differ(charjunk = difflib.IS_CHARACTER_JUNK)
                diff = list(engine.compare(want_lines, got_lines))
                kind = 'ndiff with -expected +actual'

            diff = [ line.rstrip() + '\n' for line in diff ]
            return 'Differences (%s):\n' % kind + _indent(''.join(diff))
        if want and got:
            return 'Expected:\n%sGot:\n%s' % (_indent(want), _indent(got))
        if want:
            return 'Expected:\n%sGot nothing\n' % _indent(want)
        if got:
            return 'Expected nothing\nGot:\n%s' % _indent(got)
        return 'Expected nothing\nGot nothing\n'



class DocTestFailure(Exception):

    def __init__(self, test, example, got):
        self.test = test
        self.example = example
        self.got = got


    def __str__(self):
        return str(self.test)



class UnexpectedException(Exception):

    def __init__(self, test, example, exc_info):
        self.test = test
        self.example = example
        self.exc_info = exc_info


    def __str__(self):
        return str(self.test)



class DebugRunner(DocTestRunner):

    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 report_unexpected_exception(self, out, test, example, exc_info):
        raise UnexpectedException(test, example, exc_info)


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


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):
    global master
    if m is None:
        m = sys.modules.get('__main__')

    if not inspect.ismodule(m):
        raise TypeError('testmod: module required; %r' % (m,))
    inspect.ismodule(m)
    if name is None:
        name = m.__name__

    finder = DocTestFinder(exclude_empty = exclude_empty)
    if raise_on_error:
        runner = DebugRunner(verbose = verbose, optionflags = optionflags)
    else:
        runner = DocTestRunner(verbose = verbose, optionflags = optionflags)
    for test in finder.find(m, name, globs = globs, extraglobs = extraglobs):
        runner.run(test)

    if report:
        runner.summarize()

    if master is None:
        master = runner
    else:
        master.merge(runner)
    return TestResults(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(), encoding = None):
    global master
    if package and not module_relative:
        raise ValueError('Package may only be specified for module-relative paths.')
    not module_relative
    (text, filename) = _load_testfile(filename, package, module_relative)
    if name is None:
        name = os.path.basename(filename)

    if globs is None:
        globs = { }
    else:
        globs = globs.copy()
    if extraglobs is not None:
        globs.update(extraglobs)

    if '__name__' not in globs:
        globs['__name__'] = '__main__'

    if raise_on_error:
        runner = DebugRunner(verbose = verbose, optionflags = optionflags)
    else:
        runner = DocTestRunner(verbose = verbose, optionflags = optionflags)
    if encoding is not None:
        text = text.decode(encoding)

    test = parser.get_doctest(text, globs, name, filename, 0)
    runner.run(test)
    if report:
        runner.summarize()

    if master is None:
        master = runner
    else:
        master.merge(runner)
    return TestResults(runner.failures, runner.tries)


def run_docstring_examples(f, globs, verbose = False, name = 'NoName', compileflags = None, optionflags = 0):
    finder = DocTestFinder(verbose = verbose, recurse = False)
    runner = DocTestRunner(verbose = verbose, optionflags = optionflags)
    for test in finder.find(f, name, globs = globs):
        runner.run(test, compileflags = compileflags)



class Tester:

    def __init__(self, mod = None, globs = None, verbose = None, optionflags = 0):
        warnings.warn('class Tester is deprecated; use class doctest.DocTestRunner instead', DeprecationWarning, stacklevel = 2)
        if mod is None and globs is None:
            raise TypeError('Tester.__init__: must specify mod or globs')
        globs is None
        if mod is not None and not inspect.ismodule(mod):
            raise TypeError('Tester.__init__: mod must be a module; %r' % (mod,))
        not inspect.ismodule(mod)
        if globs is None:
            globs = mod.__dict__

        self.globs = globs
        self.verbose = verbose
        self.optionflags = optionflags
        self.testfinder = DocTestFinder()
        self.testrunner = DocTestRunner(verbose = verbose, optionflags = optionflags)


    def runstring(self, s, name):
        test = DocTestParser().get_doctest(s, self.globs, name, None, None)
        if self.verbose:
            print 'Running string', name

        (f, t) = self.testrunner.run(test)
        if self.verbose:
            print f, 'of', t, 'examples failed in string', name

        return TestResults(f, t)


    def rundoc(self, object, name = None, module = None):
        f = t = 0
        tests = self.testfinder.find(object, name, module = module, globs = self.globs)
        for test in tests:
            (f2, t2) = self.testrunner.run(test)
            f = f + f2
            t = t + t2

        return TestResults(f, t)


    def rundict(self, d, name, module = None):
        import types as types
        m = types.ModuleType(name)
        m.__dict__.update(d)
        if module is None:
            module = False

        return self.rundoc(m, name, module)


    def run__test__(self, d, name):
        import types
        m = types.ModuleType(name)
        m.__test__ = d
        return self.rundoc(m, name)


    def summarize(self, verbose = None):
        return self.testrunner.summarize(verbose)


    def merge(self, other):
        self.testrunner.merge(other.testrunner)


_unittest_reportflags = 0

def set_unittest_reportflags(flags):
    global _unittest_reportflags
    if flags & REPORTING_FLAGS != flags:
        raise ValueError('Only reporting flags allowed', flags)
    flags & REPORTING_FLAGS != flags
    old = _unittest_reportflags
    _unittest_reportflags = flags
    return old


class DocTestCase(unittest.TestCase):

    def __init__(self, test, optionflags = 0, setUp = None, tearDown = None, checker = None):
        unittest.TestCase.__init__(self)
        self._dt_optionflags = optionflags
        self._dt_checker = checker
        self._dt_test = test
        self._dt_setUp = setUp
        self._dt_tearDown = tearDown


    def setUp(self):
        test = self._dt_test
        if self._dt_setUp is not None:
            self._dt_setUp(test)



    def tearDown(self):
        test = self._dt_test
        if self._dt_tearDown is not None:
            self._dt_tearDown(test)

        test.globs.clear()


    def runTest(self):
        test = self._dt_test
        old = sys.stdout
        new = StringIO()
        optionflags = self._dt_optionflags
        if not optionflags & REPORTING_FLAGS:
            optionflags |= _unittest_reportflags

        runner = DocTestRunner(optionflags = optionflags, checker = self._dt_checker, verbose = False)

        try:
            runner.DIVIDER = '-' * 70
            (failures, tries) = runner.run(test, out = new.write, clear_globs = False)
        finally:
            sys.stdout = old

        if failures:
            raise self.failureException(self.format_failure(new.getvalue()))
        failures


    def format_failure(self, err):
        test = self._dt_test
        if test.lineno is None:
            lineno = 'unknown line number'
        else:
            lineno = '%s' % test.lineno
        lname = '.'.join(test.name.split('.')[-1:])
        return 'Failed doctest test for %s\n  File "%s", line %s, in %s\n\n%s' % (test.name, test.filename, lineno, lname, err)


    def debug(self):
        self.setUp()
        runner = DebugRunner(optionflags = self._dt_optionflags, checker = self._dt_checker, verbose = False)
        runner.run(self._dt_test, clear_globs = False)
        self.tearDown()


    def id(self):
        return self._dt_test.name


    def __repr__(self):
        name = self._dt_test.name.split('.')
        return '%s (%s)' % (name[-1], '.'.join(name[:-1]))

    __str__ = __repr__

    def shortDescription(self):
        return 'Doctest: ' + self._dt_test.name



def DocTestSuite(module = None, globs = None, extraglobs = None, test_finder = None, **options):
    if test_finder is None:
        test_finder = DocTestFinder()

    module = _normalize_module(module)
    tests = test_finder.find(module, globs = globs, extraglobs = extraglobs)
    if not tests:
        raise ValueError(module, 'has no tests')
    tests
    tests.sort()
    suite = unittest.TestSuite()
    for test in tests:
        if len(test.examples) == 0:
            continue

        if not test.filename:
            filename = module.__file__
            if filename[-4:] in ('.pyc', '.pyo'):
                filename = filename[:-1]

            test.filename = filename

        suite.addTest(DocTestCase(test, **options))

    return suite


class DocFileCase(DocTestCase):

    def id(self):
        return '_'.join(self._dt_test.name.split('.'))


    def __repr__(self):
        return self._dt_test.filename

    __str__ = __repr__

    def format_failure(self, err):
        return 'Failed doctest test for %s\n  File "%s", line 0\n\n%s' % (self._dt_test.name, self._dt_test.filename, err)



def DocFileTest(path, module_relative = True, package = None, globs = None, parser = DocTestParser(), encoding = None, **options):
    if globs is None:
        globs = { }
    else:
        globs = globs.copy()
    if package and not module_relative:
        raise ValueError('Package may only be specified for module-relative paths.')
    not module_relative
    (doc, path) = _load_testfile(path, package, module_relative)
    if '__file__' not in globs:
        globs['__file__'] = path

    name = os.path.basename(path)
    if encoding is not None:
        doc = doc.decode(encoding)

    test = parser.get_doctest(doc, globs, name, path, 0)
    return DocFileCase(test, **options)


def DocFileSuite(*paths, **kw):
    suite = unittest.TestSuite()
    if kw.get('module_relative', True):
        kw['package'] = _normalize_module(kw.get('package'))

    for path in paths:
        suite.addTest(DocFileTest(path, **kw))

    return suite


def script_from_examples(s):
    output = []
    for piece in DocTestParser().parse(s):
        if isinstance(piece, Example):
            output.append(piece.source[:-1])
            want = piece.want
            if want:
                output.append('# Expected:')
                [] += [ '## ' + l for l in want.split('\n')[:-1] ]

        want
        [] += [ _comment_line(l) for l in piece.split('\n')[:-1] ]

    while output and output[-1] == '#':
        output.pop()
        continue
        []
    while output and output[0] == '#':
        output.pop(0)
        continue
        output
    return '\n'.join(output) + '\n'


def testsource(module, name):
    module = _normalize_module(module)
    tests = DocTestFinder().find(module)
    test = _[1]
    if not test:
        raise ValueError(name, 'not found in tests')
    test
    test = test[0]
    testsrc = script_from_examples(test.docstring)
    return testsrc


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


def debug_script(src, pm = False, globs = None):
    import pdb
    srcfilename = tempfile.mktemp('.py', 'doctestdebug')
    f = open(srcfilename, 'w')
    f.write(src)
    f.close()

    try:
        if globs:
            globs = globs.copy()
        else:
            globs = { }
        if pm:

            try:
                execfile(srcfilename, globs, globs)
            print sys.exc_info()[1]
            pdb.post_mortem(sys.exc_info()[2])

        else:
            pdb.run('execfile(%r)' % srcfilename, globs, globs)
    finally:
        os.remove(srcfilename)



def debug(module, name, pm = False):
    module = _normalize_module(module)
    testsrc = testsource(module, name)
    debug_script(testsrc, pm, module.__dict__)


class _TestClass:

    def __init__(self, val):
        self.val = val


    def square(self):
        self.val = self.val ** 2
        return self


    def get(self):
        return self.val


__test__ = {
    '_TestClass': _TestClass,
    'string': '\n                      Example of a string object, searched as-is.\n                      >>> x = 1; y = 2\n                      >>> x + y, x * y\n                      (3, 2)\n                      ',
    'bool-int equivalence': '\n                                    In 2.2, boolean expressions displayed\n                                    0 or 1.  By default, we still accept\n                                    them.  This can be disabled by passing\n                                    DONT_ACCEPT_TRUE_FOR_1 to the new\n                                    optionflags argument.\n                                    >>> 4 == 4\n                                    1\n                                    >>> 4 == 4\n                                    True\n                                    >>> 4 > 4\n                                    0\n                                    >>> 4 > 4\n                                    False\n                                    ',
    'blank lines': "\n                Blank lines can be marked with <BLANKLINE>:\n                    >>> print 'foo\\n\\nbar\\n'\n                    foo\n                    <BLANKLINE>\n                    bar\n                    <BLANKLINE>\n            ",
    'ellipsis': "\n                If the ellipsis flag is used, then '...' can be used to\n                elide substrings in the desired output:\n                    >>> print range(1000) #doctest: +ELLIPSIS\n                    [0, 1, 2, ..., 999]\n            ",
    'whitespace normalization': '\n                If the whitespace normalization flag is used, then\n                differences in whitespace are ignored.\n                    >>> print range(30) #doctest: +NORMALIZE_WHITESPACE\n                    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,\n                     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n                     27, 28, 29]\n            ' }

def _test():
    testfiles = _[1]
    return 0

if __name__ == '__main__':
    sys.exit(_test())