description=None):        TestCase.__init__(self)        self.__setUpFunc = setUp        self.__tearDownFunc = tearDown        self.__testFunc = testFunc        self.__description = description    def setUp(self):        if self.__setUpFunc is not None:            self.__setUpFunc()    def tearDown(self):        if self.__tearDownFunc is not None:            self.__tearDownFunc()    def runTest(self):        self.__testFunc()    def id(self):        return self.__testFunc.__name__    def __str__(self):        return "%s (%s)" % (self.__class__, self.__testFunc.__name__)    def __repr__(self):        return "<%s testFunc=%s>" % (self.__class__, self.__testFunc)    def shortDescription(self):        if self.__description is not None: return self.__description        doc = self.__testFunc.__doc__        return doc and string.strip(string.split(doc, "\n")[0]) or None############################################################################### Locating and loading tests##############################################################################class TestLoader:    """This class is responsible for loading tests according to various    criteria and returning them wrapped in a Test    """    testMethodPrefix = 'test'    sortTestMethodsUsing = cmp    suiteClass = TestSuite    def loadTestsFromTestCase(self, testCaseClass):        """Return a suite of all tests cases contained in testCaseClass"""        return self.suiteClass(map(testCaseClass,                                   self.getTestCaseNames(testCaseClass)))    def loadTestsFromModule(self, module):        """Return a suite of all tests cases contained in the given module"""        tests = []        for name in dir(module):            obj = getattr(module, name)            if type(obj) == types.ClassType and issubclass(obj, TestCase):                tests.append(self.loadTestsFromTestCase(obj))        return self.suiteClass(tests)    def loadTestsFromName(self, name, module=None):        """Return a suite of all tests cases given a string specifier.        The name may resolve either to a module, a test case class, a        test method within a test case class, or a callable object which        returns a TestCase or TestSuite instance.        The method optionally resolves the names relative to a given module.        """        parts = string.split(name, '.')        if module is None:            if not parts:                raise ValueError, "incomplete test name: %s" % name            else:                parts_copy = parts[:]                while parts_copy:                    try:                        module = __import__(string.join(parts_copy,'.'))                        break                    except ImportError:                        del parts_copy[-1]                        if not parts_copy: raise                parts = parts[1:]        obj = module        for part in parts:            obj = getattr(obj, part)        import unittest        if type(obj) == types.ModuleType:            return self.loadTestsFromModule(obj)        elif type(obj) == types.ClassType and issubclass(obj, unittest.TestCase):            return self.loadTestsFromTestCase(obj)        elif type(obj) == types.UnboundMethodType:            return obj.im_class(obj.__name__)        elif callable(obj):            test = obj()            if not isinstance(test, unittest.TestCase) and \               not isinstance(test, unittest.TestSuite):                raise ValueError, \                      "calling %s returned %s, not a test" % (obj,test)            return test        else:            raise ValueError, "don't know how to make test from: %s" % obj    def loadTestsFromNames(self, names, module=None):        """Return a suite of all tests cases found using the given sequence        of string specifiers. See 'loadTestsFromName()'.        """        suites = []        for name in names:            suites.append(self.loadTestsFromName(name, module))        return self.suiteClass(suites)    def getTestCaseNames(self, testCaseClass):        """Return a sorted sequence of method names found within testCaseClass        """        testFnNames = filter(lambda n,p=self.testMethodPrefix: n[:len(p)] == p,                             dir(testCaseClass))        for baseclass in testCaseClass.__bases__:            for testFnName in self.getTestCaseNames(baseclass):                if testFnName not in testFnNames:  # handle overridden methods                    testFnNames.append(testFnName)        if self.sortTestMethodsUsing:            testFnNames.sort(self.sortTestMethodsUsing)        return testFnNamesdefaultTestLoader = TestLoader()############################################################################### Patches for old functions: these functions should be considered obsolete##############################################################################def _makeLoader(prefix, sortUsing, suiteClass=None):    loader = TestLoader()    loader.sortTestMethodsUsing = sortUsing    loader.testMethodPrefix = prefix    if suiteClass: loader.suiteClass = suiteClass    return loaderdef getTestCaseNames(testCaseClass, prefix, sortUsing=cmp):    return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass)def makeSuite(testCaseClass, prefix='test', sortUsing=cmp, suiteClass=TestSuite):    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(testCaseClass)def findTestCases(module, prefix='test', sortUsing=cmp, suiteClass=TestSuite):    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(module)############################################################################### Text UI##############################################################################class _WritelnDecorator:    """Used to decorate file-like objects with a handy 'writeln' method"""    def __init__(self,stream):        self.stream = stream    def __getattr__(self, attr):        return getattr(self.stream,attr)    def writeln(self, *args):        if args: apply(self.write, args)        self.write('\n') # text-mode streams translate to \r\n if neededclass _TextTestResult(TestResult):    """A test result class that can print formatted text results to a stream.    Used by TextTestRunner.    """    separator1 = '=' * 70    separator2 = '-' * 70    def __init__(self, stream, descriptions, verbosity):        TestResult.__init__(self)        self.stream = stream        self.showAll = verbosity > 1        self.dots = verbosity == 1        self.descriptions = descriptions    def getDescription(self, test):        if self.descriptions:            return test.shortDescription() or str(test)        else:            return str(test)    def startTest(self, test):        TestResult.startTest(self, test)        if self.showAll:            self.stream.write(self.getDescription(test))            self.stream.write(" ... ")    def addSuccess(self, test):        TestResult.addSuccess(self, test)        if self.showAll:            self.stream.writeln("ok")        elif self.dots:            self.stream.write('.')    def addError(self, test, err):        TestResult.addError(self, test, err)        if self.showAll:            self.stream.writeln("ERROR")        elif self.dots:            self.stream.write('E')    def addFailure(self, test, err):        TestResult.addFailure(self, test, err)        if self.showAll:            self.stream.writeln("FAIL")        elif self.dots:            self.stream.write('F')    def printErrors(self):        if self.dots or self.showAll:            self.stream.writeln()        self.printErrorList('ERROR', self.errors)        self.printErrorList('FAIL', self.failures)    def printErrorList(self, flavour, errors):        for test, err in errors:            self.stream.writeln(self.separator1)            self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))            self.stream.writeln(self.separator2)            self.stream.writeln("%s" % err)class TextTestRunner:    """A test runner class that displays results in textual form.    It prints out the names of tests as they are run, errors as they    occur, and a summary of the results at the end of the test run.    """    def __init__(self, stream=sys.stderr, descriptions=1, verbosity=1):        self.stream = _WritelnDecorator(stream)        self.descriptions = descriptions        self.verbosity = verbosity    def _makeResult(self):        return _TextTestResult(self.stream, self.descriptions, self.verbosity)    def run(self, test):        "Run the given test case or test suite."        result = self._makeResult()        startTime = time.time()        test(result)        stopTime = time.time()        timeTaken = float(stopTime - startTime)        result.printErrors()        self.stream.writeln(result.separator2)        run = result.testsRun        self.stream.writeln("Ran %d test%s in %.3fs" %                            (run, run != 1 and "s" or "", timeTaken))        self.stream.writeln()        if not result.wasSuccessful():            self.stream.write("FAILED (")            failed, errored = map(len, (result.failures, result.errors))            if failed:                self.stream.write("failures=%d" % failed)            if errored:                if failed: self.stream.write(", ")                self.stream.write("errors=%d" % errored)            self.stream.writeln(")")        else:            self.stream.writeln("OK")        return result############################################################################### Facilities for running tests from the command line##############################################################################class TestProgram:    """A command-line program that runs a set of tests; this is primarily       for making test modules conveniently executable.    """    USAGE = """\Usage: %(progName)s [options] [test] [...]Options:  -h, --help       Show this message  -v, --verbose    Verbose output  -q, --quiet      Minimal outputExamples:  %(progName)s                               - run default set of tests  %(progName)s MyTestSuite                   - run suite 'MyTestSuite'  %(progName)s MyTestCase.testSomething      - run MyTestCase.testSomething  %(progName)s MyTestCase                    - run all 'test*' test methods                                               in MyTestCase"""    def __init__(self, module='__main__', defaultTest=None,                 argv=None, testRunner=None, testLoader=defaultTestLoader):        if type(module) == type(''):            self.module = __import__(module)            for part in string.split(module,'.')[1:]:                self.module = getattr(self.module, part)        else:            self.module = module        if argv is None:            argv = sys.argv        self.verbosity = 1        self.defaultTest = defaultTest        self.testRunner = testRunner        self.testLoader = testLoader        self.progName = os.path.basename(argv[0])        self.parseArgs(argv)        self.runTests()    def usageExit(self, msg=None):        if msg: print msg        print self.USAGE % self.__dict__        sys.exit(2)    def parseArgs(self, argv):        import getopt        try:            options, args = getopt.getopt(argv[1:], 'hHvq',                                          ['help','verbose','quiet'])            for opt, value in options:                if opt in ('-h','-H','--help'):                    self.usageExit()                if opt in ('-q','--quiet'):                    self.verbosity = 0                if opt in ('-v','--verbose'):                    self.verbosity = 2            if len(args) == 0 and self.defaultTest is None:                self.test = self.testLoader.loadTestsFromModule(self.module)                return            if len(args) > 0:                self.testNames = args            else:                self.testNames = (self.defaultTest,)            self.createTests()        except getopt.error, msg:            self.usageExit(msg)    def createTests(self):        self.test = self.testLoader.loadTestsFromNames(self.testNames,                                                       self.module)    def runTests(self):        if self.testRunner is None:            self.testRunner = TextTestRunner(verbosity=self.verbosity)        result = self.testRunner.run(self.test)        sys.exit(not result.wasSuccessful())main = TestProgram############################################################################### Executing this module from the command line##############################################################################if __name__ == "__main__":    main(module=None)