#!/usr/bin/env python'''Python unit testing framework, based on Erich Gamma's JUnit and Kent Beck'sSmalltalk testing framework.This module contains the core framework classes that form the basis ofspecific test cases and suites (TestCase, TestSuite etc.), and also atext-based utility class for running the tests and reporting the results (TextTestRunner).Simple usage:    import unittest    class IntegerArithmenticTestCase(unittest.TestCase):        def testAdd(self):  ## test method names begin 'test*'            self.assertEquals((1 + 2), 3)            self.assertEquals(0 + 1, 1)        def testMultiply(self):            self.assertEquals((0 * 10), 0)            self.assertEquals((5 * 8), 40)    if __name__ == '__main__':        unittest.main()Further information is available in the bundled documentation, and from  http://pyunit.sourceforge.net/Copyright (c) 1999, 2000, 2001 Steve PurcellThis module is free software, and you may redistribute it and/or modifyit under the same terms as Python itself, so long as this copyright messageand disclaimer are retained in their original form.IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OFTHIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCHDAMAGE.THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOTLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR APARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.'''__author__ = "Steve Purcell"__email__ = "stephen_purcell at yahoo dot com"__version__ = "#Revision: 1.43 $"[11:-2]import timeimport sysimport tracebackimport stringimport osimport types############################################################################### Test framework core##############################################################################class TestResult:    """Holder for test result information.    Test results are automatically managed by the TestCase and TestSuite    classes, and do not need to be explicitly manipulated by writers of tests.    Each instance holds the total number of tests run, and collections of    failures and errors that occurred among those test runs. The collections    contain tuples of (testcase, exceptioninfo), where exceptioninfo is the    formatted traceback of the error that occurred.    """    def __init__(self):        self.failures = []        self.errors = []        self.testsRun = 0        self.shouldStop = 0    def startTest(self, test):        "Called when the given test is about to be run"        self.testsRun = self.testsRun + 1    def stopTest(self, test):        "Called when the given test has been run"        pass    def addError(self, test, err):        """Called when an error has occurred. 'err' is a tuple of values as        returned by sys.exc_info().        """        self.errors.append((test, self._exc_info_to_string(err)))    def addFailure(self, test, err):        """Called when an error has occurred. 'err' is a tuple of values as        returned by sys.exc_info()."""        self.failures.append((test, self._exc_info_to_string(err)))    def addSuccess(self, test):        "Called when a test has completed successfully"        pass    def wasSuccessful(self):        "Tells whether or not this result was a success"        return len(self.failures) == len(self.errors) == 0    def stop(self):        "Indicates that the tests should be aborted"        self.shouldStop = 1    def _exc_info_to_string(self, err):        """Converts a sys.exc_info()-style tuple of values into a string."""        return string.join(apply(traceback.format_exception, err), '')    def __repr__(self):        return "<%s run=%i errors=%i failures=%i>" % \               (self.__class__, self.testsRun, len(self.errors),                len(self.failures))class TestCase:    """A class whose instances are single test cases.    By default, the test code itself should be placed in a method named    'runTest'.    If the fixture may be used for many test cases, create as    many test methods as are needed. When instantiating such a TestCase    subclass, specify in the constructor arguments the name of the test method    that the instance is to execute.    Test authors should subclass TestCase for their own tests. Construction    and deconstruction of the test's environment ('fixture') can be    implemented by overriding the 'setUp' and 'tearDown' methods respectively.    If it is necessary to override the __init__ method, the base class    __init__ method must always be called. It is important that subclasses    should not change the signature of their __init__ method, since instances    of the classes are instantiated automatically by parts of the framework    in order to be run.    """    # This attribute determines which exception will be raised when    # the instance's assertion methods fail; test methods raising this    # exception will be deemed to have 'failed' rather than 'errored'    failureException = AssertionError    def __init__(self, methodName='runTest'):        """Create an instance of the class that will use the named test           method when executed. Raises a ValueError if the instance does           not have a method with the specified name.        """        try:            self.__testMethodName = methodName            testMethod = getattr(self, methodName)            self.__testMethodDoc = testMethod.__doc__        except AttributeError:            raise ValueError, "no such test method in %s: %s" % \                  (self.__class__, methodName)    def setUp(self):        "Hook method for setting up the test fixture before exercising it."        pass    def tearDown(self):        "Hook method for deconstructing the test fixture after testing it."        pass    def countTestCases(self):        return 1    def defaultTestResult(self):        return TestResult()    def shortDescription(self):        """Returns a one-line description of the test, or None if no        description has been provided.        The default implementation of this method returns the first line of        the specified test method's docstring.        """        doc = self.__testMethodDoc        return doc and string.strip(string.split(doc, "\n")[0]) or None    def id(self):        return "%s.%s" % (self.__class__, self.__testMethodName)    def __str__(self):        return "%s (%s)" % (self.__testMethodName, self.__class__)    def __repr__(self):        return "<%s testMethod=%s>" % \               (self.__class__, self.__testMethodName)    def run(self, result=None):        return self(result)    def __call__(self, result=None):        if result is None: result = self.defaultTestResult()        result.startTest(self)        testMethod = getattr(self, self.__testMethodName)        try:            try:                self.setUp()            except KeyboardInterrupt:                raise            except:                result.addError(self, self.__exc_info())                return            ok = 0            try:                testMethod()                ok = 1            except self.failureException, e:                result.addFailure(self, self.__exc_info())            except KeyboardInterrupt:                raise            except:                result.addError(self, self.__exc_info())            try:                self.tearDown()            except KeyboardInterrupt:                raise            except:                result.addError(self, self.__exc_info())                ok = 0            if ok: result.addSuccess(self)        finally:            result.stopTest(self)    def debug(self):        """Run the test without collecting errors in a TestResult"""        self.setUp()        getattr(self, self.__testMethodName)()        self.tearDown()    def __exc_info(self):        """Return a version of sys.exc_info() with the traceback frame           minimised; usually the top level of the traceback frame is not           needed.        """        exctype, excvalue, tb = sys.exc_info()        if sys.platform[:4] == 'java': ## tracebacks look different in Jython            return (exctype, excvalue, tb)        newtb = tb.tb_next        if newtb is None:            return (exctype, excvalue, tb)        return (exctype, excvalue, newtb)    def fail(self, msg=None):        """Fail immediately, with the given message."""        raise self.failureException, msg    def failIf(self, expr, msg=None):        "Fail the test if the expression is true."        if expr: raise self.failureException, msg    def failUnless(self, expr, msg=None):        """Fail the test unless the expression is true."""        if not expr: raise self.failureException, msg    def failUnlessRaises(self, excClass, callableObj, *args, **kwargs):        """Fail unless an exception of class excClass is thrown           by callableObj when invoked with arguments args and keyword           arguments kwargs. If a different type of exception is           thrown, it will not be caught, and the test case will be           deemed to have suffered an error, exactly as for an           unexpected exception.        """        try:            apply(callableObj, args, kwargs)        except excClass:            return        else:            if hasattr(excClass,'__name__'): excName = excClass.__name__            else: excName = str(excClass)            raise self.failureException, excName    def failUnlessEqual(self, first, second, msg=None):        """Fail if the two objects are unequal as determined by the '!='           operator.        """        if first != second:            raise self.failureException, \                  (msg or '%s != %s' % (`first`, `second`))    def failIfEqual(self, first, second, msg=None):        """Fail if the two objects are equal as determined by the '=='           operator.        """        if first == second:            raise self.failureException, \                  (msg or '%s == %s' % (`first`, `second`))    assertEqual = assertEquals = failUnlessEqual    assertNotEqual = assertNotEquals = failIfEqual    assertRaises = failUnlessRaises    assert_ = failUnlessclass TestSuite:    """A test suite is a composite test consisting of a number of TestCases.    For use, create an instance of TestSuite, then add test case instances.    When all tests have been added, the suite can be passed to a test    runner, such as TextTestRunner. It will run the individual test cases    in the order in which they were added, aggregating the results. When    subclassing, do not forget to call the base class constructor.    """    def __init__(self, tests=()):        self._tests = []        self.addTests(tests)    def __repr__(self):        return "<%s tests=%s>" % (self.__class__, self._tests)    __str__ = __repr__    def countTestCases(self):        cases = 0        for test in self._tests:            cases = cases + test.countTestCases()        return cases    def addTest(self, test):        self._tests.append(test)    def addTests(self, tests):        for test in tests:            self.addTest(test)    def run(self, result):        return self(result)    def __call__(self, result):        for test in self._tests:            if result.shouldStop:                break            test(result)        return result    def debug(self):        """Run the tests without collecting errors in a TestResult"""        for test in self._tests: test.debug()class FunctionTestCase(TestCase):    """A test case that wraps a test function.    This is useful for slipping pre-existing test functions into the    PyUnit framework. Optionally, set-up and tidy-up functions can be    supplied. As with TestCase, the tidy-up ('tearDown') function will    always be called if the set-up ('setUp') function ran successfully.    """    def __init__(self, testFunc, setUp=None, tearDown=None,