Remove third_party/twisted_8_1

third_party/twisted_8_1/twisted/trial/test/test_loader.py

Index: third_party/twisted_8_1/twisted/trial/test/test_loader.py
diff --git a/third_party/twisted_8_1/twisted/trial/test/test_loader.py b/third_party/twisted_8_1/twisted/trial/test/test_loader.py
deleted file mode 100644
index 0bc53a17df0c51871b778bd5ea86b834d25cc9a7..0000000000000000000000000000000000000000
--- a/third_party/twisted_8_1/twisted/trial/test/test_loader.py
+++ /dev/null
@@ -1,475 +0,0 @@
-
-import md5
-import os
-import shutil
-
-from twisted.python import util
-from twisted.trial.test import packages
-from twisted.trial import runner, reporter, unittest
-from twisted.trial.itrial import ITestCase
-
-from twisted.python.modules import getModule
-
-
-
-def testNames(tests):
-    """
-    Return the id of each test within the given test suite or case.
-    """
-    names = []
-    for test in unittest._iterateTests(tests):
-        names.append(test.id())
-    return names
-
-
-
-class FinderTest(packages.PackageTest):
-    def setUp(self):
-        packages.PackageTest.setUp(self)
-        self.loader = runner.TestLoader()
-
-    def tearDown(self):
-        packages.PackageTest.tearDown(self)
-
-    def test_findPackage(self):
-        sample1 = self.loader.findByName('twisted')
-        import twisted as sample2
-        self.failUnlessEqual(sample1, sample2)
-
-    def test_findModule(self):
-        sample1 = self.loader.findByName('twisted.trial.test.sample')
-        import sample as sample2
-        self.failUnlessEqual(sample1, sample2)
-
-    def test_findFile(self):
-        path = util.sibpath(__file__, 'sample.py')
-        sample1 = self.loader.findByName(path)
-        import sample as sample2
-        self.failUnlessEqual(sample1, sample2)
-
-    def test_findObject(self):
-        sample1 = self.loader.findByName('twisted.trial.test.sample.FooTest')
-        import sample
-        self.failUnlessEqual(sample.FooTest, sample1)
-
-    def test_findNonModule(self):
-        self.failUnlessRaises(AttributeError,
-                              self.loader.findByName,
-                              'twisted.trial.test.nonexistent')
-
-    def test_findNonPackage(self):
-        self.failUnlessRaises(ValueError,
-                              self.loader.findByName,
-                              'nonextant')
-
-    def test_findNonFile(self):
-        path = util.sibpath(__file__, 'nonexistent.py')
-        self.failUnlessRaises(ValueError, self.loader.findByName, path)
-
-
-
-class FileTest(packages.SysPathManglingTest):
-    def test_notFile(self):
-        self.failUnlessRaises(ValueError,
-                              runner.filenameToModule, 'doesntexist')
-
-    def test_moduleInPath(self):
-        sample1 = runner.filenameToModule(util.sibpath(__file__, 'sample.py'))
-        import sample as sample2
-        self.failUnlessEqual(sample2, sample1)
-
-    def test_moduleNotInPath(self):
-        self.mangleSysPath(self.oldPath)
-        sample1 = runner.filenameToModule(os.path.join(self.parent,
-                                                       'goodpackage',
-                                                       'test_sample.py'))
-        self.mangleSysPath(self.newPath)
-        from goodpackage import test_sample as sample2
-        self.failUnlessEqual(os.path.splitext(sample2.__file__)[0],
-                             os.path.splitext(sample1.__file__)[0])
-
-    def test_packageInPath(self):
-        package1 = runner.filenameToModule(os.path.join(self.parent,
-                                                        'goodpackage'))
-        import goodpackage
-        self.failUnlessEqual(goodpackage, package1)
-
-    def test_packageNotInPath(self):
-        self.mangleSysPath(self.oldPath)
-        package1 = runner.filenameToModule(os.path.join(self.parent,
-                                                        'goodpackage'))
-        self.mangleSysPath(self.newPath)
-        import goodpackage
-        self.failUnlessEqual(os.path.splitext(goodpackage.__file__)[0],
-                             os.path.splitext(package1.__file__)[0])
-
-    def test_directoryNotPackage(self):
-        self.failUnlessRaises(ValueError, runner.filenameToModule,
-                              util.sibpath(__file__, 'directory'))
-
-    def test_filenameNotPython(self):
-        self.failUnlessRaises(ValueError, runner.filenameToModule,
-                              util.sibpath(__file__, 'notpython.py'))
-
-    def test_filenameMatchesPackage(self):
-        filename = os.path.join(self.parent, 'goodpackage.py')
-        fd = open(filename, 'w')
-        fd.write(packages.testModule)
-        fd.close()
-        try:
-            module = runner.filenameToModule(filename)
-            self.failUnlessEqual(filename, module.__file__)
-        finally:
-            os.remove(filename)
-
-    def test_directory(self):
-        """
-        Test loader against a filesystem directory. It should handle
-        'path' and 'path/' the same way.
-        """
-        path  = util.sibpath(__file__, 'goodDirectory')
-        os.mkdir(path)
-        f = file(os.path.join(path, '__init__.py'), "w")
-        f.close()
-        try:
-            module = runner.filenameToModule(path)
-            self.assert_(module.__name__.endswith('goodDirectory'))
-            module = runner.filenameToModule(path + os.path.sep)
-            self.assert_(module.__name__.endswith('goodDirectory'))
-        finally:
-            shutil.rmtree(path)
-
-
-
-class LoaderTest(packages.SysPathManglingTest):
-
-    def setUp(self):
-        self.loader = runner.TestLoader()
-        packages.SysPathManglingTest.setUp(self)
-
-    def test_sortCases(self):
-        import sample
-        suite = self.loader.loadClass(sample.AlphabetTest)
-        self.failUnlessEqual(['test_a', 'test_b', 'test_c'],
-                             [test._testMethodName for test in suite._tests])
-        newOrder = ['test_b', 'test_c', 'test_a']
-        sortDict = dict(zip(newOrder, range(3)))
-        self.loader.sorter = lambda x : sortDict.get(x.shortDescription(), -1)
-        suite = self.loader.loadClass(sample.AlphabetTest)
-        self.failUnlessEqual(newOrder,
-                             [test._testMethodName for test in suite._tests])
-
-    def test_loadMethod(self):
-        import sample
-        suite = self.loader.loadMethod(sample.FooTest.test_foo)
-        self.failUnlessEqual(1, suite.countTestCases())
-        self.failUnlessEqual('test_foo', suite._testMethodName)
-
-    def test_loadFailingMethod(self):
-        # test added for issue1353
-        import erroneous
-        suite = self.loader.loadMethod(erroneous.TestRegularFail.test_fail)
-        result = reporter.TestResult()
-        suite.run(result)
-        self.failUnlessEqual(result.testsRun, 1)
-        self.failUnlessEqual(len(result.failures), 1)
-
-    def test_loadNonMethod(self):
-        import sample
-        self.failUnlessRaises(TypeError, self.loader.loadMethod, sample)
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadMethod, sample.FooTest)
-        self.failUnlessRaises(TypeError, self.loader.loadMethod, "string")
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadMethod, ('foo', 'bar'))
-
-    def test_loadClass(self):
-        import sample
-        suite = self.loader.loadClass(sample.FooTest)
-        self.failUnlessEqual(2, suite.countTestCases())
-        self.failUnlessEqual(['test_bar', 'test_foo'],
-                             [test._testMethodName for test in suite._tests])
-
-
-    def test_loadNonClass(self):
-        import sample
-        self.failUnlessRaises(TypeError, self.loader.loadClass, sample)
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadClass, sample.FooTest.test_foo)
-        self.failUnlessRaises(TypeError, self.loader.loadClass, "string")
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadClass, ('foo', 'bar'))
-
-    def test_loadNonTestCase(self):
-        import sample
-        self.failUnlessRaises(ValueError, self.loader.loadClass,
-                              sample.NotATest)
-
-    def test_loadModule(self):
-        import sample
-        suite = self.loader.loadModule(sample)
-        self.failUnlessEqual(7, suite.countTestCases())
-
-    def test_loadNonModule(self):
-        import sample
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadModule, sample.FooTest)
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadModule, sample.FooTest.test_foo)
-        self.failUnlessRaises(TypeError, self.loader.loadModule, "string")
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadModule, ('foo', 'bar'))
-
-    def test_loadPackage(self):
-        import goodpackage
-        suite = self.loader.loadPackage(goodpackage)
-        self.failUnlessEqual(7, suite.countTestCases())
-
-    def test_loadNonPackage(self):
-        import sample
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadPackage, sample.FooTest)
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadPackage, sample.FooTest.test_foo)
-        self.failUnlessRaises(TypeError, self.loader.loadPackage, "string")
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadPackage, ('foo', 'bar'))
-
-    def test_loadModuleAsPackage(self):
-        import sample
-        ## XXX -- should this instead raise a ValueError? -- jml
-        self.failUnlessRaises(TypeError, self.loader.loadPackage, sample)
-
-    def test_loadPackageRecursive(self):
-        import goodpackage
-        suite = self.loader.loadPackage(goodpackage, recurse=True)
-        self.failUnlessEqual(14, suite.countTestCases())
-
-    def test_loadAnythingOnModule(self):
-        import sample
-        suite = self.loader.loadAnything(sample)
-        self.failUnlessEqual(sample.__name__,
-                             suite._tests[0]._tests[0].__class__.__module__)
-
-    def test_loadAnythingOnClass(self):
-        import sample
-        suite = self.loader.loadAnything(sample.FooTest)
-        self.failUnlessEqual(2, suite.countTestCases())
-
-    def test_loadAnythingOnMethod(self):
-        import sample
-        suite = self.loader.loadAnything(sample.FooTest.test_foo)
-        self.failUnlessEqual(1, suite.countTestCases())
-
-    def test_loadAnythingOnPackage(self):
-        import goodpackage
-        suite = self.loader.loadAnything(goodpackage)
-        self.failUnless(isinstance(suite, self.loader.suiteFactory))
-        self.failUnlessEqual(7, suite.countTestCases())
-
-    def test_loadAnythingOnPackageRecursive(self):
-        import goodpackage
-        suite = self.loader.loadAnything(goodpackage, recurse=True)
-        self.failUnless(isinstance(suite, self.loader.suiteFactory))
-        self.failUnlessEqual(14, suite.countTestCases())
-
-    def test_loadAnythingOnString(self):
-        # the important thing about this test is not the string-iness
-        # but the non-handledness.
-        self.failUnlessRaises(TypeError,
-                              self.loader.loadAnything, "goodpackage")
-
-    def test_importErrors(self):
-        import package
-        suite = self.loader.loadPackage(package, recurse=True)
-        result = reporter.Reporter()
-        suite.run(result)
-        self.failUnlessEqual(False, result.wasSuccessful())
-        self.failUnlessEqual(2, len(result.errors))
-        errors = [test.id() for test, error in result.errors]
-        errors.sort()
-        self.failUnlessEqual(errors, ['package.test_bad_module',
-                                      'package.test_import_module'])
-
-
-    def test_loadModuleWith_test_suite(self):
-        """
-        Check that C{test_suite} is used when present and other L{TestCase}s are
-        not included.
-        """
-        from twisted.trial.test import mockcustomsuite
-        suite = self.loader.loadModule(mockcustomsuite)
-        self.failUnlessEqual(0, suite.countTestCases())
-        self.failUnlessEqual("MyCustomSuite", getattr(suite, 'name', None))
-
-
-    def test_loadModuleWith_testSuite(self):
-        """
-        Check that C{testSuite} is used when present and other L{TestCase}s are
-        not included.
-        """
-        from twisted.trial.test import mockcustomsuite2
-        suite = self.loader.loadModule(mockcustomsuite2)
-        self.assertEqual(0, suite.countTestCases())
-        self.assertEqual("MyCustomSuite", getattr(suite, 'name', None))
-
-
-    def test_loadModuleWithBothCustom(self):
-        """
-        Check that if C{testSuite} and C{test_suite} are both present in a
-        module then C{testSuite} gets priority.
-        """
-        from twisted.trial.test import mockcustomsuite3
-        suite = self.loader.loadModule(mockcustomsuite3)
-        self.assertEqual('testSuite', getattr(suite, 'name', None))
-
-
-    def test_customLoadRaisesAttributeError(self):
-        """
-        Make sure that any C{AttributeError}s raised by C{testSuite} are not
-        swallowed by L{TestLoader}.
-        """
-        def testSuite():
-            raise AttributeError('should be reraised')
-        from twisted.trial.test import mockcustomsuite2
-        mockcustomsuite2.testSuite, original = (testSuite,
-                                                mockcustomsuite2.testSuite)
-        try:
-            self.assertRaises(AttributeError, self.loader.loadModule,
-                              mockcustomsuite2)
-        finally:
-            mockcustomsuite2.testSuite = original
-
-
-    # XXX - duplicated and modified from test_script
-    def assertSuitesEqual(self, test1, test2):
-        loader = runner.TestLoader()
-        names1 = testNames(test1)
-        names2 = testNames(test2)
-        names1.sort()
-        names2.sort()
-        self.assertEqual(names1, names2)
-
-    def test_loadByNamesDuplicate(self):
-        """
-        Check that loadByNames ignores duplicate names
-        """
-        module = 'twisted.trial.test.test_test_visitor'
-        suite1 = self.loader.loadByNames([module, module], True)
-        suite2 = self.loader.loadByName(module, True)
-        self.assertSuitesEqual(suite1, suite2)
-
-    def test_loadDifferentNames(self):
-        """
-        Check that loadByNames loads all the names that it is given
-        """
-        modules = ['goodpackage', 'package.test_module']
-        suite1 = self.loader.loadByNames(modules)
-        suite2 = runner.TestSuite(map(self.loader.loadByName, modules))
-        self.assertSuitesEqual(suite1, suite2)
-
-
-
-class ZipLoadingTest(LoaderTest):
-    def setUp(self):
-        from twisted.test.test_paths import zipit
-        LoaderTest.setUp(self)
-        zipit(self.parent, self.parent+'.zip')
-        self.parent += '.zip'
-        self.mangleSysPath(self.oldPath+[self.parent])
-
-
-
-class PackageOrderingTest(packages.SysPathManglingTest):
-    def setUp(self):
-        self.resultingTests = []
-        self.loader = runner.TestLoader()
-        self.topDir = self.mktemp()
-        parent = os.path.join(self.topDir, "uberpackage")
-        os.makedirs(parent)
-        file(os.path.join(parent, "__init__.py"), "wb").close()
-        packages.SysPathManglingTest.setUp(self, parent)
-        self.mangleSysPath(self.oldPath + [self.topDir])
-
-    def _trialSortAlgorithm(self, sorter):
-        """
-        Right now, halfway by accident, trial sorts like this:
-
-            1. all modules are grouped together in one list and sorted.
-
-            2. within each module, the classes are grouped together in one list
-               and sorted.
-
-            3. finally within each class, each test method is grouped together
-               in a list and sorted.
-
-        This attempts to return a sorted list of testable thingies following
-        those rules, so that we can compare the behavior of loadPackage.
-
-        The things that show as 'cases' are errors from modules which failed to
-        import, and test methods.  Let's gather all those together.
-        """
-        pkg = getModule('uberpackage')
-        testModules = []
-        for testModule in pkg.walkModules():
-            if testModule.name.split(".")[-1].startswith("test_"):
-                testModules.append(testModule)
-        sortedModules = util.dsu(testModules, sorter) # ONE
-        for modinfo in sortedModules:
-            # Now let's find all the classes.
-            module = modinfo.load(None)
-            if module is None:
-                yield modinfo
-            else:
-                testClasses = []
-                for attrib in modinfo.iterAttributes():
-                    if runner.isTestCase(attrib.load()):
-                        testClasses.append(attrib)
-                sortedClasses = util.dsu(testClasses, sorter) # TWO
-                for clsinfo in sortedClasses:
-                    testMethods = []
-                    for attr in clsinfo.iterAttributes():
-                        if attr.name.split(".")[-1].startswith('test'):
-                            testMethods.append(attr)
-                    sortedMethods = util.dsu(testMethods, sorter) # THREE
-                    for methinfo in sortedMethods:
-                        yield methinfo
-
-
-    def loadSortedPackages(self, sorter=runner.name):
-        """
-        Verify that packages are loaded in the correct order.
-        """
-        import uberpackage
-        self.loader.sorter = sorter
-        suite = self.loader.loadPackage(uberpackage, recurse=True)
-        # XXX: Work around strange, unexplained Zope crap.
-        # jml, 2007-11-15.
-        suite = unittest.decorate(suite, ITestCase)
-        self.resultingTests = list(unittest._iterateTests(suite))
-        manifest = list(self._trialSortAlgorithm(sorter))
-        for number, (manifestTest, actualTest) in enumerate(
-            zip(manifest, self.resultingTests)):
-            self.assertEqual(
-                 manifestTest.name, actualTest.id(),
-                 "#%d: %s != %s" %
-                 (number, manifestTest.name, actualTest.id()))
-        self.assertEqual(len(manifest), len(self.resultingTests))
-
-
-    def test_sortPackagesDefaultOrder(self):
-        self.loadSortedPackages()
-
-
-    def test_sortPackagesSillyOrder(self):
-        def sillySorter(s):
-            # This has to work on fully-qualified class names and class
-            # objects, which is silly, but it's the "spec", such as it is.
-#             if isinstance(s, type) or isinstance(s, types.ClassType):
-#                 return s.__module__+'.'+s.__name__
-            n = runner.name(s)
-            d = md5.new(n).hexdigest()
-            return d
-        self.loadSortedPackages(sillySorter)
-
-