Zy Filemanager

📁 File Browser

Name	Size	Permissions	Actions
📄 __init__.py (514 bytes)	514 B	0644	✍️ ⬇️ 🗑️
📄 __init__.pyc (932 bytes)	932 B	0644	✍️ ⬇️ 🗑️
📄 __init__.pyo (932 bytes)	932 B	0644	✍️ ⬇️ 🗑️
📄 dummy.py (50 bytes)	50 B	0644	✍️ ⬇️ 🗑️
📄 dummy.pyc (143 bytes)	143 B	0644	✍️ ⬇️ 🗑️
📄 dummy.pyo (143 bytes)	143 B	0644	✍️ ⬇️ 🗑️
📄 support.py (3,471 bytes)	3.39 KB	0644	✍️ ⬇️ 🗑️
📄 support.pyc (6,342 bytes)	6.19 KB	0644	✍️ ⬇️ 🗑️
📄 support.pyo (6,342 bytes)	6.19 KB	0644	✍️ ⬇️ 🗑️
📄 test_assertions.py (11,961 bytes)	11.68 KB	0644	✍️ ⬇️ 🗑️
📄 test_assertions.pyc (13,967 bytes)	13.64 KB	0644	✍️ ⬇️ 🗑️
📄 test_assertions.pyo (13,967 bytes)	13.64 KB	0644	✍️ ⬇️ 🗑️
📄 test_break.py (9,641 bytes)	9.42 KB	0644	✍️ ⬇️ 🗑️
📄 test_break.pyc (10,520 bytes)	10.27 KB	0644	✍️ ⬇️ 🗑️
📄 test_break.pyo (10,520 bytes)	10.27 KB	0644	✍️ ⬇️ 🗑️
📄 test_case.py (45,719 bytes)	44.65 KB	0644	✍️ ⬇️ 🗑️
📄 test_case.pyc (49,154 bytes)	48 KB	0644	✍️ ⬇️ 🗑️
📄 test_case.pyo (49,154 bytes)	48 KB	0644	✍️ ⬇️ 🗑️
📄 test_discovery.py (14,313 bytes)	13.98 KB	0644	✍️ ⬇️ 🗑️
📄 test_discovery.pyc (18,447 bytes)	18.01 KB	0644	✍️ ⬇️ 🗑️
📄 test_discovery.pyo (18,447 bytes)	18.01 KB	0644	✍️ ⬇️ 🗑️
📄 test_functiontestcase.py (5,547 bytes)	5.42 KB	0644	✍️ ⬇️ 🗑️
📄 test_functiontestcase.pyc (6,425 bytes)	6.27 KB	0644	✍️ ⬇️ 🗑️
📄 test_functiontestcase.pyo (6,425 bytes)	6.27 KB	0644	✍️ ⬇️ 🗑️
📄 test_loader.py (49,866 bytes)	48.7 KB	0644	✍️ ⬇️ 🗑️
📄 test_loader.pyc (52,537 bytes)	51.31 KB	0644	✍️ ⬇️ 🗑️
📄 test_loader.pyo (52,537 bytes)	51.31 KB	0644	✍️ ⬇️ 🗑️
📄 test_program.py (7,576 bytes)	7.4 KB	0644	✍️ ⬇️ 🗑️
📄 test_program.pyc (10,941 bytes)	10.68 KB	0644	✍️ ⬇️ 🗑️
📄 test_program.pyo (10,883 bytes)	10.63 KB	0644	✍️ ⬇️ 🗑️
📄 test_result.py (19,056 bytes)	18.61 KB	0644	✍️ ⬇️ 🗑️
📄 test_result.pyc (22,413 bytes)	21.89 KB	0644	✍️ ⬇️ 🗑️
📄 test_result.pyo (22,413 bytes)	21.89 KB	0644	✍️ ⬇️ 🗑️
📄 test_runner.py (8,609 bytes)	8.41 KB	0644	✍️ ⬇️ 🗑️
📄 test_runner.pyc (14,905 bytes)	14.56 KB	0644	✍️ ⬇️ 🗑️
📄 test_runner.pyo (14,905 bytes)	14.56 KB	0644	✍️ ⬇️ 🗑️
📄 test_setups.py (16,460 bytes)	16.07 KB	0644	✍️ ⬇️ 🗑️
📄 test_setups.pyc (30,941 bytes)	30.22 KB	0644	✍️ ⬇️ 🗑️
📄 test_setups.pyo (30,941 bytes)	30.22 KB	0644	✍️ ⬇️ 🗑️
📄 test_skipping.py (5,744 bytes)	5.61 KB	0644	✍️ ⬇️ 🗑️
📄 test_skipping.pyc (10,108 bytes)	9.87 KB	0644	✍️ ⬇️ 🗑️
📄 test_skipping.pyo (10,108 bytes)	9.87 KB	0644	✍️ ⬇️ 🗑️
📄 test_suite.py (12,082 bytes)	11.8 KB	0644	✍️ ⬇️ 🗑️
📄 test_suite.pyc (16,438 bytes)	16.05 KB	0644	✍️ ⬇️ 🗑️
📄 test_suite.pyo (16,438 bytes)	16.05 KB	0644	✍️ ⬇️ 🗑️

✍️ Editing: test_result.py

            File: /opt/alt/python27/lib64/python2.7/unittest/test/test_result.py

            Size: 18.61 KB | 
            Last Modified: 2025-01-08 17:43:39        

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)

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

result.stop()

self.assertEqual(result.shouldStop, True)

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

test = Foo('test_1')

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)

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

test = Foo('test_1')

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)

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

# "addSuccess(test)"
    # ...
    # "Called when the test case test succeeds"
    # ...
    # "wasSuccessful() - Returns True if all tests run so far have passed,
    # otherwise returns False"
    # ...
    # "testsRun - The total number of tests run so far."
    # ...
    # "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."
    # ...
    # "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."
    def test_addSuccess(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

test = Foo('test_1')

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)

# "addFailure(test, err)"
    # ...
    # "Called when the test case test signals a failure. err is a tuple of
    # the form returned by sys.exc_info(): (type, value, traceback)"
    # ...
    # "wasSuccessful() - Returns True if all tests run so far have passed,
    # otherwise returns False"
    # ...
    # "testsRun - The total number of tests run so far."
    # ...
    # "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."
    # ...
    # "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."
    def test_addFailure(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

test = Foo('test_1')
        try:
            test.fail("foo")
        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)

# "addError(test, err)"
    # ...
    # "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)"
    # ...
    # "wasSuccessful() - Returns True if all tests run so far have passed,
    # otherwise returns False"
    # ...
    # "testsRun - The total number of tests run so far."
    # ...
    # "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."
    # ...
    # "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."
    def test_addError(self):
        class Foo(unittest.TestCase):
            def test_1(self):
                pass

test = Foo('test_1')
        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),
                'testGetDescriptionWithoutDocstring (' + __name__ +
                '.Test_TestResult)')

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

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

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['__unittest'] = True
        self.assertTrue(result._is_relevant_tb_level(Frame))

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

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

result = unittest.TestResult()
        result._exc_info_to_string = lambda *_: ''
        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 ('addSkip', 'addExpectedFailure', 'addUnexpectedSuccess',
           '__init__'):
    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['__init__'] = __init__
OldResult = type('OldResult', (object,), classDict)

class Test_OldTestResult(unittest.TestCase):

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

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

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

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

def testOldTestResultClass(self):
        @unittest.skip('no reason')
        class Test(unittest.TestCase):
            def testFoo(self):
                pass
        self.assertOldResultWarning(Test('testFoo'), 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't handle old
        # test result objects
        runner.run(Test('testFoo'))

class MockTraceback(object):
    @staticmethod
    def format_exception(*_):
        return ['A traceback']

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 'foo'
        print >> sys.stderr, 'bar'

self.assertEqual(out_stream.getvalue(), 'foo\n')
        self.assertEqual(err_stream.getvalue(), 'bar\n')

self.assertEqual(result._original_stdout.getvalue(), '')
        self.assertEqual(result._original_stderr.getvalue(), '')

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(), '')
        self.assertEqual(result._original_stderr.getvalue(), '')

self.assertEqual(out_stream.getvalue(), '')
        self.assertEqual(err_stream.getvalue(), '')

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 [
            ('errors', 'addError', True),
            ('failures', 'addFailure', False),
            ('errors', 'addError', True),
            ('failures', 'addFailure', False)
        ]:
            result = self.getStartedResult()
            buffered_out = sys.stdout
            buffered_err = sys.stderr
            result._original_stdout = StringIO()
            result._original_stderr = StringIO()

print >> sys.stdout, 'foo'
            if include_error:
                print >> sys.stderr, 'bar'

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("""
                Stdout:
                foo
            """)
            expectedErrMessage = ''
            if include_error:
                expectedErrMessage = textwrap.dedent("""
                Stderr:
                bar
            """)
            expectedFullMessage = 'A traceback%s%s' % (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('test_foo')])
        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('test_foo')])
        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__ = 'Module'
        sys.modules['Module'] = Module
        self.addCleanup(sys.modules.pop, 'Module')
        suite = unittest.TestSuite([Foo('test_foo')])
        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

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

↩️ Back

Zy Filemanager

📁 File Browser

📤 Upload Files

Single File

Multiple Files

ZIP Extract

➕ Create New

New Folder

New File

✍️ Editing: test_result.py

Backup Management