

<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_result.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 textwrap
from StringIO import StringIO
from test import test_support

import traceback
import unittest


class Test_TestResult(unittest.TestCase):
    # Note: there are not separate tests for TestResult.wasSuccessful(),
    # TestResult.errors, TestResult.failures, TestResult.testsRun or
    # TestResult.shouldStop because these only have meaning in terms of
    # other TestResult methods.
    #
    # Accordingly, tests for the aforenamed attributes are incorporated
    # in with the tests for the defining methods.
    ################################################################

    def test_init(self):
        result = unittest.TestResult()

        self.assertTrue(result.wasSuccessful())
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(result.testsRun, 0)
        self.assertEqual(result.shouldStop, False)
        self.assertIsNone(result._stdout_buffer)
        self.assertIsNone(result._stderr_buffer)


    # &quot;This method can be called to signal that the set of tests being
    # run should be aborted by setting the TestResult&#039;s shouldStop
    # attribute to True.&quot;
    def test_stop(self):
        result = unittest.TestResult()

        result.stop()

        self.assertEqual(result.shouldStop, True)

    # &quot;Called when the test case test is about to be run. The default
    # implementation simply increments the instance&#039;s testsRun counter.&quot;
    def test_startTest(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

        test = Foo(&#039;test_1&#039;)

        result = unittest.TestResult()

        result.startTest(test)

        self.assertTrue(result.wasSuccessful())
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(result.shouldStop, False)

        result.stopTest(test)

    # &quot;Called after the test case test has been executed, regardless of
    # the outcome. The default implementation does nothing.&quot;
    def test_stopTest(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

        test = Foo(&#039;test_1&#039;)

        result = unittest.TestResult()

        result.startTest(test)

        self.assertTrue(result.wasSuccessful())
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(result.shouldStop, False)

        result.stopTest(test)

        # Same tests as above; make sure nothing has changed
        self.assertTrue(result.wasSuccessful())
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(result.shouldStop, False)

    # &quot;Called before and after tests are run. The default implementation does nothing.&quot;
    def test_startTestRun_stopTestRun(self):
        result = unittest.TestResult()
        result.startTestRun()
        result.stopTestRun()

    # &quot;addSuccess(test)&quot;
    # ...
    # &quot;Called when the test case test succeeds&quot;
    # ...
    # &quot;wasSuccessful() - Returns True if all tests run so far have passed,
    # otherwise returns False&quot;
    # ...
    # &quot;testsRun - The total number of tests run so far.&quot;
    # ...
    # &quot;errors - A list containing 2-tuples of TestCase instances and
    # formatted tracebacks. Each tuple represents a test which raised an
    # unexpected exception. Contains formatted
    # tracebacks instead of sys.exc_info() results.&quot;
    # ...
    # &quot;failures - A list containing 2-tuples of TestCase instances and
    # formatted tracebacks. Each tuple represents a test where a failure was
    # explicitly signalled using the TestCase.fail*() or TestCase.assert*()
    # methods. Contains formatted tracebacks instead
    # of sys.exc_info() results.&quot;
    def test_addSuccess(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

        test = Foo(&#039;test_1&#039;)

        result = unittest.TestResult()

        result.startTest(test)
        result.addSuccess(test)
        result.stopTest(test)

        self.assertTrue(result.wasSuccessful())
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(result.shouldStop, False)

    # &quot;addFailure(test, err)&quot;
    # ...
    # &quot;Called when the test case test signals a failure. err is a tuple of
    # the form returned by sys.exc_info(): (type, value, traceback)&quot;
    # ...
    # &quot;wasSuccessful() - Returns True if all tests run so far have passed,
    # otherwise returns False&quot;
    # ...
    # &quot;testsRun - The total number of tests run so far.&quot;
    # ...
    # &quot;errors - A list containing 2-tuples of TestCase instances and
    # formatted tracebacks. Each tuple represents a test which raised an
    # unexpected exception. Contains formatted
    # tracebacks instead of sys.exc_info() results.&quot;
    # ...
    # &quot;failures - A list containing 2-tuples of TestCase instances and
    # formatted tracebacks. Each tuple represents a test where a failure was
    # explicitly signalled using the TestCase.fail*() or TestCase.assert*()
    # methods. Contains formatted tracebacks instead
    # of sys.exc_info() results.&quot;
    def test_addFailure(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

        test = Foo(&#039;test_1&#039;)
        try:
            test.fail(&quot;foo&quot;)
        except:
            exc_info_tuple = sys.exc_info()

        result = unittest.TestResult()

        result.startTest(test)
        result.addFailure(test, exc_info_tuple)
        result.stopTest(test)

        self.assertFalse(result.wasSuccessful())
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.failures), 1)
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(result.shouldStop, False)

        test_case, formatted_exc = result.failures[0]
        self.assertIs(test_case, test)
        self.assertIsInstance(formatted_exc, str)

    # &quot;addError(test, err)&quot;
    # ...
    # &quot;Called when the test case test raises an unexpected exception err
    # is a tuple of the form returned by sys.exc_info():
    # (type, value, traceback)&quot;
    # ...
    # &quot;wasSuccessful() - Returns True if all tests run so far have passed,
    # otherwise returns False&quot;
    # ...
    # &quot;testsRun - The total number of tests run so far.&quot;
    # ...
    # &quot;errors - A list containing 2-tuples of TestCase instances and
    # formatted tracebacks. Each tuple represents a test which raised an
    # unexpected exception. Contains formatted
    # tracebacks instead of sys.exc_info() results.&quot;
    # ...
    # &quot;failures - A list containing 2-tuples of TestCase instances and
    # formatted tracebacks. Each tuple represents a test where a failure was
    # explicitly signalled using the TestCase.fail*() or TestCase.assert*()
    # methods. Contains formatted tracebacks instead
    # of sys.exc_info() results.&quot;
    def test_addError(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

        test = Foo(&#039;test_1&#039;)
        try:
            raise TypeError()
        except:
            exc_info_tuple = sys.exc_info()

        result = unittest.TestResult()

        result.startTest(test)
        result.addError(test, exc_info_tuple)
        result.stopTest(test)

        self.assertFalse(result.wasSuccessful())
        self.assertEqual(len(result.errors), 1)
        self.assertEqual(len(result.failures), 0)
        self.assertEqual(result.testsRun, 1)
        self.assertEqual(result.shouldStop, False)

        test_case, formatted_exc = result.errors[0]
        self.assertIs(test_case, test)
        self.assertIsInstance(formatted_exc, str)

    def testGetDescriptionWithoutDocstring(self):
        result = unittest.TextTestResult(None, True, 1)
        self.assertEqual(
                result.getDescription(self),
                &#039;testGetDescriptionWithoutDocstring (&#039; + __name__ +
                &#039;.Test_TestResult)&#039;)

    @unittest.skipIf(sys.flags.optimize &gt;= 2,
                     &quot;Docstrings are omitted with -O2 and above&quot;)
    def testGetDescriptionWithOneLineDocstring(self):
        &quot;&quot;&quot;Tests getDescription() for a method with a docstring.&quot;&quot;&quot;
        result = unittest.TextTestResult(None, True, 1)
        self.assertEqual(
                result.getDescription(self),
               (&#039;testGetDescriptionWithOneLineDocstring &#039;
                &#039;(&#039; + __name__ + &#039;.Test_TestResult)\n&#039;
                &#039;Tests getDescription() for a method with a docstring.&#039;))

    @unittest.skipIf(sys.flags.optimize &gt;= 2,
                     &quot;Docstrings are omitted with -O2 and above&quot;)
    def testGetDescriptionWithMultiLineDocstring(self):
        &quot;&quot;&quot;Tests getDescription() for a method with a longer docstring.
        The second line of the docstring.
        &quot;&quot;&quot;
        result = unittest.TextTestResult(None, True, 1)
        self.assertEqual(
                result.getDescription(self),
               (&#039;testGetDescriptionWithMultiLineDocstring &#039;
                &#039;(&#039; + __name__ + &#039;.Test_TestResult)\n&#039;
                &#039;Tests getDescription() for a method with a longer &#039;
                &#039;docstring.&#039;))

    def testStackFrameTrimming(self):
        class Frame(object):
            class tb_frame(object):
                f_globals = {}
        result = unittest.TestResult()
        self.assertFalse(result._is_relevant_tb_level(Frame))

        Frame.tb_frame.f_globals[&#039;__unittest&#039;] = True
        self.assertTrue(result._is_relevant_tb_level(Frame))

    def testFailFast(self):
        result = unittest.TestResult()
        result._exc_info_to_string = lambda *_: &#039;&#039;
        result.failfast = True
        result.addError(None, None)
        self.assertTrue(result.shouldStop)

        result = unittest.TestResult()
        result._exc_info_to_string = lambda *_: &#039;&#039;
        result.failfast = True
        result.addFailure(None, None)
        self.assertTrue(result.shouldStop)

        result = unittest.TestResult()
        result._exc_info_to_string = lambda *_: &#039;&#039;
        result.failfast = True
        result.addUnexpectedSuccess(None)
        self.assertTrue(result.shouldStop)

    def testFailFastSetByRunner(self):
        runner = unittest.TextTestRunner(stream=StringIO(), failfast=True)
        def test(result):
            self.assertTrue(result.failfast)
        runner.run(test)


classDict = dict(unittest.TestResult.__dict__)
for m in (&#039;addSkip&#039;, &#039;addExpectedFailure&#039;, &#039;addUnexpectedSuccess&#039;,
           &#039;__init__&#039;):
    del classDict[m]

def __init__(self, stream=None, descriptions=None, verbosity=None):
    self.failures = []
    self.errors = []
    self.testsRun = 0
    self.shouldStop = False
    self.buffer = False

classDict[&#039;__init__&#039;] = __init__
OldResult = type(&#039;OldResult&#039;, (object,), classDict)

class Test_OldTestResult(unittest.TestCase):

    def assertOldResultWarning(self, test, failures):
        with test_support.check_warnings((&quot;TestResult has no add.+ method,&quot;,
                                          RuntimeWarning)):
            result = OldResult()
            test.run(result)
            self.assertEqual(len(result.failures), failures)

    def testOldTestResult(self):
        class Test(unittest.TestCase):
            def testSkip(self):
                self.skipTest(&#039;foobar&#039;)
            @unittest.expectedFailure
            def testExpectedFail(self):
                raise TypeError
            @unittest.expectedFailure
            def testUnexpectedSuccess(self):
                pass

        for test_name, should_pass in ((&#039;testSkip&#039;, True),
                                       (&#039;testExpectedFail&#039;, True),
                                       (&#039;testUnexpectedSuccess&#039;, False)):
            test = Test(test_name)
            self.assertOldResultWarning(test, int(not should_pass))

    def testOldTestTesultSetup(self):
        class Test(unittest.TestCase):
            def setUp(self):
                self.skipTest(&#039;no reason&#039;)
            def testFoo(self):
                pass
        self.assertOldResultWarning(Test(&#039;testFoo&#039;), 0)

    def testOldTestResultClass(self):
        @unittest.skip(&#039;no reason&#039;)
        class Test(unittest.TestCase):
            def testFoo(self):
                pass
        self.assertOldResultWarning(Test(&#039;testFoo&#039;), 0)

    def testOldResultWithRunner(self):
        class Test(unittest.TestCase):
            def testFoo(self):
                pass
        runner = unittest.TextTestRunner(resultclass=OldResult,
                                          stream=StringIO())
        # This will raise an exception if TextTestRunner can&#039;t handle old
        # test result objects
        runner.run(Test(&#039;testFoo&#039;))


class MockTraceback(object):
    @staticmethod
    def format_exception(*_):
        return [&#039;A traceback&#039;]

def restore_traceback():
    unittest.result.traceback = traceback


class TestOutputBuffering(unittest.TestCase):

    def setUp(self):
        self._real_out = sys.stdout
        self._real_err = sys.stderr

    def tearDown(self):
        sys.stdout = self._real_out
        sys.stderr = self._real_err

    def testBufferOutputOff(self):
        real_out = self._real_out
        real_err = self._real_err

        result = unittest.TestResult()
        self.assertFalse(result.buffer)

        self.assertIs(real_out, sys.stdout)
        self.assertIs(real_err, sys.stderr)

        result.startTest(self)

        self.assertIs(real_out, sys.stdout)
        self.assertIs(real_err, sys.stderr)

    def testBufferOutputStartTestAddSuccess(self):
        real_out = self._real_out
        real_err = self._real_err

        result = unittest.TestResult()
        self.assertFalse(result.buffer)

        result.buffer = True

        self.assertIs(real_out, sys.stdout)
        self.assertIs(real_err, sys.stderr)

        result.startTest(self)

        self.assertIsNot(real_out, sys.stdout)
        self.assertIsNot(real_err, sys.stderr)
        self.assertIsInstance(sys.stdout, StringIO)
        self.assertIsInstance(sys.stderr, StringIO)
        self.assertIsNot(sys.stdout, sys.stderr)

        out_stream = sys.stdout
        err_stream = sys.stderr

        result._original_stdout = StringIO()
        result._original_stderr = StringIO()

        print &#039;foo&#039;
        print &gt;&gt; sys.stderr, &#039;bar&#039;

        self.assertEqual(out_stream.getvalue(), &#039;foo\n&#039;)
        self.assertEqual(err_stream.getvalue(), &#039;bar\n&#039;)

        self.assertEqual(result._original_stdout.getvalue(), &#039;&#039;)
        self.assertEqual(result._original_stderr.getvalue(), &#039;&#039;)

        result.addSuccess(self)
        result.stopTest(self)

        self.assertIs(sys.stdout, result._original_stdout)
        self.assertIs(sys.stderr, result._original_stderr)

        self.assertEqual(result._original_stdout.getvalue(), &#039;&#039;)
        self.assertEqual(result._original_stderr.getvalue(), &#039;&#039;)

        self.assertEqual(out_stream.getvalue(), &#039;&#039;)
        self.assertEqual(err_stream.getvalue(), &#039;&#039;)


    def getStartedResult(self):
        result = unittest.TestResult()
        result.buffer = True
        result.startTest(self)
        return result

    def testBufferOutputAddErrorOrFailure(self):
        unittest.result.traceback = MockTraceback
        self.addCleanup(restore_traceback)

        for message_attr, add_attr, include_error in [
            (&#039;errors&#039;, &#039;addError&#039;, True),
            (&#039;failures&#039;, &#039;addFailure&#039;, False),
            (&#039;errors&#039;, &#039;addError&#039;, True),
            (&#039;failures&#039;, &#039;addFailure&#039;, False)
        ]:
            result = self.getStartedResult()
            buffered_out = sys.stdout
            buffered_err = sys.stderr
            result._original_stdout = StringIO()
            result._original_stderr = StringIO()

            print &gt;&gt; sys.stdout, &#039;foo&#039;
            if include_error:
                print &gt;&gt; sys.stderr, &#039;bar&#039;


            addFunction = getattr(result, add_attr)
            addFunction(self, (None, None, None))
            result.stopTest(self)

            result_list = getattr(result, message_attr)
            self.assertEqual(len(result_list), 1)

            test, message = result_list[0]
            expectedOutMessage = textwrap.dedent(&quot;&quot;&quot;
                Stdout:
                foo
            &quot;&quot;&quot;)
            expectedErrMessage = &#039;&#039;
            if include_error:
                expectedErrMessage = textwrap.dedent(&quot;&quot;&quot;
                Stderr:
                bar
            &quot;&quot;&quot;)
            expectedFullMessage = &#039;A traceback%s%s&#039; % (expectedOutMessage, expectedErrMessage)

            self.assertIs(test, self)
            self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage)
            self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage)
            self.assertMultiLineEqual(message, expectedFullMessage)

    def testBufferSetupClass(self):
        result = unittest.TestResult()
        result.buffer = True

        class Foo(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                1//0
            def test_foo(self):
                pass
        suite = unittest.TestSuite([Foo(&#039;test_foo&#039;)])
        suite(result)
        self.assertEqual(len(result.errors), 1)

    def testBufferTearDownClass(self):
        result = unittest.TestResult()
        result.buffer = True

        class Foo(unittest.TestCase):
            @classmethod
            def tearDownClass(cls):
                1//0
            def test_foo(self):
                pass
        suite = unittest.TestSuite([Foo(&#039;test_foo&#039;)])
        suite(result)
        self.assertEqual(len(result.errors), 1)

    def testBufferSetUpModule(self):
        result = unittest.TestResult()
        result.buffer = True

        class Foo(unittest.TestCase):
            def test_foo(self):
                pass
        class Module(object):
            @staticmethod
            def setUpModule():
                1//0

        Foo.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module
        self.addCleanup(sys.modules.pop, &#039;Module&#039;)
        suite = unittest.TestSuite([Foo(&#039;test_foo&#039;)])
        suite(result)
        self.assertEqual(len(result.errors), 1)

    def testBufferTearDownModule(self):
        result = unittest.TestResult()
        result.buffer = True

        class Foo(unittest.TestCase):
            def test_foo(self):
                pass
        class Module(object):
            @staticmethod
            def tearDownModule():
                1//0

        Foo.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module
        self.addCleanup(sys.modules.pop, &#039;Module&#039;)
        suite = unittest.TestSuite([Foo(&#039;test_foo&#039;)])
        suite(result)
        self.assertEqual(len(result.errors), 1)


if __name__ == &#039;__main__&#039;:
    unittest.main()
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python2.7/unittest/test/test_result.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>