

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: test_loader.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>import sys
import types


import unittest


class Test_TestLoader(unittest.TestCase):

    ### Tests for TestLoader.loadTestsFromTestCase
    ################################################################

    # &quot;Return a suite of all test cases contained in the TestCase-derived
    # class testCaseClass&quot;
    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(&#039;test_1&#039;), Foo(&#039;test_2&#039;)])

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

    # &quot;Return a suite of all test cases contained in the TestCase-derived
    # class testCaseClass&quot;
    #
    # Make sure it does the right thing even if no tests were found
    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)

    # &quot;Return a suite of all test cases contained in the TestCase-derived
    # class testCaseClass&quot;
    #
    # What happens if loadTestsFromTestCase() is given an object
    # that isn&#039;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.
    def test_loadTestsFromTestCase__TestSuite_subclass(self):
        class NotATestCase(unittest.TestSuite):
            pass

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromTestCase(NotATestCase)
        except TypeError:
            pass
        else:
            self.fail(&#039;Should raise TypeError&#039;)

    # &quot;Return a suite of all test cases contained in the TestCase-derived
    # class testCaseClass&quot;
    #
    # 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
    def test_loadTestsFromTestCase__default_method_name(self):
        class Foo(unittest.TestCase):
            def runTest(self):
                pass

        loader = unittest.TestLoader()
        # This has to be false for the test to succeed
        self.assertFalse(&#039;runTest&#039;.startswith(loader.testMethodPrefix))

        suite = loader.loadTestsFromTestCase(Foo)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [Foo(&#039;runTest&#039;)])

    ################################################################
    ### /Tests for TestLoader.loadTestsFromTestCase

    ### Tests for TestLoader.loadTestsFromModule
    ################################################################

    # &quot;This method searches `module` for classes derived from TestCase&quot;
    def test_loadTestsFromModule__TestCase_subclass(self):
        m = types.ModuleType(&#039;m&#039;)
        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(&#039;test&#039;)])]
        self.assertEqual(list(suite), expected)

    # &quot;This method searches `module` for classes derived from TestCase&quot;
    #
    # What happens if no tests are found (no TestCase instances)?
    def test_loadTestsFromModule__no_TestCase_instances(self):
        m = types.ModuleType(&#039;m&#039;)

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

    # &quot;This method searches `module` for classes derived from TestCase&quot;
    #
    # What happens if no tests are found (TestCases instances, but no tests)?
    def test_loadTestsFromModule__no_TestCase_tests(self):
        m = types.ModuleType(&#039;m&#039;)
        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()])

    # &quot;This method searches `module` for classes derived from TestCase&quot;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&#039;ll add a test for it
    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(&#039;test&#039;)])]
        self.assertEqual(list(suite), reference)


    # Check that loadTestsFromModule honors (or not) a module
    # with a load_tests function.
    def test_loadTestsFromModule__load_tests(self):
        m = types.ModuleType(&#039;m&#039;)
        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])

        load_tests_args = []
        suite = loader.loadTestsFromModule(m, use_load_tests=False)
        self.assertEqual(load_tests_args, [])

    def test_loadTestsFromModule__faulty_load_tests(self):
        m = types.ModuleType(&#039;m&#039;)

        def load_tests(loader, tests, pattern):
            raise TypeError(&#039;some failure&#039;)
        m.load_tests = load_tests

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromModule(m)
        self.assertIsInstance(suite, unittest.TestSuite)
        self.assertEqual(suite.countTestCases(), 1)
        test = list(suite)[0]

        self.assertRaisesRegexp(TypeError, &quot;some failure&quot;, test.m)

    ################################################################
    ### /Tests for TestLoader.loadTestsFromModule()

    ### Tests for TestLoader.loadTestsFromName()
    ################################################################

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # Is ValueError raised in response to an empty name?
    def test_loadTestsFromName__empty_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromName(&#039;&#039;)
        except ValueError, e:
            self.assertEqual(str(e), &quot;Empty module name&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise ValueError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # What happens when the name contains invalid characters?
    def test_loadTestsFromName__malformed_name(self):
        loader = unittest.TestLoader()

        # XXX Should this raise ValueError or ImportError?
        try:
            loader.loadTestsFromName(&#039;abc () //&#039;)
        except ValueError:
            pass
        except ImportError:
            pass
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise ValueError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to a
    # module&quot;
    #
    # What happens when a module by that name can&#039;t be found?
    def test_loadTestsFromName__unknown_module_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromName(&#039;sdasfasfasdf&#039;)
        except ImportError, e:
            self.assertEqual(str(e), &quot;No module named sdasfasfasdf&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise ImportError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # What happens when the module is found, but the attribute can&#039;t?
    def test_loadTestsFromName__unknown_attr_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromName(&#039;unittest.sdasfasfasdf&#039;)
        except AttributeError, e:
            self.assertEqual(str(e), &quot;&#039;module&#039; object has no attribute &#039;sdasfasfasdf&#039;&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # What happens when we provide the module, but the attribute can&#039;t be
    # found?
    def test_loadTestsFromName__relative_unknown_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromName(&#039;sdasfasfasdf&#039;, unittest)
        except AttributeError, e:
            self.assertEqual(str(e), &quot;&#039;module&#039; object has no attribute &#039;sdasfasfasdf&#039;&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    # ...
    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # Does loadTestsFromName raise ValueError when passed an empty
    # name relative to a provided module?
    #
    # XXX Should probably raise a ValueError instead of an AttributeError
    def test_loadTestsFromName__relative_empty_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromName(&#039;&#039;, unittest)
        except AttributeError:
            pass
        else:
            self.fail(&quot;Failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    # ...
    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # What happens when an impossible name is given, relative to the provided
    # `module`?
    def test_loadTestsFromName__relative_malformed_name(self):
        loader = unittest.TestLoader()

        # XXX Should this raise AttributeError or ValueError?
        try:
            loader.loadTestsFromName(&#039;abc () //&#039;, unittest)
        except ValueError:
            pass
        except AttributeError:
            pass
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise ValueError&quot;)

    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # Does loadTestsFromName raise TypeError when the `module` argument
    # isn&#039;t a module object?
    #
    # XXX Accepts the not-a-module object, ignoring the object&#039;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
    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(&#039;test_2&#039;, NotAModule)

        reference = [MyTestCase(&#039;test&#039;)]
        self.assertEqual(list(suite), reference)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # Does it raise an exception if the name resolves to an invalid
    # object?
    def test_loadTestsFromName__relative_bad_object(self):
        m = types.ModuleType(&#039;m&#039;)
        m.testcase_1 = object()

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromName(&#039;testcase_1&#039;, m)
        except TypeError:
            pass
        else:
            self.fail(&quot;Should have raised TypeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may
    # resolve either to ... a test case class&quot;
    def test_loadTestsFromName__relative_TestCase_subclass(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

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

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    def test_loadTestsFromName__relative_TestSuite(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testsuite = unittest.TestSuite([MyTestCase(&#039;test&#039;)])

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName(&#039;testsuite&#039;, m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [MyTestCase(&#039;test&#039;)])

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a test method within a test case class&quot;
    def test_loadTestsFromName__relative_testmethod(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromName(&#039;testcase_1.test&#039;, m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [MyTestCase(&#039;test&#039;)])

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # Does loadTestsFromName() raise the proper exception when trying to
    # resolve &quot;a test method within a test case class&quot; that doesn&#039;t exist
    # for the given name (relative to a provided module)?
    def test_loadTestsFromName__relative_invalid_testmethod(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromName(&#039;testcase_1.testfoo&#039;, m)
        except AttributeError, e:
            self.assertEqual(str(e), &quot;type object &#039;MyTestCase&#039; has no attribute &#039;testfoo&#039;&quot;)
        else:
            self.fail(&quot;Failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a ... TestSuite instance&quot;
    def test_loadTestsFromName__callable__TestSuite(self):
        m = types.ModuleType(&#039;m&#039;)
        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(&#039;return_TestSuite&#039;, m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [testcase_1, testcase_2])

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a TestCase ... instance&quot;
    def test_loadTestsFromName__callable__TestCase_instance(self):
        m = types.ModuleType(&#039;m&#039;)
        testcase_1 = unittest.FunctionTestCase(lambda: None)
        def return_TestCase():
            return testcase_1
        m.return_TestCase = return_TestCase

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

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a TestCase ... instance&quot;
    #*****************************************************************
    #Override the suiteClass attribute to ensure that the suiteClass
    #attribute is used
    def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass(self):
        class SubTestSuite(unittest.TestSuite):
            pass
        m = types.ModuleType(&#039;m&#039;)
        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(&#039;return_TestCase&#039;, m)
        self.assertIsInstance(suite, loader.suiteClass)
        self.assertEqual(list(suite), [testcase_1])

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a test method within a test case class&quot;
    #*****************************************************************
    #Override the suiteClass attribute to ensure that the suiteClass
    #attribute is used
    def test_loadTestsFromName__relative_testmethod_ProperSuiteClass(self):
        class SubTestSuite(unittest.TestSuite):
            pass
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        loader.suiteClass=SubTestSuite
        suite = loader.loadTestsFromName(&#039;testcase_1.test&#039;, m)
        self.assertIsInstance(suite, loader.suiteClass)

        self.assertEqual(list(suite), [MyTestCase(&#039;test&#039;)])

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a TestCase or TestSuite instance&quot;
    #
    # What happens if the callable returns something else?
    def test_loadTestsFromName__callable__wrong_type(self):
        m = types.ModuleType(&#039;m&#039;)
        def return_wrong():
            return 6
        m.return_wrong = return_wrong

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromName(&#039;return_wrong&#039;, m)
        except TypeError:
            pass
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise TypeError&quot;)

    # &quot;The specifier can refer to modules and packages which have not been
    # imported; they will be imported as a side-effect&quot;
    def test_loadTestsFromName__module_not_loaded(self):
        # We&#039;re going to try to load this module as a side-effect, so it
        # better not be loaded before we try.
        #
        module_name = &#039;unittest.test.dummy&#039;
        sys.modules.pop(module_name, None)

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

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

            # module should now be loaded, thanks to loadTestsFromName()
            self.assertIn(module_name, sys.modules)
        finally:
            if module_name in sys.modules:
                del sys.modules[module_name]

    ################################################################
    ### Tests for TestLoader.loadTestsFromName()

    ### Tests for TestLoader.loadTestsFromNames()
    ################################################################

    # &quot;Similar to loadTestsFromName(), but takes a sequence of names rather
    # than a single name.&quot;
    #
    # What happens if that sequence of names is empty?
    def test_loadTestsFromNames__empty_name_list(self):
        loader = unittest.TestLoader()

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

    # &quot;Similar to loadTestsFromName(), but takes a sequence of names rather
    # than a single name.&quot;
    # ...
    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # What happens if that sequence of names is empty?
    #
    # XXX Should this raise a ValueError or just return an empty TestSuite?
    def test_loadTestsFromNames__relative_empty_name_list(self):
        loader = unittest.TestLoader()

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

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # Is ValueError raised in response to an empty name?
    def test_loadTestsFromNames__empty_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromNames([&#039;&#039;])
        except ValueError, e:
            self.assertEqual(str(e), &quot;Empty module name&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromNames failed to raise ValueError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # What happens when presented with an impossible module name?
    def test_loadTestsFromNames__malformed_name(self):
        loader = unittest.TestLoader()

        # XXX Should this raise ValueError or ImportError?
        try:
            loader.loadTestsFromNames([&#039;abc () //&#039;])
        except ValueError:
            pass
        except ImportError:
            pass
        else:
            self.fail(&quot;TestLoader.loadTestsFromNames failed to raise ValueError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # What happens when no module can be found for the given name?
    def test_loadTestsFromNames__unknown_module_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromNames([&#039;sdasfasfasdf&#039;])
        except ImportError, e:
            self.assertEqual(str(e), &quot;No module named sdasfasfasdf&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromNames failed to raise ImportError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # What happens when the module can be found, but not the attribute?
    def test_loadTestsFromNames__unknown_attr_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromNames([&#039;unittest.sdasfasfasdf&#039;, &#039;unittest&#039;])
        except AttributeError, e:
            self.assertEqual(str(e), &quot;&#039;module&#039; object has no attribute &#039;sdasfasfasdf&#039;&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromNames failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    # ...
    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # What happens when given an unknown attribute on a specified `module`
    # argument?
    def test_loadTestsFromNames__unknown_name_relative_1(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromNames([&#039;sdasfasfasdf&#039;], unittest)
        except AttributeError, e:
            self.assertEqual(str(e), &quot;&#039;module&#039; object has no attribute &#039;sdasfasfasdf&#039;&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    # ...
    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # Do unknown attributes (relative to a provided module) still raise an
    # exception even in the presence of valid attribute names?
    def test_loadTestsFromNames__unknown_name_relative_2(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromNames([&#039;TestCase&#039;, &#039;sdasfasfasdf&#039;], unittest)
        except AttributeError, e:
            self.assertEqual(str(e), &quot;&#039;module&#039; object has no attribute &#039;sdasfasfasdf&#039;&quot;)
        else:
            self.fail(&quot;TestLoader.loadTestsFromName failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    # ...
    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # What happens when faced with the empty string?
    #
    # XXX This currently raises AttributeError, though ValueError is probably
    # more appropriate
    def test_loadTestsFromNames__relative_empty_name(self):
        loader = unittest.TestLoader()

        try:
            loader.loadTestsFromNames([&#039;&#039;], unittest)
        except AttributeError:
            pass
        else:
            self.fail(&quot;Failed to raise ValueError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    # ...
    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # What happens when presented with an impossible attribute name?
    def test_loadTestsFromNames__relative_malformed_name(self):
        loader = unittest.TestLoader()

        # XXX Should this raise AttributeError or ValueError?
        try:
            loader.loadTestsFromNames([&#039;abc () //&#039;], unittest)
        except AttributeError:
            pass
        except ValueError:
            pass
        else:
            self.fail(&quot;TestLoader.loadTestsFromNames failed to raise ValueError&quot;)

    # &quot;The method optionally resolves name relative to the given module&quot;
    #
    # 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.
    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([&#039;test_2&#039;], NotAModule)

        reference = [unittest.TestSuite([MyTestCase(&#039;test&#039;)])]
        self.assertEqual(list(suite), reference)

    # &quot;The specifier name is a ``dotted name&#039;&#039; 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.&quot;
    #
    # Does it raise an exception if the name resolves to an invalid
    # object?
    def test_loadTestsFromNames__relative_bad_object(self):
        m = types.ModuleType(&#039;m&#039;)
        m.testcase_1 = object()

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromNames([&#039;testcase_1&#039;], m)
        except TypeError:
            pass
        else:
            self.fail(&quot;Should have raised TypeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a test case class&quot;
    def test_loadTestsFromNames__relative_TestCase_subclass(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames([&#039;testcase_1&#039;], m)
        self.assertIsInstance(suite, loader.suiteClass)

        expected = loader.suiteClass([MyTestCase(&#039;test&#039;)])
        self.assertEqual(list(suite), [expected])

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a TestSuite instance&quot;
    def test_loadTestsFromNames__relative_TestSuite(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testsuite = unittest.TestSuite([MyTestCase(&#039;test&#039;)])

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames([&#039;testsuite&#039;], m)
        self.assertIsInstance(suite, loader.suiteClass)

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

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to ... a
    # test method within a test case class&quot;
    def test_loadTestsFromNames__relative_testmethod(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames([&#039;testcase_1.test&#039;], m)
        self.assertIsInstance(suite, loader.suiteClass)

        ref_suite = unittest.TestSuite([MyTestCase(&#039;test&#039;)])
        self.assertEqual(list(suite), [ref_suite])

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to ... a
    # test method within a test case class&quot;
    #
    # Does the method gracefully handle names that initially look like they
    # resolve to &quot;a test method within a test case class&quot; but don&#039;t?
    def test_loadTestsFromNames__relative_invalid_testmethod(self):
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            def test(self):
                pass
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromNames([&#039;testcase_1.testfoo&#039;], m)
        except AttributeError, e:
            self.assertEqual(str(e), &quot;type object &#039;MyTestCase&#039; has no attribute &#039;testfoo&#039;&quot;)
        else:
            self.fail(&quot;Failed to raise AttributeError&quot;)

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a ... TestSuite instance&quot;
    def test_loadTestsFromNames__callable__TestSuite(self):
        m = types.ModuleType(&#039;m&#039;)
        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([&#039;return_TestSuite&#039;], m)
        self.assertIsInstance(suite, loader.suiteClass)

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

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a TestCase ... instance&quot;
    def test_loadTestsFromNames__callable__TestCase_instance(self):
        m = types.ModuleType(&#039;m&#039;)
        testcase_1 = unittest.FunctionTestCase(lambda: None)
        def return_TestCase():
            return testcase_1
        m.return_TestCase = return_TestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames([&#039;return_TestCase&#039;], m)
        self.assertIsInstance(suite, loader.suiteClass)

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

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a TestCase or TestSuite instance&quot;
    #
    # Are staticmethods handled correctly?
    def test_loadTestsFromNames__callable__call_staticmethod(self):
        m = types.ModuleType(&#039;m&#039;)
        class Test1(unittest.TestCase):
            def test(self):
                pass

        testcase_1 = Test1(&#039;test&#039;)
        class Foo(unittest.TestCase):
            @staticmethod
            def foo():
                return testcase_1
        m.Foo = Foo

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames([&#039;Foo.foo&#039;], m)
        self.assertIsInstance(suite, loader.suiteClass)

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

    # &quot;The specifier name is a ``dotted name&#039;&#039; that may resolve ... to
    # ... a callable object which returns a TestCase or TestSuite instance&quot;
    #
    # What happens when the callable returns something else?
    def test_loadTestsFromNames__callable__wrong_type(self):
        m = types.ModuleType(&#039;m&#039;)
        def return_wrong():
            return 6
        m.return_wrong = return_wrong

        loader = unittest.TestLoader()
        try:
            loader.loadTestsFromNames([&#039;return_wrong&#039;], m)
        except TypeError:
            pass
        else:
            self.fail(&quot;TestLoader.loadTestsFromNames failed to raise TypeError&quot;)

    # &quot;The specifier can refer to modules and packages which have not been
    # imported; they will be imported as a side-effect&quot;
    def test_loadTestsFromNames__module_not_loaded(self):
        # We&#039;re going to try to load this module as a side-effect, so it
        # better not be loaded before we try.
        #
        module_name = &#039;unittest.test.dummy&#039;
        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()])

            # module should now be loaded, thanks to loadTestsFromName()
            self.assertIn(module_name, sys.modules)
        finally:
            if module_name in sys.modules:
                del sys.modules[module_name]

    ################################################################
    ### /Tests for TestLoader.loadTestsFromNames()

    ### Tests for TestLoader.getTestCaseNames()
    ################################################################

    # &quot;Return a sorted sequence of method names found within testCaseClass&quot;
    #
    # Test.foobar is defined to make sure getTestCaseNames() respects
    # loader.testMethodPrefix
    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), [&#039;test_1&#039;, &#039;test_2&#039;])

    # &quot;Return a sorted sequence of method names found within testCaseClass&quot;
    #
    # Does getTestCaseNames() behave appropriately if no tests are found?
    def test_getTestCaseNames__no_tests(self):
        class Test(unittest.TestCase):
            def foobar(self): pass

        loader = unittest.TestLoader()

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

    # &quot;Return a sorted sequence of method names found within testCaseClass&quot;
    #
    # Are not-TestCases handled gracefully?
    #
    # XXX This should raise a TypeError, not return a list
    #
    # XXX It&#039;s too late in the 2.5 release cycle to fix this, but it should
    # probably be revisited for 2.6
    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, [&#039;test_foo&#039;])

    # &quot;Return a sorted sequence of method names found within testCaseClass&quot;
    #
    # Make sure inherited names are handled.
    #
    # TestP.foobar is defined to make sure getTestCaseNames() respects
    # loader.testMethodPrefix
    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 = [&#039;test_1&#039;, &#039;test_2&#039;, &#039;test_3&#039;]
        self.assertEqual(loader.getTestCaseNames(TestC), names)

    ################################################################
    ### /Tests for TestLoader.getTestCaseNames()

    ### Tests for TestLoader.testMethodPrefix
    ################################################################

    # &quot;String giving the prefix of method names which will be interpreted as
    # test methods&quot;
    #
    # Implicit in the documentation is that testMethodPrefix is respected by
    # all loadTestsFrom* methods.
    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(&#039;foo_bar&#039;)])
        tests_2 = unittest.TestSuite([Foo(&#039;test_1&#039;), Foo(&#039;test_2&#039;)])

        loader = unittest.TestLoader()
        loader.testMethodPrefix = &#039;foo&#039;
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_1)

        loader.testMethodPrefix = &#039;test&#039;
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_2)

    # &quot;String giving the prefix of method names which will be interpreted as
    # test methods&quot;
    #
    # Implicit in the documentation is that testMethodPrefix is respected by
    # all loadTestsFrom* methods.
    def test_testMethodPrefix__loadTestsFromModule(self):
        m = types.ModuleType(&#039;m&#039;)
        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(&#039;foo_bar&#039;)])]
        tests_2 = [unittest.TestSuite([Foo(&#039;test_1&#039;), Foo(&#039;test_2&#039;)])]

        loader = unittest.TestLoader()
        loader.testMethodPrefix = &#039;foo&#039;
        self.assertEqual(list(loader.loadTestsFromModule(m)), tests_1)

        loader.testMethodPrefix = &#039;test&#039;
        self.assertEqual(list(loader.loadTestsFromModule(m)), tests_2)

    # &quot;String giving the prefix of method names which will be interpreted as
    # test methods&quot;
    #
    # Implicit in the documentation is that testMethodPrefix is respected by
    # all loadTestsFrom* methods.
    def test_testMethodPrefix__loadTestsFromName(self):
        m = types.ModuleType(&#039;m&#039;)
        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(&#039;foo_bar&#039;)])
        tests_2 = unittest.TestSuite([Foo(&#039;test_1&#039;), Foo(&#039;test_2&#039;)])

        loader = unittest.TestLoader()
        loader.testMethodPrefix = &#039;foo&#039;
        self.assertEqual(loader.loadTestsFromName(&#039;Foo&#039;, m), tests_1)

        loader.testMethodPrefix = &#039;test&#039;
        self.assertEqual(loader.loadTestsFromName(&#039;Foo&#039;, m), tests_2)

    # &quot;String giving the prefix of method names which will be interpreted as
    # test methods&quot;
    #
    # Implicit in the documentation is that testMethodPrefix is respected by
    # all loadTestsFrom* methods.
    def test_testMethodPrefix__loadTestsFromNames(self):
        m = types.ModuleType(&#039;m&#039;)
        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(&#039;foo_bar&#039;)])])
        tests_2 = unittest.TestSuite([Foo(&#039;test_1&#039;), Foo(&#039;test_2&#039;)])
        tests_2 = unittest.TestSuite([tests_2])

        loader = unittest.TestLoader()
        loader.testMethodPrefix = &#039;foo&#039;
        self.assertEqual(loader.loadTestsFromNames([&#039;Foo&#039;], m), tests_1)

        loader.testMethodPrefix = &#039;test&#039;
        self.assertEqual(loader.loadTestsFromNames([&#039;Foo&#039;], m), tests_2)

    # &quot;The default value is &#039;test&#039;&quot;
    def test_testMethodPrefix__default_value(self):
        loader = unittest.TestLoader()
        self.assertTrue(loader.testMethodPrefix == &#039;test&#039;)

    ################################################################
    ### /Tests for TestLoader.testMethodPrefix

    ### Tests for TestLoader.sortTestMethodsUsing
    ################################################################

    # &quot;Function to be used to compare method names when sorting them in
    # getTestCaseNames() and all the loadTestsFromX() methods&quot;
    def test_sortTestMethodsUsing__loadTestsFromTestCase(self):
        def reversed_cmp(x, y):
            return -cmp(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(&#039;test_2&#039;), Foo(&#039;test_1&#039;)])
        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)

    # &quot;Function to be used to compare method names when sorting them in
    # getTestCaseNames() and all the loadTestsFromX() methods&quot;
    def test_sortTestMethodsUsing__loadTestsFromModule(self):
        def reversed_cmp(x, y):
            return -cmp(x, y)

        m = types.ModuleType(&#039;m&#039;)
        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(&#039;test_2&#039;), Foo(&#039;test_1&#039;)])]
        self.assertEqual(list(loader.loadTestsFromModule(m)), tests)

    # &quot;Function to be used to compare method names when sorting them in
    # getTestCaseNames() and all the loadTestsFromX() methods&quot;
    def test_sortTestMethodsUsing__loadTestsFromName(self):
        def reversed_cmp(x, y):
            return -cmp(x, y)

        m = types.ModuleType(&#039;m&#039;)
        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(&#039;test_2&#039;), Foo(&#039;test_1&#039;)])
        self.assertEqual(loader.loadTestsFromName(&#039;Foo&#039;, m), tests)

    # &quot;Function to be used to compare method names when sorting them in
    # getTestCaseNames() and all the loadTestsFromX() methods&quot;
    def test_sortTestMethodsUsing__loadTestsFromNames(self):
        def reversed_cmp(x, y):
            return -cmp(x, y)

        m = types.ModuleType(&#039;m&#039;)
        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(&#039;test_2&#039;), Foo(&#039;test_1&#039;)])]
        self.assertEqual(list(loader.loadTestsFromNames([&#039;Foo&#039;], m)), tests)

    # &quot;Function to be used to compare method names when sorting them in
    # getTestCaseNames()&quot;
    #
    # Does it actually affect getTestCaseNames()?
    def test_sortTestMethodsUsing__getTestCaseNames(self):
        def reversed_cmp(x, y):
            return -cmp(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 = [&#039;test_2&#039;, &#039;test_1&#039;]
        self.assertEqual(loader.getTestCaseNames(Foo), test_names)

    # &quot;The default value is the built-in cmp() function&quot;
    def test_sortTestMethodsUsing__default_value(self):
        loader = unittest.TestLoader()
        self.assertTrue(loader.sortTestMethodsUsing is cmp)

    # &quot;it can be set to None to disable the sort.&quot;
    #
    # XXX How is this different from reassigning cmp? Are the tests returned
    # in a random order or something? This behaviour should die
    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 = [&#039;test_2&#039;, &#039;test_1&#039;]
        self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names))

    ################################################################
    ### /Tests for TestLoader.sortTestMethodsUsing

    ### Tests for TestLoader.suiteClass
    ################################################################

    # &quot;Callable object that constructs a test suite from a list of tests.&quot;
    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(&#039;test_1&#039;), Foo(&#039;test_2&#039;)]

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

    # It is implicit in the documentation for TestLoader.suiteClass that
    # all TestLoader.loadTestsFrom* methods respect it. Let&#039;s make sure
    def test_suiteClass__loadTestsFromModule(self):
        m = types.ModuleType(&#039;m&#039;)
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests = [[Foo(&#039;test_1&#039;), Foo(&#039;test_2&#039;)]]

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

    # It is implicit in the documentation for TestLoader.suiteClass that
    # all TestLoader.loadTestsFrom* methods respect it. Let&#039;s make sure
    def test_suiteClass__loadTestsFromName(self):
        m = types.ModuleType(&#039;m&#039;)
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests = [Foo(&#039;test_1&#039;), Foo(&#039;test_2&#039;)]

        loader = unittest.TestLoader()
        loader.suiteClass = list
        self.assertEqual(loader.loadTestsFromName(&#039;Foo&#039;, m), tests)

    # It is implicit in the documentation for TestLoader.suiteClass that
    # all TestLoader.loadTestsFrom* methods respect it. Let&#039;s make sure
    def test_suiteClass__loadTestsFromNames(self):
        m = types.ModuleType(&#039;m&#039;)
        class Foo(unittest.TestCase):
            def test_1(self): pass
            def test_2(self): pass
            def foo_bar(self): pass
        m.Foo = Foo

        tests = [[Foo(&#039;test_1&#039;), Foo(&#039;test_2&#039;)]]

        loader = unittest.TestLoader()
        loader.suiteClass = list
        self.assertEqual(loader.loadTestsFromNames([&#039;Foo&#039;], m), tests)

    # &quot;The default value is the TestSuite class&quot;
    def test_suiteClass__default_value(self):
        loader = unittest.TestLoader()
        self.assertIs(loader.suiteClass, unittest.TestSuite)

    # Make sure the dotted name resolution works even if the actual
    # function doesn&#039;t have the same name as is used to find it.
    def test_loadTestsFromName__function_with_different_name_than_method(self):
        # lambdas have the name &#039;&lt;lambda&gt;&#039;.
        m = types.ModuleType(&#039;m&#039;)
        class MyTestCase(unittest.TestCase):
            test = lambda: 1
        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()
        suite = loader.loadTestsFromNames([&#039;testcase_1.test&#039;], m)
        self.assertIsInstance(suite, loader.suiteClass)

        ref_suite = unittest.TestSuite([MyTestCase(&#039;test&#039;)])
        self.assertEqual(list(suite), [ref_suite])

if __name__ == &#039;__main__&#039;:
    unittest.main()
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python2.7/unittest/test/test_loader.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython2.7%2Funittest%2Ftest' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>