def load_tests_input_scenario_utils(*args):
    """
    Wrapper for testscenarios to set the scenarios to avoid running a getattr
    on the CONF object at import.
    """
    if getattr(args[0], "suiteClass", None) is not None:
        loader, standard_tests, pattern = args
    else:
        standard_tests, module, loader = args
    output = None
    scenario_utils = None
    try:
        scenario_utils = InputScenarioUtils()
        scenario_flavor = scenario_utils.scenario_flavors
        scenario_image = scenario_utils.scenario_images
    except (exc_lib.InvalidCredentials, TypeError):
        output = standard_tests
    finally:
        if scenario_utils:
            scenario_utils.clear_creds()
    if output is not None:
        return output
    for test in testtools.iterate_tests(standard_tests):
        setattr(test, "scenarios", testscenarios.multiply_scenarios(scenario_image, scenario_flavor))
    return testscenarios.load_tests_apply_scenarios(*args)

    def test_load_tests(self):
        tests.write_tree_from_desc('''dir: t
file: t/__init__.py
import unittest

def load_tests(test_loader, tests, ignore):
    # A simple way to reveal the side effect is to add more tests
    class TestLoadTest(unittest.TestCase):
        def test_in_load_test(self):
          self.assertTrue(True)
    tests.addTests(test_loader.loadTestsFromTestCase(TestLoadTest))
    return tests

class TestInit(unittest.TestCase):

    def test_in_init(self):
      self.assertTrue(True)

file: t/test_not_discovered.py
import unittest

class Test(unittest.TestCase):

    def test_me(self):
      self.assertTrue(True)
''')
        test_loader = self.make_test_loader()
        suite = test_loader.discoverTestsFromTree('t')
        self.assertEqual(2, suite.countTestCases())
        self.assertEqual(['t.TestInit.test_in_init',
                          't.TestLoadTest.test_in_load_test'],
                         [t.id() for t in testtools.iterate_tests(suite)])

    def test_regular_below_scripts(self):
        tests.write_tree_from_desc('''dir: t
file: t/__init__.py
dir: t/regular
file: t/regular/__init__.py
from sst import loaders

discover = loaders.discoverRegularTests

file: t/regular/test_foo.py
import unittest

class Test(unittest.TestCase):

    def test_me(self):
      self.assertTrue(True)
file: t/script.py
raise AssertionError('Loading only, executing fails')
''')
        suite = self.discover('t')
        # Check which kind of tests have been discovered or we may miss regular
        # test cases seen as scripts.
        self.assertEqual(['t.regular.test_foo.Test.test_me',
                          't.script'],
                         [t.id() for t in testtools.iterate_tests(suite)])

def partition_tests(suite, count):
    # Keep the same interface as the original concurrencytest.partition_tests
    independent_old_modules = [
        "pcs_test.tier0.test_constraints",
        "pcs_test.tier0.test_resource",
        "pcs_test.tier0.test_stonith",
    ]
    old_tests = [] # tests are not independent, cannot run in parallel
    old_tests_independent = {} # independent modules
    independent_tests = []
    for test in iterate_tests(suite):
        module = test.__class__.__module__
        if not (
            module.startswith("pcs_test.tier0.test_")
            or
            module.startswith("pcs_test.tier0.cib_resource")
        ):
            independent_tests.append(test)
        elif module in independent_old_modules:
            if module not in old_tests_independent:
                old_tests_independent[module] = []
            old_tests_independent[module].append(test)
        else:
            old_tests.append(test)
    return [old_tests, independent_tests] + list(old_tests_independent.values())

    def test_scripts_below_regular(self):
        tests.write_tree_from_desc('''dir: t
file: t/__init__.py
file: t/foo.py
import unittest

class Test(unittest.TestCase):

    def test_me(self):
      self.assertTrue(True)
dir: t/scripts
file: t/scripts/__init__.py
from sst import loader

discover = loader.discoverTestScripts
file: t/scripts/script.py
raise AssertionError('Loading only, executing fails')
''')
        test_loader = loader.TestLoader()
        suite = test_loader.discoverTests('t')
        self.assertEqual(2, suite.countTestCases())
        # Check which kind of tests have been discovered or we may miss regular
        # test cases seen as scripts.
        self.assertEqual(['t.foo.Test.test_me',
                          't.scripts.script'],
                         [t.id() for t in testtools.iterate_tests(suite)])

def _iter_tests(names):
    """
    Given a list of names, iterate through all the tests in them.
    """
    for name in names:
        suite = _load_tests(name)
        for test in iterate_tests(suite):
            yield test

 def test_custom_suite_without_sort_tests_works(self):
     a = PlaceHolder('a')
     b = PlaceHolder('b')
     class Subclass(unittest.TestSuite):pass
     input_suite = Subclass([b, a])
     suite = sorted_tests(input_suite)
     self.assertEqual([b, a], list(iterate_tests(suite)))
     self.assertEqual([input_suite], list(iter(suite)))

 def test_sorts_custom_suites(self):
     a = PlaceHolder('a')
     b = PlaceHolder('b')
     class Subclass(unittest.TestSuite):
         def sort_tests(self):
             self._tests = sorted_tests(self, True)
     input_suite = Subclass([b, a])
     suite = sorted_tests(input_suite)
     self.assertEqual([a, b], list(iterate_tests(suite)))
     self.assertEqual([input_suite], list(iter(suite)))

 def test_load_tests_apply_scenarios(self):
     suite = load_tests_apply_scenarios(
         unittest.TestLoader(),
         [self.SampleTest('test_nothing')],
         None)
     result_tests = list(testtools.iterate_tests(suite))
     self.assertEquals(
         2,
         len(result_tests),
         result_tests)

def partition_tests(suite, count):
    """Partition suite into count lists of tests."""
    # This just assigns tests in a round-robin fashion.  On one hand this
    # splits up blocks of related tests that might run faster if they shared
    # resources, but on the other it avoids assigning blocks of slow tests to
    # just one partition.  So the slowest partition shouldn't be much slower
    # than the fastest.
    partitions = [list() for _ in range(count)]
    tests = iterate_tests(suite)
    for partition, test in zip(cycle(partitions), tests):
        partition.append(test)
    return partitions

 def test_load_tests_apply_scenarios_old_style(self):
     """Call load_tests in the way used by bzr."""
     suite = load_tests_apply_scenarios(
         [self.SampleTest('test_nothing')],
         self.__class__.__module__,
         unittest.TestLoader(),
         )
     result_tests = list(testtools.iterate_tests(suite))
     self.assertEquals(
         2,
         len(result_tests),
         result_tests)

 def load_tests(*args):
     """
     Wrapper for testscenarios to set the mandatory scenarios variable
     only in case a real test loader is in place. Will be automatically
     called in case the variable "load_tests" is set.
     """
     if getattr(args[0], "suiteClass", None) is not None:
         loader, standard_tests, pattern = args
     else:
         standard_tests, module, loader = args
     for test in testtools.iterate_tests(standard_tests):
         schema_file = getattr(test, "_schema_file", None)
         if schema_file is not None:
             setattr(test, "scenarios", NegativeAutoTest.generate_scenario(schema_file))
     return testscenarios.load_tests_apply_scenarios(*args)

    def test_regular_and_scripts_mixed(self):
        def regular(dir_name, name, suffix=None):
            if suffix is None:
                suffix = ''
            return '''
file: {dir_name}/{name}{suffix}
from sst import cases

class Test_{name}(cases.SSTTestCase):
    def test_{name}(self):
        pass
'''.format(**locals())

        tests.write_tree_from_desc('''dir: tests
file: tests/__init__.py
from sst import loader

discover = loader.discoverRegularTests
''')
        tests.write_tree_from_desc(regular('tests', 'test_real', '.py'))
        tests.write_tree_from_desc(regular('tests', 'test_real1', '.py'))
        tests.write_tree_from_desc(regular('tests', 'test_real2', '.py'))
        # Leading '_' => ignored
        tests.write_tree_from_desc(regular('tests', '_hidden', '.py'))
        # Not a python file => ignored
        tests.write_tree_from_desc(regular('tests', 'not-python'))
        # Some empty files
        tests.write_tree_from_desc('''
file: script1.py
file: script2.py
file: not_a_test
# '.p' is intentional, not a typoed '.py'
file: test_not_a_test.p
_hidden_too.py
''')
        test_loader = loader.TestLoader()
        suite = test_loader.discoverTests(
            '.',
            file_loader_class=loader.ScriptLoader,
            dir_loader_class=loader.ScriptDirLoader)
        self.assertEqual(['script1',
                          'script2',
                          'tests.test_real.Test_test_real.test_test_real',
                          'tests.test_real1.Test_test_real1.test_test_real1',
                          'tests.test_real2.Test_test_real2.test_test_real2'],
                         [t.id() for t in testtools.iterate_tests(suite)])

def partition_tests(suite, count):
    # Keep tests from the same class together but allow tests from modules
    # to go to different processes to aid parallelisation.
    modules = {}
    for test in iterate_tests(suite):
        m = test.__module__ + "." + test.__class__.__name__
        if m not in modules:
            modules[m] = []
        modules[m].append(test)

    # Simply divide the test blocks between the available processes
    partitions = [list() for _ in range(count)]
    for partition, m in zip(cycle(partitions), modules):
        partition.extend(modules[m])

    # No point in empty threads so drop them
    return [p for p in partitions if p]

def load_tests_input_scenario_utils(*args):
    """
    Wrapper for testscenarios to set the scenarios to avoid running a getattr
    on the CONF object at import.
    """
    if getattr(args[0], 'suiteClass', None) is not None:
        loader, standard_tests, pattern = args
    else:
        standard_tests, module, loader = args
    scenario_utils = InputScenarioUtils()
    scenario_flavor = scenario_utils.scenario_flavors
    scenario_image = scenario_utils.scenario_images
    for test in testtools.iterate_tests(standard_tests):
        setattr(test, 'scenarios', testscenarios.multiply_scenarios(
            scenario_image,
            scenario_flavor))
    return testscenarios.load_tests_apply_scenarios(*args)

def generate_scenarios(test_or_suite):
    """Yield the tests in test_or_suite with scenario multiplication done.

    TestCase objects with no scenarios specified are yielded unaltered. Tests
    with scenarios are not yielded at all, instead the results of multiplying
    them by the scenarios they specified gets yielded.

    :param test_or_suite: A TestCase or TestSuite.
    :return: A generator of tests - objects satisfying the TestCase protocol.
    """
    for test in iterate_tests(test_or_suite):
        scenarios = getattr(test, 'scenarios', None)
        if scenarios:
            for newtest in apply_scenarios(scenarios, test):
                newtest.scenarios = None
                yield newtest
        else:
            yield test

    def test_discover_changing_file_matcher(self):
        tests.write_tree_from_desc('''dir: t
file: t/__init__.py
file: t/test_foo.py
import unittest

class Test(unittest.TestCase):

    def test_me(self):
      self.assertTrue(True)
dir: t/other
file: t/other/__init__.py
import unittest
from sst import loaders

def discover(test_loader, package, directory_path, names):
    suite = test_loader.loadTestsFromModule(package)
    # Change the test.*\.py rule
    fmatcher = loaders.NameMatcher(includes=['.*'])
    with loaders.NameMatchers(test_loader, fmatcher) as tl:
        suite.addTests(tl.discoverTestsFromNames(directory_path, names))
    return suite

class Test(unittest.TestCase):

    def test_in_init(self):
      self.assertTrue(True)
file: t/other/not_starting_with_test.py
import unittest

class Test(unittest.TestCase):

    def test_me(self):
      self.assertTrue(True)
''')
        test_loader = self.make_test_loader()
        suite = test_loader.discoverTestsFromTree('t')
        self.assertEqual(3, suite.countTestCases())
        self.assertEqual(['t.other.Test.test_in_init',
                          't.other.not_starting_with_test.Test.test_me',
                          't.test_foo.Test.test_me'],
                         [t.id() for t in testtools.iterate_tests(suite)])

 def split_suite(self, suite):
     tests = list(enumerate(iterate_tests(suite)))
     return [(test, _u(str(pos))) for pos, test in tests]

 def split_suite(self, suite):
     tests = list(iterate_tests(suite))
     return tests[0], tests[1]

 def test_num_tests(self):
     num_tests = len(list(iterate_tests(self.suite)))
     self.assertEqual(num_tests, 8)