basic object tests tests for testloader loadtestsfromtestcase return a suite of all test cases contained in the testcasederived class testcaseclass return a suite of all test cases contained in the testcasederived class testcaseclass make sure it does the right thing even if no tests were found return a suite of all test cases contained in the testcasederived class testcaseclass what happens if loadtestsfromtestcase is given an object that isn t a subclass of testcase specifically what happens if testcaseclass is a subclass of testsuite this is checked for specifically in the code so we better add a test for it return a suite of all test cases contained in the testcasederived class testcaseclass make sure loadtestsfromtestcase picks up the default test method name as specified by testcase even though the method name does not match the default testloader testmethodprefix string this has to be false for the test to succeed do not load any tests from testcase class itself do not load any tests from functiontestcase class tests for testloader loadtestsfromtestcase tests for testloader loadtestsfrommodule this method searches module for classes derived from testcase this test ensures that internal testcase subclasses are not loaded see https github compythoncpythonissues84867 simulate imported names this method searches module for classes derived from testcase what happens if no tests are found no testcase instances this method searches module for classes derived from testcase what happens if no tests are found testcases instances but no tests this method searches module for classes derived from testcases what happens if loadtestsfrommodule is given something other than a module xxx currently it succeeds anyway this flexibility should either be documented or loadtestsfrommodule should raise a typeerror xxx certain people are using this behaviour we ll add a test for it check that loadtestsfrommodule honors a module with a loadtests function in python 3 12 the undocumented and unofficial useloadtests has been removed errors loading the suite are also captured for introspection tests for testloader loadtestsfrommodule tests for testloader loadtestsfromname the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance is valueerror raised in response to an empty name the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the name contains invalid characters the specifier name is a dotted name that may resolve to a module what happens when a module by that name can t be found the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the module is found but the attribute isn t the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the module is found but the attribute isn t the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when we provide the module but the attribute can t be found the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module does loadtestsfromname raise valueerror when passed an empty name relative to a provided module xxx should probably raise a valueerror instead of an attributeerror the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when an impossible name is given relative to the provided module xxx should this raise attributeerror or valueerror the method optionally resolves name relative to the given module does loadtestsfromname raise typeerror when the module argument isn t a module object xxx accepts the notamodule object ignoring the object s type this should raise an exception or the method name should be changed xxx some people are relying on this so keep it for now the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance does it raise an exception if the name resolves to an invalid object the specifier name is a dotted name that may resolve either to a test case class the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the specifier name is a dotted name that may resolve to a test method within a test case class the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance does loadtestsfromname raise the proper exception when trying to resolve a test method within a test case class that doesn t exist for the given name relative to a provided module the specifier name is a dotted name that may resolve to a callable object which returns a testsuite instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase instance override the suiteclass attribute to ensure that the suiteclass attribute is used the specifier name is a dotted name that may resolve to a test method within a test case class override the suiteclass attribute to ensure that the suiteclass attribute is used the specifier name is a dotted name that may resolve to a callable object which returns a testcase or testsuite instance what happens if the callable returns something else the specifier can refer to modules and packages which have not been imported they will be imported as a sideeffect we re going to try to load this module as a sideeffect so it better not be loaded before we try module should now be loaded thanks to loadtestsfromname tests for testloader loadtestsfromname tests for testloader loadtestsfromnames helper function for checking that errors in loading are reported param loader a loader with some errors param suite a suite that should have a late bound error return the first error message from the loader and the test object from the suite errors loading the suite are also captured for introspection similar to loadtestsfromname but takes a sequence of names rather than a single name what happens if that sequence of names is empty similar to loadtestsfromname but takes a sequence of names rather than a single name the method optionally resolves name relative to the given module what happens if that sequence of names is empty xxx should this raise a valueerror or just return an empty testsuite the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance is valueerror raised in response to an empty name the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when presented with an impossible module name xxx should this raise valueerror or importerror the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when no module can be found for the given name the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the module can be found but not the attribute the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when given an unknown attribute on a specified module argument the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module do unknown attributes relative to a provided module still raise an exception even in the presence of valid attribute names the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when faced with the empty string xxx this currently raises attributeerror though valueerror is probably more appropriate the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when presented with an impossible attribute name xxx should this raise attributeerror or valueerror the method optionally resolves name relative to the given module does loadtestsfromnames make sure the provided module is in fact a module xxx this validation is currently not done this flexibility should either be documented or a typeerror should be raised the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance does it raise an exception if the name resolves to an invalid object the specifier name is a dotted name that may resolve to a test case class the specifier name is a dotted name that may resolve to a testsuite instance the specifier name is a dotted name that may resolve to a test method within a test case class 14971 make sure the dotted name resolution works even if the actual function doesn t have the same name as is used to find it lambdas have the name lambda the specifier name is a dotted name that may resolve to a test method within a test case class does the method gracefully handle names that initially look like they resolve to a test method within a test case class but don t the specifier name is a dotted name that may resolve to a callable object which returns a testsuite instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase or testsuite instance are staticmethods handled correctly the specifier name is a dotted name that may resolve to a callable object which returns a testcase or testsuite instance what happens when the callable returns something else the specifier can refer to modules and packages which have not been imported they will be imported as a sideeffect we re going to try to load this module as a sideeffect so it better not be loaded before we try module should now be loaded thanks to loadtestsfromname tests for testloader loadtestsfromnames tests for testloader gettestcasenames return a sorted sequence of method names found within testcaseclass test foobar is defined to make sure gettestcasenames respects loader testmethodprefix return a sorted sequence of method names found within testcaseclass does gettestcasenames behave appropriately if no tests are found return a sorted sequence of method names found within testcaseclass are nottestcases handled gracefully xxx this should raise a typeerror not return a list xxx it s too late in the 2 5 release cycle to fix this but it should probably be revisited for 2 6 return a sorted sequence of method names found within testcaseclass make sure inherited names are handled testp foobar is defined to make sure gettestcasenames respects loader testmethodprefix return a sorted sequence of method names found within testcaseclass if testloader testnamepatterns is set only tests that match one of these patterns should be included return a sorted sequence of method names found within testcaseclass if testloader testnamepatterns is set only tests that match one of these patterns should be included for backwards compatibility reasons see bpo32071 the check may only touch a testcase s attribute if it starts with the test method prefix tests for testloader gettestcasenames tests for testloader testmethodprefix string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods the default value is test tests for testloader testmethodprefix tests for testloader sorttestmethodsusing function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames does it actually affect gettestcasenames the default value is the builtin cmp function since cmp is now defunct we simply verify that the results occur in the same order as they would with the default sort it can be set to none to disable the sort xxx how is this different from reassigning cmp are the tests returned in a random order or something this behaviour should die tests for testloader sorttestmethodsusing tests for testloader suiteclass callable object that constructs a test suite from a list of tests it is implicit in the documentation for testloader suiteclass that all testloader loadtestsfrom methods respect it let s make sure it is implicit in the documentation for testloader suiteclass that all testloader loadtestsfrom methods respect it let s make sure it is implicit in the documentation for testloader suiteclass that all testloader loadtestsfrom methods respect it let s make sure the default value is the testsuite class basic object tests tests for testloader loadtestsfromtestcase return a suite of all test cases contained in the testcase derived class testcaseclass return a suite of all test cases contained in the testcase derived class testcaseclass make sure it does the right thing even if no tests were found return a suite of all test cases contained in the testcase derived class testcaseclass what happens if loadtestsfromtestcase is given an object that isn t a subclass of testcase specifically what happens if testcaseclass is a subclass of testsuite this is checked for specifically in the code so we better add a test for it return a suite of all test cases contained in the testcase derived class testcaseclass make sure loadtestsfromtestcase picks up the default test method name as specified by testcase even though the method name does not match the default testloader testmethodprefix string this has to be false for the test to succeed do not load any tests from testcase class itself do not load any tests from functiontestcase class tests for testloader loadtestsfromtestcase tests for testloader loadtestsfrommodule this method searches module for classes derived from testcase this test ensures that internal testcase subclasses are not loaded see https github com python cpython issues 84867 simulate imported names this method searches module for classes derived from testcase what happens if no tests are found no testcase instances this method searches module for classes derived from testcase what happens if no tests are found testcases instances but no tests this method searches module for classes derived from testcase s what happens if loadtestsfrommodule is given something other than a module xxx currently it succeeds anyway this flexibility should either be documented or loadtestsfrommodule should raise a typeerror xxx certain people are using this behaviour we ll add a test for it check that loadtestsfrommodule honors a module with a load_tests function in python 3 12 the undocumented and unofficial use_load_tests has been removed errors loading the suite are also captured for introspection tests for testloader loadtestsfrommodule tests for testloader loadtestsfromname the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance is valueerror raised in response to an empty name the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the name contains invalid characters the specifier name is a dotted name that may resolve to a module what happens when a module by that name can t be found the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the module is found but the attribute isn t the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the module is found but the attribute isn t the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when we provide the module but the attribute can t be found the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module does loadtestsfromname raise valueerror when passed an empty name relative to a provided module xxx should probably raise a valueerror instead of an attributeerror the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when an impossible name is given relative to the provided module xxx should this raise attributeerror or valueerror the method optionally resolves name relative to the given module does loadtestsfromname raise typeerror when the module argument isn t a module object xxx accepts the not a module object ignoring the object s type this should raise an exception or the method name should be changed xxx some people are relying on this so keep it for now the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance does it raise an exception if the name resolves to an invalid object the specifier name is a dotted name that may resolve either to a test case class the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the specifier name is a dotted name that may resolve to a test method within a test case class the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance does loadtestsfromname raise the proper exception when trying to resolve a test method within a test case class that doesn t exist for the given name relative to a provided module the specifier name is a dotted name that may resolve to a callable object which returns a testsuite instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase instance override the suiteclass attribute to ensure that the suiteclass attribute is used the specifier name is a dotted name that may resolve to a test method within a test case class override the suiteclass attribute to ensure that the suiteclass attribute is used the specifier name is a dotted name that may resolve to a callable object which returns a testcase or testsuite instance what happens if the callable returns something else the specifier can refer to modules and packages which have not been imported they will be imported as a side effect we re going to try to load this module as a side effect so it better not be loaded before we try module should now be loaded thanks to loadtestsfromname tests for testloader loadtestsfromname tests for testloader loadtestsfromnames helper function for checking that errors in loading are reported param loader a loader with some errors param suite a suite that should have a late bound error return the first error message from the loader and the test object from the suite errors loading the suite are also captured for introspection similar to loadtestsfromname but takes a sequence of names rather than a single name what happens if that sequence of names is empty similar to loadtestsfromname but takes a sequence of names rather than a single name the method optionally resolves name relative to the given module what happens if that sequence of names is empty xxx should this raise a valueerror or just return an empty testsuite the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance is valueerror raised in response to an empty name the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when presented with an impossible module name xxx should this raise valueerror or importerror the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when no module can be found for the given name the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance what happens when the module can be found but not the attribute the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when given an unknown attribute on a specified module argument the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module do unknown attributes relative to a provided module still raise an exception even in the presence of valid attribute names the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when faced with the empty string xxx this currently raises attributeerror though valueerror is probably more appropriate the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance the method optionally resolves name relative to the given module what happens when presented with an impossible attribute name xxx should this raise attributeerror or valueerror the method optionally resolves name relative to the given module does loadtestsfromnames make sure the provided module is in fact a module xxx this validation is currently not done this flexibility should either be documented or a typeerror should be raised the specifier name is a dotted name that may resolve either to a module a test case class a testsuite instance a test method within a test case class or a callable object which returns a testcase or testsuite instance does it raise an exception if the name resolves to an invalid object the specifier name is a dotted name that may resolve to a test case class the specifier name is a dotted name that may resolve to a testsuite instance the specifier name is a dotted name that may resolve to a test method within a test case class 14971 make sure the dotted name resolution works even if the actual function doesn t have the same name as is used to find it lambdas have the name lambda the specifier name is a dotted name that may resolve to a test method within a test case class does the method gracefully handle names that initially look like they resolve to a test method within a test case class but don t the specifier name is a dotted name that may resolve to a callable object which returns a testsuite instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase instance the specifier name is a dotted name that may resolve to a callable object which returns a testcase or testsuite instance are staticmethods handled correctly the specifier name is a dotted name that may resolve to a callable object which returns a testcase or testsuite instance what happens when the callable returns something else the specifier can refer to modules and packages which have not been imported they will be imported as a side effect we re going to try to load this module as a side effect so it better not be loaded before we try module should now be loaded thanks to loadtestsfromname tests for testloader loadtestsfromnames tests for testloader gettestcasenames return a sorted sequence of method names found within testcaseclass test foobar is defined to make sure gettestcasenames respects loader testmethodprefix return a sorted sequence of method names found within testcaseclass does gettestcasenames behave appropriately if no tests are found return a sorted sequence of method names found within testcaseclass are not testcases handled gracefully xxx this should raise a typeerror not return a list xxx it s too late in the 2 5 release cycle to fix this but it should probably be revisited for 2 6 return a sorted sequence of method names found within testcaseclass make sure inherited names are handled testp foobar is defined to make sure gettestcasenames respects loader testmethodprefix return a sorted sequence of method names found within testcaseclass if testloader testnamepatterns is set only tests that match one of these patterns should be included return a sorted sequence of method names found within testcaseclass if testloader testnamepatterns is set only tests that match one of these patterns should be included for backwards compatibility reasons see bpo 32071 the check may only touch a testcase s attribute if it starts with the test method prefix tests for testloader gettestcasenames tests for testloader testmethodprefix string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods string giving the prefix of method names which will be interpreted as test methods implicit in the documentation is that testmethodprefix is respected by all loadtestsfrom methods the default value is test tests for testloader testmethodprefix tests for testloader sorttestmethodsusing function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames and all the loadtestsfromx methods function to be used to compare method names when sorting them in gettestcasenames does it actually affect gettestcasenames the default value is the built in cmp function since cmp is now defunct we simply verify that the results occur in the same order as they would with the default sort it can be set to none to disable the sort xxx how is this different from reassigning cmp are the tests returned in a random order or something this behaviour should die tests for testloader sorttestmethodsusing tests for testloader suiteclass callable object that constructs a test suite from a list of tests it is implicit in the documentation for testloader suiteclass that all testloader loadtestsfrom methods respect it let s make sure it is implicit in the documentation for testloader suiteclass that all testloader loadtestsfrom methods respect it let s make sure it is implicit in the documentation for testloader suiteclass that all testloader loadtestsfrom methods respect it let s make sure the default value is the testsuite class
import functools
import sys
import types

import unittest

class Test_TestLoader(unittest.TestCase):

    
    

    def test___init__(self):
        loader = unittest.TestLoader()
        self.assertEqual([], loader.errors)

    
    

    
    
    def test_loadTestsFromTestCase(self):
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass

        tests = unittest.TestSuite([Foo('test_1'), Foo('test_2')])

        loader = unittest.TestLoader()
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)

    
    
    
    
    def test_loadTestsFromTestCase__no_matches(self):
        class Foo(unittest.TestCase):
            def foo_bar(self): pass

        empty_suite = unittest.TestSuite()

        loader = unittest.TestLoader()
        self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite)

    
    
    
    
    
    
    
    
    
    def test_loadTestsFromTestCase__TestSuite_subclass(self):
        class NotATestCase(unittest.TestSuite):
            pass

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromTestCase(NotATestCase)
        except TypeError:
            pass
        else:
            self.fail('Should raise TypeError')

    
    
    
    
    
    
    def test_loadTestsFromTestCase__default_method_name(self):
        class Foo(unittest.TestCase):
            def runTest(self):
                pass

        loader = unittest.TestLoader()
        
        self.assertFalse('runTest'.startswith(loader.testMethodPrefix))

        suite = loader.loadTestsFromTestCase(Foo)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [Foo('runTest')])

    
    def test_loadTestsFromTestCase__from_TestCase(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromTestCase(unittest.TestCase)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [])

    
    def test_loadTestsFromTestCase__from_FunctionTestCase(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromTestCase(unittest.FunctionTestCase)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [])

    
    

    
    

    
    def test_loadTestsFromModule__TestCase_subclass(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m)
        self.assertIsInstance(suite, loader.suiteClass)

        expected = [loader.suiteClass([MyTestCase('test')])]
        self.assertEqual(list(suite), expected)

    
    def test_loadTestsFromModule__TestCase_subclass_internals(self):
        
        m = types.ModuleType('m')
        
        m.TestCase = unittest.TestCase
        m.FunctionTestCase = unittest.FunctionTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [])

    
    
    
    def test_loadTestsFromModule__no_TestCase_instances(self):
        m = types.ModuleType('m')

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [])

    
    
    
    def test_loadTestsFromModule__no_TestCase_tests(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [loader.suiteClass()])

    
    
    
    
    
    
    
    
    
    
    def test_loadTestsFromModule__not_a_module(self):
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass

        class NotAModule(object):
            test_2 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(NotAModule)

        reference = [unittest.TestSuite([MyTestCase('test')])]
        self.assertEqual(list(suite), reference)


    
    
    def test_loadTestsFromModule__load_tests(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        load_tests_args = []
        def load_tests(loader, tests, pattern):
            self.assertIsInstance(tests, unittest.TestSuite)
            load_tests_args.extend((loader, tests, pattern))
            return tests
        m.load_tests = load_tests

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m)
        self.assertIsInstance(suite, unittest.TestSuite)
        self.assertEqual(load_tests_args, [loader, suite, None])

        
        
        with self.assertRaises(TypeError):
            loader.loadTestsFromModule(m, False)
        with self.assertRaises(TypeError):
            loader.loadTestsFromModule(m, use_load_tests=False)

    def test_loadTestsFromModule__pattern(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        load_tests_args = []
        def load_tests(loader, tests, pattern):
            self.assertIsInstance(tests, unittest.TestSuite)
            load_tests_args.extend((loader, tests, pattern))
            return tests
        m.load_tests = load_tests

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m, pattern='testme.*')
        self.assertIsInstance(suite, unittest.TestSuite)
        self.assertEqual(load_tests_args, [loader, suite, 'testme.*'])

    def test_loadTestsFromModule__faulty_load_tests(self):
        m = types.ModuleType('m')

        def load_tests(loader, tests, pattern):
            raise TypeError('some failure')
        m.load_tests = load_tests

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m)
        self.assertIsInstance(suite, unittest.TestSuite)
        self.assertEqual(suite.countTestCases(), 1)
        
        self.assertNotEqual([], loader.errors)
        self.assertEqual(1, len(loader.errors))
        error = loader.errors[0]
        self.assertTrue(
            'Failed to call load_tests:' in error,
            'missing error string in %r' % error)
        test = list(suite)[0]

        self.assertRaisesRegex(TypeError, "some failure", test.m)

    
    

    
    

    
    
    
    
    
    
    def test_loadTestsFromName__empty_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromName('')
        except ValueError as e:
            self.assertEqual(str(e), "Empty module name")
        else:
            self.fail("TestLoader.loadTestsFromName failed to raise ValueError")

    
    
    
    
    
    
    def test_loadTestsFromName__malformed_name(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('abc () //')
        error, test = self.check_deferred_error(loader, suite)
        expected = "Failed to import test module: abc () //"
        expected_regex = r"Failed to import test module: abc \(\) //"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(
            ImportError, expected_regex, getattr(test, 'abc () //'))

    
    
    
    
    def test_loadTestsFromName__unknown_module_name(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('sdasfasfasdf')
        expected = "No module named 'sdasfasfasdf'"
        error, test = self.check_deferred_error(loader, suite)
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(ImportError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    def test_loadTestsFromName__unknown_attr_name_on_module(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('unittest.loader.sdasfasfasdf')
        expected = "module 'unittest.loader' has no attribute 'sdasfasfasdf'"
        error, test = self.check_deferred_error(loader, suite)
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    def test_loadTestsFromName__unknown_attr_name_on_package(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('unittest.sdasfasfasdf')
        expected = "No module named 'unittest.sdasfasfasdf'"
        error, test = self.check_deferred_error(loader, suite)
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(ImportError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    
    def test_loadTestsFromName__relative_unknown_name(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('sdasfasfasdf', unittest)
        expected = "module 'unittest' has no attribute 'sdasfasfasdf'"
        error, test = self.check_deferred_error(loader, suite)
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    
    
    
    
    
    def test_loadTestsFromName__relative_empty_name(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('', unittest)
        error, test = self.check_deferred_error(loader, suite)
        expected = "has no attribute ''"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, getattr(test, ''))

    
    
    
    
    
    
    
    
    
    def test_loadTestsFromName__relative_malformed_name(self):
        loader = unittest.TestLoader()

        
        suite = loader.loadTestsFromName('abc () //', unittest)
        error, test = self.check_deferred_error(loader, suite)
        expected = "module 'unittest' has no attribute 'abc () //'"
        expected_regex = r"module 'unittest' has no attribute 'abc \(\) //'"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(
            AttributeError, expected_regex, getattr(test, 'abc () //'))

    
    
    
    
    
    
    
    
    
    def test_loadTestsFromName__relative_not_a_module(self):
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass

        class NotAModule(object):
            test_2 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName('test_2', NotAModule)

        reference = [MyTestCase('test')]
        self.assertEqual(list(suite), reference)

    
    
    
    
    
    
    
    def test_loadTestsFromName__relative_bad_object(self):
        m = types.ModuleType('m')
        m.testcase_1 = object()

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromName('testcase_1', m)
        except TypeError:
            pass
        else:
            self.fail("Should have raised TypeError")

    
    
    def test_loadTestsFromName__relative_TestCase_subclass(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName('testcase_1', m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [MyTestCase('test')])

    
    
    
    
    def test_loadTestsFromName__relative_TestSuite(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testsuite = unittest.TestSuite([MyTestCase('test')])

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName('testsuite', m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [MyTestCase('test')])

    
    
    def test_loadTestsFromName__relative_testmethod(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName('testcase_1.test', m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [MyTestCase('test')])

    
    
    
    
    
    
    
    
    def test_loadTestsFromName__relative_invalid_testmethod(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName('testcase_1.testfoo', m)
        expected = "type object 'MyTestCase' has no attribute 'testfoo'"
        error, test = self.check_deferred_error(loader, suite)
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, test.testfoo)

    
    
    def test_loadTestsFromName__callable__TestSuite(self):
        m = types.ModuleType('m')
        testcase_1 = unittest.FunctionTestCase(lambda: None)
        testcase_2 = unittest.FunctionTestCase(lambda: None)
        def return_TestSuite():
            return unittest.TestSuite([testcase_1, testcase_2])
        m.return_TestSuite = return_TestSuite

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName('return_TestSuite', m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [testcase_1, testcase_2])

    
    
    def test_loadTestsFromName__callable__TestCase_instance(self):
        m = types.ModuleType('m')
        testcase_1 = unittest.FunctionTestCase(lambda: None)
        def return_TestCase():
            return testcase_1
        m.return_TestCase = return_TestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName('return_TestCase', m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [testcase_1])

    
    
    
    
    
    def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass(self):
        class SubTestSuite(unittest.TestSuite):
            pass
        m = types.ModuleType('m')
        testcase_1 = unittest.FunctionTestCase(lambda: None)
        def return_TestCase():
            return testcase_1
        m.return_TestCase = return_TestCase

        loader = unittest.TestLoader()
        loader.suiteClass = SubTestSuite
        suite = loader.loadTestsFromName('return_TestCase', m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [testcase_1])

    
    
    
    
    
    def test_loadTestsFromName__relative_testmethod_ProperSuiteClass(self):
        class SubTestSuite(unittest.TestSuite):
            pass
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        loader.suiteClass=SubTestSuite
        suite = loader.loadTestsFromName('testcase_1.test', m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [MyTestCase('test')])

    
    
    
    
    def test_loadTestsFromName__callable__wrong_type(self):
        m = types.ModuleType('m')
        def return_wrong():
            return 6
        m.return_wrong = return_wrong

        loader = unittest.TestLoader()
        try:
            suite = loader.loadTestsFromName('return_wrong', m)
        except TypeError:
            pass
        else:
            self.fail("TestLoader.loadTestsFromName failed to raise TypeError")

    
    
    def test_loadTestsFromName__module_not_loaded(self):
        
        
        
        module_name = 'test.test_unittest.dummy'
        sys.modules.pop(module_name, None)

        loader = unittest.TestLoader()
        try:
            suite = loader.loadTestsFromName(module_name)

            self.assertIsInstance(suite, loader.suiteClass)
            self.assertEqual(list(suite), [])

            
            self.assertIn(module_name, sys.modules)
        finally:
            if module_name in sys.modules:
                del sys.modules[module_name]

    
    

    
    

    def check_deferred_error(self, loader, suite):
        
        self.assertIsInstance(suite, unittest.TestSuite)
        self.assertEqual(suite.countTestCases(), 1)
        
        self.assertNotEqual([], loader.errors)
        self.assertEqual(1, len(loader.errors))
        error = loader.errors[0]
        test = list(suite)[0]
        return error, test

    
    
    
    
    def test_loadTestsFromNames__empty_name_list(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromNames([])
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [])

    
    
    
    
    
    
    
    
    def test_loadTestsFromNames__relative_empty_name_list(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromNames([], unittest)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [])

    
    
    
    
    
    
    def test_loadTestsFromNames__empty_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromNames([''])
        except ValueError as e:
            self.assertEqual(str(e), "Empty module name")
        else:
            self.fail("TestLoader.loadTestsFromNames failed to raise ValueError")

    
    
    
    
    
    
    def test_loadTestsFromNames__malformed_name(self):
        loader = unittest.TestLoader()

        
        suite = loader.loadTestsFromNames(['abc () //'])
        error, test = self.check_deferred_error(loader, list(suite)[0])
        expected = "Failed to import test module: abc () //"
        expected_regex = r"Failed to import test module: abc \(\) //"
        self.assertIn(
            expected,  error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(
            ImportError, expected_regex, getattr(test, 'abc () //'))

    
    
    
    
    
    
    def test_loadTestsFromNames__unknown_module_name(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromNames(['sdasfasfasdf'])
        error, test = self.check_deferred_error(loader, list(suite)[0])
        expected = "Failed to import test module: sdasfasfasdf"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(ImportError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    def test_loadTestsFromNames__unknown_attr_name(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromNames(
            ['unittest.loader.sdasfasfasdf', 'test.test_unittest.dummy'])
        error, test = self.check_deferred_error(loader, list(suite)[0])
        expected = "module 'unittest.loader' has no attribute 'sdasfasfasdf'"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    
    
    
    def test_loadTestsFromNames__unknown_name_relative_1(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromNames(['sdasfasfasdf'], unittest)
        error, test = self.check_deferred_error(loader, list(suite)[0])
        expected = "module 'unittest' has no attribute 'sdasfasfasdf'"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    
    
    
    def test_loadTestsFromNames__unknown_name_relative_2(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest)
        error, test = self.check_deferred_error(loader, list(suite)[1])
        expected = "module 'unittest' has no attribute 'sdasfasfasdf'"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, test.sdasfasfasdf)

    
    
    
    
    
    
    
    
    
    
    
    def test_loadTestsFromNames__relative_empty_name(self):
        loader = unittest.TestLoader()

        suite = loader.loadTestsFromNames([''], unittest)
        error, test = self.check_deferred_error(loader, list(suite)[0])
        expected = "has no attribute ''"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, getattr(test, ''))

    
    
    
    
    
    
    
    
    def test_loadTestsFromNames__relative_malformed_name(self):
        loader = unittest.TestLoader()

        
        suite = loader.loadTestsFromNames(['abc () //'], unittest)
        error, test = self.check_deferred_error(loader, list(suite)[0])
        expected = "module 'unittest' has no attribute 'abc () //'"
        expected_regex = r"module 'unittest' has no attribute 'abc \(\) //'"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(
            AttributeError, expected_regex, getattr(test, 'abc () //'))

    
    
    
    
    
    
    
    def test_loadTestsFromNames__relative_not_a_module(self):
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass

        class NotAModule(object):
            test_2 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['test_2'], NotAModule)

        reference = [unittest.TestSuite([MyTestCase('test')])]
        self.assertEqual(list(suite), reference)

    
    
    
    
    
    
    
    def test_loadTestsFromNames__relative_bad_object(self):
        m = types.ModuleType('m')
        m.testcase_1 = object()

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromNames(['testcase_1'], m)
        except TypeError:
            pass
        else:
            self.fail("Should have raised TypeError")

    
    
    def test_loadTestsFromNames__relative_TestCase_subclass(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['testcase_1'], m)
        self.assertIsInstance(suite, loader.suiteClass)

        expected = loader.suiteClass([MyTestCase('test')])
        self.assertEqual(list(suite), [expected])

    
    
    def test_loadTestsFromNames__relative_TestSuite(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testsuite = unittest.TestSuite([MyTestCase('test')])

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['testsuite'], m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [m.testsuite])

    
    
    def test_loadTestsFromNames__relative_testmethod(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['testcase_1.test'], m)
        self.assertIsInstance(suite, loader.suiteClass)

        ref_suite = unittest.TestSuite([MyTestCase('test')])
        self.assertEqual(list(suite), [ref_suite])

    
    
    def test_loadTestsFromName__function_with_different_name_than_method(self):
        
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            test = lambda: 1
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['testcase_1.test'], m)
        self.assertIsInstance(suite, loader.suiteClass)

        ref_suite = unittest.TestSuite([MyTestCase('test')])
        self.assertEqual(list(suite), [ref_suite])

    
    
    
    
    
    def test_loadTestsFromNames__relative_invalid_testmethod(self):
        m = types.ModuleType('m')
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['testcase_1.testfoo'], m)
        error, test = self.check_deferred_error(loader, list(suite)[0])
        expected = "type object 'MyTestCase' has no attribute 'testfoo'"
        self.assertIn(
            expected, error,
            'missing error string in %r' % error)
        self.assertRaisesRegex(AttributeError, expected, test.testfoo)

    
    
    def test_loadTestsFromNames__callable__TestSuite(self):
        m = types.ModuleType('m')
        testcase_1 = unittest.FunctionTestCase(lambda: None)
        testcase_2 = unittest.FunctionTestCase(lambda: None)
        def return_TestSuite():
            return unittest.TestSuite([testcase_1, testcase_2])
        m.return_TestSuite = return_TestSuite

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['return_TestSuite'], m)
        self.assertIsInstance(suite, loader.suiteClass)

        expected = unittest.TestSuite([testcase_1, testcase_2])
        self.assertEqual(list(suite), [expected])

    
    
    def test_loadTestsFromNames__callable__TestCase_instance(self):
        m = types.ModuleType('m')
        testcase_1 = unittest.FunctionTestCase(lambda: None)
        def return_TestCase():
            return testcase_1
        m.return_TestCase = return_TestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['return_TestCase'], m)
        self.assertIsInstance(suite, loader.suiteClass)

        ref_suite = unittest.TestSuite([testcase_1])
        self.assertEqual(list(suite), [ref_suite])

    
    
    
    
    def test_loadTestsFromNames__callable__call_staticmethod(self):
        m = types.ModuleType('m')
        class Test1(unittest.TestCase):
            def test(self):
                pass

        testcase_1 = Test1('test')
        class Foo(unittest.TestCase):
            @staticmethod
            def foo():
                return testcase_1
        m.Foo = Foo

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames(['Foo.foo'], m)
        self.assertIsInstance(suite, loader.suiteClass)

        ref_suite = unittest.TestSuite([testcase_1])
        self.assertEqual(list(suite), [ref_suite])

    
    
    
    
    def test_loadTestsFromNames__callable__wrong_type(self):
        m = types.ModuleType('m')
        def return_wrong():
            return 6
        m.return_wrong = return_wrong

        loader = unittest.TestLoader()
        try:
            suite = loader.loadTestsFromNames(['return_wrong'], m)
        except TypeError:
            pass
        else:
            self.fail("TestLoader.loadTestsFromNames failed to raise TypeError")

    
    
    def test_loadTestsFromNames__module_not_loaded(self):
        
        
        
        module_name = 'test.test_unittest.dummy'
        sys.modules.pop(module_name, None)

        loader = unittest.TestLoader()
        try:
            suite = loader.loadTestsFromNames([module_name])

            self.assertIsInstance(suite, loader.suiteClass)
            self.assertEqual(list(suite), [unittest.TestSuite()])

            
            self.assertIn(module_name, sys.modules)
        finally:
            if module_name in sys.modules:
                del sys.modules[module_name]

    
    

    
    

    
    
    
    
    def test_getTestCaseNames(self):
        class Test(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foobar(self): pass

        loader = unittest.TestLoader()

        self.assertEqual(loader.getTestCaseNames(Test), ['test_1', 'test_2'])

    
    
    
    def test_getTestCaseNames__no_tests(self):
        class Test(unittest.TestCase):
            def foobar(self): pass

        loader = unittest.TestLoader()

        self.assertEqual(loader.getTestCaseNames(Test), [])

    
    
    
    
    
    
    
    
    def test_getTestCaseNames__not_a_TestCase(self):
        class BadCase(int):
            def test_foo(self):
                pass

        loader = unittest.TestLoader()
        names = loader.getTestCaseNames(BadCase)

        self.assertEqual(names, ['test_foo'])

    
    
    
    
    
    
    def test_getTestCaseNames__inheritance(self):
        class TestP(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foobar(self): pass

        class TestC(TestP):
            def test_1(self): pass
            def test_3(self): pass

        loader = unittest.TestLoader()

        names = ['test_1', 'test_2', 'test_3']
        self.assertEqual(loader.getTestCaseNames(TestC), names)

    
    
    
    
    def test_getTestCaseNames__testNamePatterns(self):
        class MyTest(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foobar(self): pass

        loader = unittest.TestLoader()

        loader.testNamePatterns = []
        self.assertEqual(loader.getTestCaseNames(MyTest), [])

        loader.testNamePatterns = ['*1']
        self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1'])

        loader.testNamePatterns = ['*1', '*2']
        self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1', 'test_2'])

        loader.testNamePatterns = ['*My*']
        self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1', 'test_2'])

        loader.testNamePatterns = ['*my*']
        self.assertEqual(loader.getTestCaseNames(MyTest), [])

    
    
    
    
    
    
    
    def test_getTestCaseNames__testNamePatterns__attribute_access_regression(self):
        class Trap:
            def __get__(*ignored):
                self.fail('Non-test attribute accessed')

        class MyTest(unittest.TestCase):
            def test_1(self): pass
            foobar = Trap()

        loader = unittest.TestLoader()
        self.assertEqual(loader.getTestCaseNames(MyTest), ['test_1'])

        loader = unittest.TestLoader()
        loader.testNamePatterns = []
        self.assertEqual(loader.getTestCaseNames(MyTest), [])

    
    

    
    

    
    
    
    
    
    def test_testMethodPrefix__loadTestsFromTestCase(self):
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass

        tests_1 = unittest.TestSuite([Foo('foo_bar')])
        tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')])

        loader = unittest.TestLoader()
        loader.testMethodPrefix = 'foo'
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_1)

        loader.testMethodPrefix = 'test'
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_2)

    
    
    
    
    
    def test_testMethodPrefix__loadTestsFromModule(self):
        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests_1 = [unittest.TestSuite([Foo('foo_bar')])]
        tests_2 = [unittest.TestSuite([Foo('test_1'), Foo('test_2')])]

        loader = unittest.TestLoader()
        loader.testMethodPrefix = 'foo'
        self.assertEqual(list(loader.loadTestsFromModule(m)), tests_1)

        loader.testMethodPrefix = 'test'
        self.assertEqual(list(loader.loadTestsFromModule(m)), tests_2)

    
    
    
    
    
    def test_testMethodPrefix__loadTestsFromName(self):
        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests_1 = unittest.TestSuite([Foo('foo_bar')])
        tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')])

        loader = unittest.TestLoader()
        loader.testMethodPrefix = 'foo'
        self.assertEqual(loader.loadTestsFromName('Foo', m), tests_1)

        loader.testMethodPrefix = 'test'
        self.assertEqual(loader.loadTestsFromName('Foo', m), tests_2)

    
    
    
    
    
    def test_testMethodPrefix__loadTestsFromNames(self):
        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests_1 = unittest.TestSuite([unittest.TestSuite([Foo('foo_bar')])])
        tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')])
        tests_2 = unittest.TestSuite([tests_2])

        loader = unittest.TestLoader()
        loader.testMethodPrefix = 'foo'
        self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_1)

        loader.testMethodPrefix = 'test'
        self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_2)

    
    def test_testMethodPrefix__default_value(self):
        loader = unittest.TestLoader()
        self.assertEqual(loader.testMethodPrefix, 'test')

    
    

    
    

    
    
    def test_sortTestMethodsUsing__loadTestsFromTestCase(self):
        def reversed_cmp(x, y):
            return -((x > y) - (x < y))

        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass

        loader = unittest.TestLoader()
        loader.sortTestMethodsUsing = reversed_cmp

        tests = loader.suiteClass([Foo('test_2'), Foo('test_1')])
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)

    
    
    def test_sortTestMethodsUsing__loadTestsFromModule(self):
        def reversed_cmp(x, y):
            return -((x > y) - (x < y))

        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
        m.Foo = Foo

        loader = unittest.TestLoader()
        loader.sortTestMethodsUsing = reversed_cmp

        tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])]
        self.assertEqual(list(loader.loadTestsFromModule(m)), tests)

    
    
    def test_sortTestMethodsUsing__loadTestsFromName(self):
        def reversed_cmp(x, y):
            return -((x > y) - (x < y))

        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
        m.Foo = Foo

        loader = unittest.TestLoader()
        loader.sortTestMethodsUsing = reversed_cmp

        tests = loader.suiteClass([Foo('test_2'), Foo('test_1')])
        self.assertEqual(loader.loadTestsFromName('Foo', m), tests)

    
    
    def test_sortTestMethodsUsing__loadTestsFromNames(self):
        def reversed_cmp(x, y):
            return -((x > y) - (x < y))

        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
        m.Foo = Foo

        loader = unittest.TestLoader()
        loader.sortTestMethodsUsing = reversed_cmp

        tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])]
        self.assertEqual(list(loader.loadTestsFromNames(['Foo'], m)), tests)

    
    
    
    
    def test_sortTestMethodsUsing__getTestCaseNames(self):
        def reversed_cmp(x, y):
            return -((x > y) - (x < y))

        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass

        loader = unittest.TestLoader()
        loader.sortTestMethodsUsing = reversed_cmp

        test_names = ['test_2', 'test_1']
        self.assertEqual(loader.getTestCaseNames(Foo), test_names)

    
    
    
    def test_sortTestMethodsUsing__default_value(self):
        loader = unittest.TestLoader()

        class Foo(unittest.TestCase):
            def test_2(self): pass
            def test_3(self): pass
            def test_1(self): pass

        test_names = ['test_2', 'test_3', 'test_1']
        self.assertEqual(loader.getTestCaseNames(Foo), sorted(test_names))


    
    
    
    
    def test_sortTestMethodsUsing__None(self):
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass

        loader = unittest.TestLoader()
        loader.sortTestMethodsUsing = None

        test_names = ['test_2', 'test_1']
        self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names))

    
    

    
    

    
    def test_suiteClass__loadTestsFromTestCase(self):
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass

        tests = [Foo('test_1'), Foo('test_2')]

        loader = unittest.TestLoader()
        loader.suiteClass = list
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)

    
    
    def test_suiteClass__loadTestsFromModule(self):
        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests = [[Foo('test_1'), Foo('test_2')]]

        loader = unittest.TestLoader()
        loader.suiteClass = list
        self.assertEqual(loader.loadTestsFromModule(m), tests)

    
    
    def test_suiteClass__loadTestsFromName(self):
        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests = [Foo('test_1'), Foo('test_2')]

        loader = unittest.TestLoader()
        loader.suiteClass = list
        self.assertEqual(loader.loadTestsFromName('Foo', m), tests)

    
    
    def test_suiteClass__loadTestsFromNames(self):
        m = types.ModuleType('m')
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests = [[Foo('test_1'), Foo('test_2')]]

        loader = unittest.TestLoader()
        loader.suiteClass = list
        self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests)

    
    def test_suiteClass__default_value(self):
        loader = unittest.TestLoader()
        self.assertIs(loader.suiteClass, unittest.TestSuite)


    def test_partial_functions(self):
        def noop(arg):
            pass

        class Foo(unittest.TestCase):
            pass

        setattr(Foo, 'test_partial', functools.partial(noop, None))

        loader = unittest.TestLoader()

        test_names = ['test_partial']
        self.assertEqual(loader.getTestCaseNames(Foo), test_names)


class TestObsoleteFunctions(unittest.TestCase):
    class MyTestSuite(unittest.TestSuite):
        pass

    class MyTestCase(unittest.TestCase):
        def check_1(self): pass
        def check_2(self): pass
        def test(self): pass

    @staticmethod
    def reverse_three_way_cmp(a, b):
        return unittest.util.three_way_cmp(b, a)


if __name__ == "__main__":
    unittest.main()