[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / unittest / test / test_runner.py

import unittest\r
\r
from cStringIO import StringIO\r
import pickle\r
\r
from .support import LoggingResult, ResultWithNoStartTestRunStopTestRun\r
\r
\r
class TestCleanUp(unittest.TestCase):\r
\r
    def testCleanUp(self):\r
        class TestableTest(unittest.TestCase):\r
            def testNothing(self):\r
                pass\r
\r
        test = TestableTest('testNothing')\r
        self.assertEqual(test._cleanups, [])\r
\r
        cleanups = []\r
\r
        def cleanup1(*args, **kwargs):\r
            cleanups.append((1, args, kwargs))\r
\r
        def cleanup2(*args, **kwargs):\r
            cleanups.append((2, args, kwargs))\r
\r
        test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye')\r
        test.addCleanup(cleanup2)\r
\r
        self.assertEqual(test._cleanups,\r
                         [(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')),\r
                          (cleanup2, (), {})])\r
\r
        result = test.doCleanups()\r
        self.assertTrue(result)\r
\r
        self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3),\r
                                    dict(four='hello', five='goodbye'))])\r
\r
    def testCleanUpWithErrors(self):\r
        class TestableTest(unittest.TestCase):\r
            def testNothing(self):\r
                pass\r
\r
        class MockResult(object):\r
            errors = []\r
            def addError(self, test, exc_info):\r
                self.errors.append((test, exc_info))\r
\r
        result = MockResult()\r
        test = TestableTest('testNothing')\r
        test._resultForDoCleanups = result\r
\r
        exc1 = Exception('foo')\r
        exc2 = Exception('bar')\r
        def cleanup1():\r
            raise exc1\r
\r
        def cleanup2():\r
            raise exc2\r
\r
        test.addCleanup(cleanup1)\r
        test.addCleanup(cleanup2)\r
\r
        self.assertFalse(test.doCleanups())\r
\r
        (test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors)\r
        self.assertEqual((test1, Type1, instance1), (test, Exception, exc1))\r
        self.assertEqual((test2, Type2, instance2), (test, Exception, exc2))\r
\r
    def testCleanupInRun(self):\r
        blowUp = False\r
        ordering = []\r
\r
        class TestableTest(unittest.TestCase):\r
            def setUp(self):\r
                ordering.append('setUp')\r
                if blowUp:\r
                    raise Exception('foo')\r
\r
            def testNothing(self):\r
                ordering.append('test')\r
\r
            def tearDown(self):\r
                ordering.append('tearDown')\r
\r
        test = TestableTest('testNothing')\r
\r
        def cleanup1():\r
            ordering.append('cleanup1')\r
        def cleanup2():\r
            ordering.append('cleanup2')\r
        test.addCleanup(cleanup1)\r
        test.addCleanup(cleanup2)\r
\r
        def success(some_test):\r
            self.assertEqual(some_test, test)\r
            ordering.append('success')\r
\r
        result = unittest.TestResult()\r
        result.addSuccess = success\r
\r
        test.run(result)\r
        self.assertEqual(ordering, ['setUp', 'test', 'tearDown',\r
                                    'cleanup2', 'cleanup1', 'success'])\r
\r
        blowUp = True\r
        ordering = []\r
        test = TestableTest('testNothing')\r
        test.addCleanup(cleanup1)\r
        test.run(result)\r
        self.assertEqual(ordering, ['setUp', 'cleanup1'])\r
\r
    def testTestCaseDebugExecutesCleanups(self):\r
        ordering = []\r
\r
        class TestableTest(unittest.TestCase):\r
            def setUp(self):\r
                ordering.append('setUp')\r
                self.addCleanup(cleanup1)\r
\r
            def testNothing(self):\r
                ordering.append('test')\r
\r
            def tearDown(self):\r
                ordering.append('tearDown')\r
\r
        test = TestableTest('testNothing')\r
\r
        def cleanup1():\r
            ordering.append('cleanup1')\r
            test.addCleanup(cleanup2)\r
        def cleanup2():\r
            ordering.append('cleanup2')\r
\r
        test.debug()\r
        self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2'])\r
\r
\r
class Test_TextTestRunner(unittest.TestCase):\r
    """Tests for TextTestRunner."""\r
\r
    def test_init(self):\r
        runner = unittest.TextTestRunner()\r
        self.assertFalse(runner.failfast)\r
        self.assertFalse(runner.buffer)\r
        self.assertEqual(runner.verbosity, 1)\r
        self.assertTrue(runner.descriptions)\r
        self.assertEqual(runner.resultclass, unittest.TextTestResult)\r
\r
\r
    def testBufferAndFailfast(self):\r
        class Test(unittest.TestCase):\r
            def testFoo(self):\r
                pass\r
        result = unittest.TestResult()\r
        runner = unittest.TextTestRunner(stream=StringIO(), failfast=True,\r
                                           buffer=True)\r
        # Use our result object\r
        runner._makeResult = lambda: result\r
        runner.run(Test('testFoo'))\r
\r
        self.assertTrue(result.failfast)\r
        self.assertTrue(result.buffer)\r
\r
    def testRunnerRegistersResult(self):\r
        class Test(unittest.TestCase):\r
            def testFoo(self):\r
                pass\r
        originalRegisterResult = unittest.runner.registerResult\r
        def cleanup():\r
            unittest.runner.registerResult = originalRegisterResult\r
        self.addCleanup(cleanup)\r
\r
        result = unittest.TestResult()\r
        runner = unittest.TextTestRunner(stream=StringIO())\r
        # Use our result object\r
        runner._makeResult = lambda: result\r
\r
        self.wasRegistered = 0\r
        def fakeRegisterResult(thisResult):\r
            self.wasRegistered += 1\r
            self.assertEqual(thisResult, result)\r
        unittest.runner.registerResult = fakeRegisterResult\r
\r
        runner.run(unittest.TestSuite())\r
        self.assertEqual(self.wasRegistered, 1)\r
\r
    def test_works_with_result_without_startTestRun_stopTestRun(self):\r
        class OldTextResult(ResultWithNoStartTestRunStopTestRun):\r
            separator2 = ''\r
            def printErrors(self):\r
                pass\r
\r
        class Runner(unittest.TextTestRunner):\r
            def __init__(self):\r
                super(Runner, self).__init__(StringIO())\r
\r
            def _makeResult(self):\r
                return OldTextResult()\r
\r
        runner = Runner()\r
        runner.run(unittest.TestSuite())\r
\r
    def test_startTestRun_stopTestRun_called(self):\r
        class LoggingTextResult(LoggingResult):\r
            separator2 = ''\r
            def printErrors(self):\r
                pass\r
\r
        class LoggingRunner(unittest.TextTestRunner):\r
            def __init__(self, events):\r
                super(LoggingRunner, self).__init__(StringIO())\r
                self._events = events\r
\r
            def _makeResult(self):\r
                return LoggingTextResult(self._events)\r
\r
        events = []\r
        runner = LoggingRunner(events)\r
        runner.run(unittest.TestSuite())\r
        expected = ['startTestRun', 'stopTestRun']\r
        self.assertEqual(events, expected)\r
\r
    def test_pickle_unpickle(self):\r
        # Issue #7197: a TextTestRunner should be (un)pickleable. This is\r
        # required by test_multiprocessing under Windows (in verbose mode).\r
        from StringIO import StringIO as PickleableIO\r
        # cStringIO objects are not pickleable, but StringIO objects are.\r
        stream = PickleableIO("foo")\r
        runner = unittest.TextTestRunner(stream)\r
        for protocol in range(pickle.HIGHEST_PROTOCOL + 1):\r
            s = pickle.dumps(runner, protocol=protocol)\r
            obj = pickle.loads(s)\r
            # StringIO objects never compare equal, a cheap test instead.\r
            self.assertEqual(obj.stream.getvalue(), stream.getvalue())\r
\r
    def test_resultclass(self):\r
        def MockResultClass(*args):\r
            return args\r
        STREAM = object()\r
        DESCRIPTIONS = object()\r
        VERBOSITY = object()\r
        runner = unittest.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY,\r
                                         resultclass=MockResultClass)\r
        self.assertEqual(runner.resultclass, MockResultClass)\r
\r
        expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)\r
        self.assertEqual(runner._makeResult(), expectedresult)\r
\r
\r
if __name__ == '__main__':\r
    unittest.main()\r
Commit	Line	Data
4710c53d	1	import unittest\r
	2	\r
	3	from cStringIO import StringIO\r
	4	import pickle\r
	5	\r
	6	from .support import LoggingResult, ResultWithNoStartTestRunStopTestRun\r
	7	\r
	8	\r
	9	class TestCleanUp(unittest.TestCase):\r
	10	\r
	11	def testCleanUp(self):\r
	12	class TestableTest(unittest.TestCase):\r
	13	def testNothing(self):\r
	14	pass\r
	15	\r
	16	test = TestableTest('testNothing')\r
	17	self.assertEqual(test._cleanups, [])\r
	18	\r
	19	cleanups = []\r
	20	\r
	21	def cleanup1(args, *kwargs):\r
	22	cleanups.append((1, args, kwargs))\r
	23	\r
	24	def cleanup2(args, *kwargs):\r
	25	cleanups.append((2, args, kwargs))\r
	26	\r
	27	test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye')\r
	28	test.addCleanup(cleanup2)\r
	29	\r
	30	self.assertEqual(test._cleanups,\r
	31	[(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')),\r
	32	(cleanup2, (), {})])\r
	33	\r
	34	result = test.doCleanups()\r
	35	self.assertTrue(result)\r
	36	\r
	37	self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3),\r
	38	dict(four='hello', five='goodbye'))])\r
	39	\r
	40	def testCleanUpWithErrors(self):\r
	41	class TestableTest(unittest.TestCase):\r
	42	def testNothing(self):\r
	43	pass\r
	44	\r
	45	class MockResult(object):\r
	46	errors = []\r
	47	def addError(self, test, exc_info):\r
	48	self.errors.append((test, exc_info))\r
	49	\r
	50	result = MockResult()\r
	51	test = TestableTest('testNothing')\r
	52	test._resultForDoCleanups = result\r
	53	\r
	54	exc1 = Exception('foo')\r
	55	exc2 = Exception('bar')\r
	56	def cleanup1():\r
	57	raise exc1\r
	58	\r
	59	def cleanup2():\r
	60	raise exc2\r
	61	\r
	62	test.addCleanup(cleanup1)\r
	63	test.addCleanup(cleanup2)\r
	64	\r
65	self.assertFalse(test.doCleanups())\r
66	\r
67	(test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors)\r
68	self.assertEqual((test1, Type1, instance1), (test, Exception, exc1))\r
69	self.assertEqual((test2, Type2, instance2), (test, Exception, exc2))\r
70	\r
71	def testCleanupInRun(self):\r
72	blowUp = False\r
73	ordering = []\r
74	\r
75	class TestableTest(unittest.TestCase):\r
76	def setUp(self):\r
77	ordering.append('setUp')\r
78	if blowUp:\r
79	raise Exception('foo')\r
80	\r
81	def testNothing(self):\r
82	ordering.append('test')\r
83	\r
84	def tearDown(self):\r
85	ordering.append('tearDown')\r
86	\r
87	test = TestableTest('testNothing')\r
88	\r
89	def cleanup1():\r
90	ordering.append('cleanup1')\r
91	def cleanup2():\r
92	ordering.append('cleanup2')\r
93	test.addCleanup(cleanup1)\r
94	test.addCleanup(cleanup2)\r
95	\r
96	def success(some_test):\r
97	self.assertEqual(some_test, test)\r
98	ordering.append('success')\r
99	\r
100	result = unittest.TestResult()\r
101	result.addSuccess = success\r
102	\r
103	test.run(result)\r
104	self.assertEqual(ordering, ['setUp', 'test', 'tearDown',\r
105	'cleanup2', 'cleanup1', 'success'])\r
106	\r
107	blowUp = True\r
108	ordering = []\r
109	test = TestableTest('testNothing')\r
110	test.addCleanup(cleanup1)\r
111	test.run(result)\r
112	self.assertEqual(ordering, ['setUp', 'cleanup1'])\r
113	\r
114	def testTestCaseDebugExecutesCleanups(self):\r
115	ordering = []\r
116	\r
117	class TestableTest(unittest.TestCase):\r
118	def setUp(self):\r
119	ordering.append('setUp')\r
120	self.addCleanup(cleanup1)\r
121	\r
122	def testNothing(self):\r
123	ordering.append('test')\r
124	\r
125	def tearDown(self):\r
126	ordering.append('tearDown')\r
127	\r
128	test = TestableTest('testNothing')\r
129	\r
130	def cleanup1():\r
131	ordering.append('cleanup1')\r
132	test.addCleanup(cleanup2)\r
133	def cleanup2():\r
134	ordering.append('cleanup2')\r
135	\r
136	test.debug()\r
137	self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2'])\r
138	\r
139	\r
140	class Test_TextTestRunner(unittest.TestCase):\r
141	"""Tests for TextTestRunner."""\r
142	\r
143	def test_init(self):\r
144	runner = unittest.TextTestRunner()\r
145	self.assertFalse(runner.failfast)\r
146	self.assertFalse(runner.buffer)\r
147	self.assertEqual(runner.verbosity, 1)\r
148	self.assertTrue(runner.descriptions)\r
149	self.assertEqual(runner.resultclass, unittest.TextTestResult)\r
150	\r
151	\r
152	def testBufferAndFailfast(self):\r
153	class Test(unittest.TestCase):\r
154	def testFoo(self):\r
155	pass\r
156	result = unittest.TestResult()\r
157	runner = unittest.TextTestRunner(stream=StringIO(), failfast=True,\r
158	buffer=True)\r
159	# Use our result object\r
160	runner._makeResult = lambda: result\r
161	runner.run(Test('testFoo'))\r
162	\r
163	self.assertTrue(result.failfast)\r
164	self.assertTrue(result.buffer)\r
165	\r
166	def testRunnerRegistersResult(self):\r
167	class Test(unittest.TestCase):\r
168	def testFoo(self):\r
169	pass\r
170	originalRegisterResult = unittest.runner.registerResult\r
171	def cleanup():\r
172	unittest.runner.registerResult = originalRegisterResult\r
173	self.addCleanup(cleanup)\r
174	\r
175	result = unittest.TestResult()\r
176	runner = unittest.TextTestRunner(stream=StringIO())\r
177	# Use our result object\r
178	runner._makeResult = lambda: result\r
179	\r
180	self.wasRegistered = 0\r
181	def fakeRegisterResult(thisResult):\r
182	self.wasRegistered += 1\r
183	self.assertEqual(thisResult, result)\r
184	unittest.runner.registerResult = fakeRegisterResult\r
185	\r
186	runner.run(unittest.TestSuite())\r
187	self.assertEqual(self.wasRegistered, 1)\r
188	\r
189	def test_works_with_result_without_startTestRun_stopTestRun(self):\r
190	class OldTextResult(ResultWithNoStartTestRunStopTestRun):\r
191	separator2 = ''\r
192	def printErrors(self):\r
193	pass\r
194	\r
195	class Runner(unittest.TextTestRunner):\r
196	def __init__(self):\r
197	super(Runner, self).__init__(StringIO())\r
198	\r
199	def _makeResult(self):\r
200	return OldTextResult()\r
201	\r
202	runner = Runner()\r
203	runner.run(unittest.TestSuite())\r
204	\r
205	def test_startTestRun_stopTestRun_called(self):\r
206	class LoggingTextResult(LoggingResult):\r
207	separator2 = ''\r
208	def printErrors(self):\r
209	pass\r
210	\r
211	class LoggingRunner(unittest.TextTestRunner):\r
212	def __init__(self, events):\r
213	super(LoggingRunner, self).__init__(StringIO())\r
214	self._events = events\r
215	\r
216	def _makeResult(self):\r
217	return LoggingTextResult(self._events)\r
218	\r
219	events = []\r
220	runner = LoggingRunner(events)\r
221	runner.run(unittest.TestSuite())\r
222	expected = ['startTestRun', 'stopTestRun']\r
223	self.assertEqual(events, expected)\r
224	\r
225	def test_pickle_unpickle(self):\r
226	# Issue #7197: a TextTestRunner should be (un)pickleable. This is\r
227	# required by test_multiprocessing under Windows (in verbose mode).\r
228	from StringIO import StringIO as PickleableIO\r
229	# cStringIO objects are not pickleable, but StringIO objects are.\r
230	stream = PickleableIO("foo")\r
231	runner = unittest.TextTestRunner(stream)\r
232	for protocol in range(pickle.HIGHEST_PROTOCOL + 1):\r
233	s = pickle.dumps(runner, protocol=protocol)\r
234	obj = pickle.loads(s)\r
235	# StringIO objects never compare equal, a cheap test instead.\r
236	self.assertEqual(obj.stream.getvalue(), stream.getvalue())\r
237	\r
238	def test_resultclass(self):\r
239	def MockResultClass(*args):\r
240	return args\r
241	STREAM = object()\r
242	DESCRIPTIONS = object()\r
243	VERBOSITY = object()\r
244	runner = unittest.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY,\r
245	resultclass=MockResultClass)\r
246	self.assertEqual(runner.resultclass, MockResultClass)\r
247	\r
248	expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)\r
249	self.assertEqual(runner._makeResult(), expectedresult)\r
250	\r
251	\r
252	if __name__ == '__main__':\r
253	unittest.main()\r