def test_fixture_context_multiple_names_no_common_ancestors(self):
        stream = _WritelnDecorator(StringIO())
        res = _TextTestResult(stream, 0, 2)
        wd = os.path.join(support, 'ltfn')
        l = loader.TestLoader(workingDir=wd)
        suite = l.loadTestsFromNames(
            ['test_pak1.test_mod',
             'test_pak2:test_two_two',
             'test_mod'])
        print suite
        suite(res)
        res.printErrors()
        print stream.getvalue()
        assert not res.errors, res.errors
        assert not res.failures, res.failures
        assert 'state' in sys.modules, \
               "Context not load state module"
        m = sys.modules['state']
        print "state", m.called

        expect = ['test_pak1.setup',
                  'test_pak1.test_mod.setup',
                  'test_pak1.test_mod.test_one_mod_one',
                  'test_pak1.test_mod.teardown',
                  'test_pak1.teardown',
                  'test_pak2.setup',
                  'test_pak2.test_two_two',
                  'test_pak2.teardown',
                  'test_mod.setup',
                  'test_mod.test_mod',
                  'test_mod.teardown']
        self.assertEqual(m.called, expect, diff(expect, m.called))

def _make_result(verbose, failfast):
    """Creates a TextTestResult object that writes a stream to a StringIO"""
    stream = _WritelnDecorator(StringIO())
    result = unittest.TextTestResult(stream, True, verbose)
    result.buffer = False
    result.failfast = failfast
    return result

    def __init__(
        self,
        stream=None,
        descriptions=True,
        verbosity=1,
        failfast=False,
        buffer=False,
        resultclass=None,
        warnings=None,
        *,
        tb_locals=False,
        process_number=multiprocessing.cpu_count(),
        result_collector_class=None
    ):
        if stream is None:
            stream = sys.stderr
        self.stream = _WritelnDecorator(stream)
        self.descriptions = descriptions
        self.verbosity = verbosity
        self.failfast = failfast
        self.buffer = buffer
        self.tb_locals = tb_locals
        self.warnings = warnings

        self.process_number = process_number

        if resultclass is not None:
            if isinstance(resultclass, collections.Iterable):
                self.resultclass = resultclass
            else:
                self.resultclass = (resultclass,)

        if result_collector_class is not None:
            self.result_collector_class = result_collector_class

 def makeResult():
     stream = _WritelnDecorator(StringIO())
     result = resultClass(stream, descriptions=1, verbosity=config.verbosity, config=config)
     plug_result = config.plugins.prepareTestResult(result)
     if plug_result:
         return plug_result
     return result

    def prepareTestResult(self, result):
        result.__failures = []
        result.__errors = []
        result.__tests_run = 0
        result.__start_time = time.time()

        result.stream = _WritelnDecorator(open(os.devnull, 'w'))
        self._result = result

    def set_stream(self, streaming):
        """Set the streaming boolean option to stream TAP directly to stdout.

        The test runner default output will be suppressed in favor of TAP.
        """
        self.stream = _WritelnDecorator(open(os.devnull, "w"))
        _tracker.streaming = streaming
        _tracker.stream = sys.stdout

 def __init__(self, stream=sys.stderr, descriptions=True, verbosity=1,
              failfast=False, buffer=False, resultclass=None):
     self.stream = _WritelnDecorator(stream)
     self.descriptions = descriptions
     self.verbosity = verbosity
     self.failfast = False
     self.buffer = buffer
     if resultclass is not None:
         self.resultclass = resultclass

 def buildReport(self, add_status):
     subject, summary = self._buildSummary(add_status)
     body = StringIO()
     body.write(summary)
     for test in self.unexpectedSuccesses:
         body.write("UNEXPECTED SUCCESS: %s\n" % self.getDescription(test))
     self.stream = _WritelnDecorator(body)
     self.printErrors()
     return subject, body.getvalue()

 def __init__(self, title, verbosity):
     super(NeoTestRunner, self).__init__(
         _WritelnDecorator(sys.stderr), False, verbosity)
     self._title = title
     self.modulesStats = {}
     self.failedImports = {}
     self.run_dict = defaultdict(int)
     self.time_dict = defaultdict(int)
     self.temp_directory = getTempDirectory()

def test_mp_process_args_pickleable():
    test = case.Test(T('runTest'))
    config = Config()
    config.multiprocess_workers = 2
    config.multiprocess_timeout = 0.1
    runner = multiprocess.MultiProcessTestRunner(
        stream=_WritelnDecorator(sys.stdout),
        verbosity=2,
        loaderClass=TestLoader,
        config=config)
    runner.run(test)

 def create_result_object(self):
     result = self.resultClass(
         _WritelnDecorator(StringIO()),
         descriptions=1,
         verbosity=self.config.verbosity,
         config=self.config
     )
     plug_result = self.config.plugins.prepareTestResult(result)
     if plug_result:
         return plug_result
     return result

    def test_load_nonsense_name(self):
        ctx = os.path.join(support, 'ctx')
        l = loader.TestLoader(workingDir=ctx)
        suite = l.loadTestsFromName('fred!')

        res = _TextTestResult(
            stream=_WritelnDecorator(sys.stdout),
            descriptions=0, verbosity=1)
        suite(res)
        print res.errors
        assert res.errors, "Expected errors but got none"
        assert not res.failures, res.failures

 def test_issue_269(self):
     """Test classes that raise exceptions in __init__ do not stop test run
     """
     wdir = os.path.join(support, 'issue269')
     l = loader.TestLoader(workingDir=wdir)
     suite = l.loadTestsFromName('test_bad_class')
     res = _TextTestResult(
         stream=_WritelnDecorator(sys.stdout),
         descriptions=0, verbosity=1)
     suite(res)
     print res.errors
     self.assertEqual(len(res.errors), 1)
     assert 'raise Exception("pow")' in res.errors[0][1]

 def __init__(self, stream=None, descriptions=True, verbosity=1,
              failfast=False, buffer=False, resultclass=None,
              warnings=None):
     if stream is None:
         stream = sys.stderr
     self.stream = runner._WritelnDecorator(stream)
     self.descriptions = descriptions
     self.verbosity = verbosity
     self.failfast = failfast
     self.buffer = buffer
     self.warnings = warnings
     if resultclass is not None:
         self.resultclass = resultclass

def test_mp_process_args_pickleable():
    # TODO(Kumar) this test needs to be more succint.
    # If you start seeing it timeout then perhaps we need to skip it again.
    # raise SkipTest('this currently gets stuck in poll() 90% of the time')
    test = case.Test(T('runTest'))
    config = Config()
    config.multiprocess_workers = 2
    config.multiprocess_timeout = 5
    runner = multiprocess.MultiProcessTestRunner(
        stream=_WritelnDecorator(sys.stdout),
        verbosity=10,
        loaderClass=TestLoader,
        config=config)
    runner.run(test)

    def test_failed_import_module_name(self):
        ctx = os.path.join(support, 'ctx')
        l = loader.TestLoader(workingDir=ctx)
        suite = l.loadTestsFromName('no_such_module')

        res = _TextTestResult(
            stream=_WritelnDecorator(sys.stdout),
            descriptions=0, verbosity=1)
        suite(res)
        print res.errors
        res.printErrors()
        assert res.errors, "Expected errors but got none"
        assert not res.failures, res.failures
        err = res.errors[0][0].test.exc_class
        assert err is ImportError, \
            "Expected import error, got %s" % err

    def test_failed_import(self):
        ctx = os.path.join(support, 'ctx')
        l = loader.TestLoader(workingDir=ctx)
        suite = l.loadTestsFromName('no_such_module.py')

        res = _TextTestResult(
            stream=_WritelnDecorator(sys.stdout),
            descriptions=0, verbosity=1)
        suite(res)

        print res.errors
        res.printErrors()
        assert res.errors, "Expected errors but got none"
        assert not res.failures, res.failures
        assert res.testsRun == 1, \
               "Expected to run 1 tests but ran %s" % res.testsRun

    def test_generator_with_closure(self):
        """Test that a generator test can employ a closure

        Issue #3. If the generator binds early, the last value
        of the closure will be seen for each generated test and
        the tests will fail.
        """
        gen = os.path.join(support, 'gen')
        l = loader.TestLoader(workingDir=gen)
        suite = l.loadTestsFromName('test')
        res = _TextTestResult(
            stream=_WritelnDecorator(sys.stdout),
            descriptions=0, verbosity=1)
        suite(res)
        assert not res.errors
        self.assertEqual(res.testsRun, 5)

    def test_prepare_patches_result(self):
        stream = _WritelnDecorator(StringIO())
        res = _TextTestResult(stream, 0, 1)
        sk = Skip()
        sk.prepareTestResult(res)
        res._orig_addError
        res._orig_printErrors
        res._orig_wasSuccessful
        res.skipped
        self.assertEqual(res.errorClasses,
                         {SkipTest: (res.skipped, 'SKIP', False)})

        # result w/out print works too
        res = unittest.TestResult()
        sk = Skip()
        sk.prepareTestResult(res)
        res._orig_addError
        res.skipped
        self.assertEqual(res.errorClasses,
                         {SkipTest: (res.skipped, 'SKIP', False)})

    def test_deprecated_output(self):
        class TC(unittest.TestCase):
            def test(self):
                raise DeprecatedTest('deprecated me')

        stream = _WritelnDecorator(StringIO())
        res = _TextTestResult(stream, 0, 1)
        sk = Deprecated()
        sk.prepareTestResult(res)

        test = TC('test')
        test(res)
        assert not res.errors, "Deprecated was not caught: %s" % res.errors
        assert res.deprecated            

        res.printErrors()
        out = stream.getvalue()
        assert out
        assert out.strip() == "D"
        assert res.wasSuccessful()