class Tester():

def __init__(self, mod=None, globs=None, verbose=None,

             isprivate=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")

    if mod is not None and not inspect.ismodule(mod):

        raise TypeError("Tester.__init__: mod must be a module; %r" %

                        (mod,))

    if globs is None:

        globs = mod.__dict__

    self.globs = globs

    self.verbose = verbose

    self.isprivate = isprivate

    self.optionflags = optionflags

    self.testfinder = DocTestFinder(_namefilter=isprivate)

    self.testrunner = DocTestRunner(verbose=verbose,

                                    optionflags=optionflags)

def merge(self, other):

    self.testrunner.merge(other.testrunner)

def run__test__(self, d, name):

    import new

    m = new.module(name)

    m.__test__ = d

    return self.rundoc(m, name)

def rundict(self, d, name, module=None):

    import new

    m = new.module(name)

    m.__dict__.update(d)

    if module is None:

        module = False

    return self.rundoc(m, name, module)

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,t) = (f+f2, t+t2)

    return (f,t)

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 (f,t)

def summarize(self, verbose=None):

    return self.testrunner.summarize(verbose)