diff options
| author | Kate Stone <katherine.stone@apple.com> | 2016-09-06 20:57:50 +0000 |
|---|---|---|
| committer | Kate Stone <katherine.stone@apple.com> | 2016-09-06 20:57:50 +0000 |
| commit | b9c1b51e45b845debb76d8658edabca70ca56079 (patch) | |
| tree | dfcb5a13ef2b014202340f47036da383eaee74aa /lldb/third_party/Python/module/unittest2/unittest2/test | |
| parent | d5aa73376966339caad04013510626ec2e42c760 (diff) | |
| download | bcm5719-llvm-b9c1b51e45b845debb76d8658edabca70ca56079.tar.gz bcm5719-llvm-b9c1b51e45b845debb76d8658edabca70ca56079.zip | |
*** This commit represents a complete reformatting of the LLDB source code
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
Diffstat (limited to 'lldb/third_party/Python/module/unittest2/unittest2/test')
16 files changed, 915 insertions, 413 deletions
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py b/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py index 4287ca86179..792d6005489 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py @@ -1 +1 @@ -#
\ No newline at end of file +# diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/support.py b/lldb/third_party/Python/module/unittest2/unittest2/test/support.py index eec6eec7790..5c9bcf27496 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/support.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/support.py @@ -7,6 +7,7 @@ import unittest2 def resultFactory(*_): return unittest2.TestResult() + class OldTestResult(object): """An object honouring TestResult before startTestRun/stopTestRun.""" @@ -37,7 +38,9 @@ class OldTestResult(object): def printErrors(self): pass + class LoggingResult(unittest2.TestResult): + def __init__(self, log): self._events = log super(LoggingResult, self).__init__() @@ -98,6 +101,7 @@ class EqualityMixin(object): self.assertNotEqual(obj_1, obj_2) self.assertNotEqual(obj_2, obj_1) + class HashingMixin(object): """Used as a mixin for TestCase""" @@ -123,24 +127,24 @@ class HashingMixin(object): self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e)) - # copied from Python 2.6 try: from warnings import catch_warnings except ImportError: class catch_warnings(object): + def __init__(self, record=False, module=None): self._record = record self._module = sys.modules['warnings'] self._entered = False - + def __repr__(self): args = [] if self._record: args.append("record=True") name = type(self).__name__ return "%s(%s)" % (name, ", ".join(args)) - + def __enter__(self): if self._entered: raise RuntimeError("Cannot enter %r twice" % self) @@ -150,28 +154,36 @@ except ImportError: self._showwarning = self._module.showwarning if self._record: log = [] + def showwarning(*args, **kwargs): log.append(WarningMessage(*args, **kwargs)) self._module.showwarning = showwarning return log else: return None - + def __exit__(self, *exc_info): if not self._entered: - raise RuntimeError("Cannot exit %r without entering first" % self) + raise RuntimeError( + "Cannot exit %r without entering first" % + self) self._module.filters = self._filters self._module.showwarning = self._showwarning class WarningMessage(object): - _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file", - "line") + _WARNING_DETAILS = ( + "message", + "category", + "filename", + "lineno", + "file", + "line") + def __init__(self, message, category, filename, lineno, file=None, - line=None): + line=None): local_values = locals() for attr in self._WARNING_DETAILS: setattr(self, attr, local_values[attr]) self._category_name = None if category.__name__: self._category_name = category.__name__ - diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py index d71326b218a..c96aaafa082 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py @@ -4,6 +4,7 @@ import unittest2 class Test_Assertions(unittest2.TestCase): + def test_AlmostEqual(self): self.assertAlmostEqual(1.00000001, 1.0) self.assertNotAlmostEqual(1.0000001, 1.0) @@ -16,12 +17,12 @@ class Test_Assertions(unittest2.TestCase): self.assertRaises(self.failureException, self.assertAlmostEqual, 1.1, 1.0, places=1) - self.assertAlmostEqual(0, .1+.1j, places=0) - self.assertNotAlmostEqual(0, .1+.1j, places=1) + self.assertAlmostEqual(0, .1 + .1j, places=0) + self.assertNotAlmostEqual(0, .1 + .1j, places=1) self.assertRaises(self.failureException, - self.assertAlmostEqual, 0, .1+.1j, places=1) + self.assertAlmostEqual, 0, .1 + .1j, places=1) self.assertRaises(self.failureException, - self.assertNotAlmostEqual, 0, .1+.1j, places=0) + self.assertNotAlmostEqual, 0, .1 + .1j, places=0) try: self.assertAlmostEqual(float('inf'), float('inf')) @@ -33,24 +34,23 @@ class Test_Assertions(unittest2.TestCase): self.assertAlmostEqual(x, x) self.assertRaises(self.failureException, self.assertNotAlmostEqual, x, x) - - + def test_AmostEqualWithDelta(self): self.assertAlmostEqual(1.1, 1.0, delta=0.5) self.assertAlmostEqual(1.0, 1.1, delta=0.5) self.assertNotAlmostEqual(1.1, 1.0, delta=0.05) self.assertNotAlmostEqual(1.0, 1.1, delta=0.05) - + self.assertRaises(self.failureException, self.assertAlmostEqual, 1.1, 1.0, delta=0.05) self.assertRaises(self.failureException, self.assertNotAlmostEqual, 1.1, 1.0, delta=0.5) - + self.assertRaises(TypeError, self.assertAlmostEqual, 1.1, 1.0, places=2, delta=2) self.assertRaises(TypeError, self.assertNotAlmostEqual, 1.1, 1.0, places=2, delta=2) - + first = datetime.datetime.now() second = first + datetime.timedelta(seconds=10) self.assertAlmostEqual(first, second, @@ -96,18 +96,24 @@ class TestLongMessage(unittest2.TestCase): self.assertTrue(unittest2.TestCase.longMessage) def test_formatMsg(self): - self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo") + self.assertEquals( + self.testableFalse._formatMessage( + None, "foo"), "foo") + self.assertEquals( + self.testableFalse._formatMessage( + "foo", "bar"), "foo") self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo") - + self.assertEquals( + self.testableTrue._formatMessage( + "foo", "bar"), "bar : foo") + # This blows up if _formatMessage uses string concatenation self.testableTrue._formatMessage(object(), 'foo') def assertMessages(self, methodName, args, errors): def getMethod(i): - useTestableFalse = i < 2 + useTestableFalse = i < 2 if useTestableFalse: test = self.testableFalse else: @@ -124,7 +130,7 @@ class TestLongMessage(unittest2.TestCase): self.assertRaisesRegexp(self.failureException, expected_regexp, lambda: testMethod(*args, **kwargs)) - + def testAssertTrue(self): self.assertMessages('assertTrue', (False,), ["^False is not True$", "^oops$", "^False is not True$", @@ -141,18 +147,27 @@ class TestLongMessage(unittest2.TestCase): "^1 == 1 : oops$"]) def testAlmostEqual(self): - self.assertMessages('assertAlmostEqual', (1, 2), - ["^1 != 2 within 7 places$", "^oops$", - "^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"]) + self.assertMessages('assertAlmostEqual', + (1, + 2), + ["^1 != 2 within 7 places$", + "^oops$", + "^1 != 2 within 7 places$", + "^1 != 2 within 7 places : oops$"]) def testNotAlmostEqual(self): - self.assertMessages('assertNotAlmostEqual', (1, 1), - ["^1 == 1 within 7 places$", "^oops$", - "^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"]) + self.assertMessages('assertNotAlmostEqual', + (1, + 1), + ["^1 == 1 within 7 places$", + "^oops$", + "^1 == 1 within 7 places$", + "^1 == 1 within 7 places : oops$"]) def test_baseAssertEqual(self): - self.assertMessages('_baseAssertEqual', (1, 2), - ["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"]) + self.assertMessages( + '_baseAssertEqual', (1, 2), [ + "^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"]) def testAssertSequenceEqual(self): # Error messages are multiline so not testing on full message diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py index 1f7864b7a41..390718da22c 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py @@ -13,33 +13,32 @@ import unittest2 class TestBreak(unittest2.TestCase): - + def setUp(self): self._default_handler = signal.getsignal(signal.SIGINT) - + def tearDown(self): signal.signal(signal.SIGINT, self._default_handler) unittest2.signals._results = weakref.WeakKeyDictionary() unittest2.signals._interrupt_handler = None - def testInstallHandler(self): default_handler = signal.getsignal(signal.SIGINT) unittest2.installHandler() self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) - + try: pid = os.getpid() os.kill(pid, signal.SIGINT) except KeyboardInterrupt: self.fail("KeyboardInterrupt not handled") - + self.assertTrue(unittest2.signals._interrupt_handler.called) - + def testRegisterResult(self): result = unittest2.TestResult() unittest2.registerResult(result) - + for ref in unittest2.signals._results: if ref is result: break @@ -47,35 +46,33 @@ class TestBreak(unittest2.TestCase): self.fail("odd object in result set") else: self.fail("result not found") - - + def testInterruptCaught(self): default_handler = signal.getsignal(signal.SIGINT) - + result = unittest2.TestResult() unittest2.installHandler() unittest2.registerResult(result) - + self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) - + def test(result): pid = os.getpid() os.kill(pid, signal.SIGINT) result.breakCaught = True self.assertTrue(result.shouldStop) - + try: test(result) except KeyboardInterrupt: self.fail("KeyboardInterrupt not handled") self.assertTrue(result.breakCaught) - - + def testSecondInterrupt(self): result = unittest2.TestResult() unittest2.installHandler() unittest2.registerResult(result) - + def test(result): pid = os.getpid() os.kill(pid, signal.SIGINT) @@ -83,7 +80,7 @@ class TestBreak(unittest2.TestCase): self.assertTrue(result.shouldStop) os.kill(pid, signal.SIGINT) self.fail("Second KeyboardInterrupt not raised") - + try: test(result) except KeyboardInterrupt: @@ -92,45 +89,44 @@ class TestBreak(unittest2.TestCase): self.fail("Second KeyboardInterrupt not raised") self.assertTrue(result.breakCaught) - def testTwoResults(self): unittest2.installHandler() - + result = unittest2.TestResult() unittest2.registerResult(result) new_handler = signal.getsignal(signal.SIGINT) - + result2 = unittest2.TestResult() unittest2.registerResult(result2) self.assertEqual(signal.getsignal(signal.SIGINT), new_handler) - + result3 = unittest2.TestResult() - + def test(result): pid = os.getpid() os.kill(pid, signal.SIGINT) - + try: test(result) except KeyboardInterrupt: self.fail("KeyboardInterrupt not handled") - + self.assertTrue(result.shouldStop) self.assertTrue(result2.shouldStop) self.assertFalse(result3.shouldStop) - - + def testHandlerReplacedButCalled(self): # If our handler has been replaced (is no longer installed) but is # called by the *new* handler, then it isn't safe to delay the # SIGINT and we should immediately delegate to the default handler unittest2.installHandler() - + handler = signal.getsignal(signal.SIGINT) + def new_handler(frame, signum): handler(frame, signum) signal.signal(signal.SIGINT, new_handler) - + try: pid = os.getpid() os.kill(pid, signal.SIGINT) @@ -138,35 +134,35 @@ class TestBreak(unittest2.TestCase): pass else: self.fail("replaced but delegated handler doesn't raise interrupt") - + def testRunner(self): # Creating a TextTestRunner with the appropriate argument should # register the TextTestResult it creates runner = unittest2.TextTestRunner(stream=StringIO()) - + result = runner.run(unittest2.TestSuite()) self.assertIn(result, unittest2.signals._results) - + def testWeakReferences(self): # Calling registerResult on a result should not keep it alive result = unittest2.TestResult() unittest2.registerResult(result) - + ref = weakref.ref(result) del result - + # For non-reference counting implementations - gc.collect();gc.collect() + gc.collect() + gc.collect() self.assertIsNone(ref()) - - + def testRemoveResult(self): result = unittest2.TestResult() unittest2.registerResult(result) - + unittest2.installHandler() self.assertTrue(unittest2.removeResult(result)) - + # Should this raise an error instead? self.assertFalse(unittest2.removeResult(unittest2.TestResult())) @@ -175,9 +171,9 @@ class TestBreak(unittest2.TestCase): os.kill(pid, signal.SIGINT) except KeyboardInterrupt: pass - + self.assertFalse(result.shouldStop) - + def testMainInstallsHandler(self): failfast = object() test = object() @@ -188,14 +184,17 @@ class TestBreak(unittest2.TestCase): class FakeRunner(object): initArgs = [] runArgs = [] + def __init__(self, *args, **kwargs): self.initArgs.append((args, kwargs)) + def run(self, test): self.runArgs.append(test) return result - + class Program(unittest2.TestProgram): - def __init__(self, catchbreak): + + def __init__(self, catchbreak): self.exit = False self.verbosity = verbosity self.failfast = failfast @@ -203,31 +202,30 @@ class TestBreak(unittest2.TestCase): self.testRunner = FakeRunner self.test = test self.result = None - + p = Program(False) p.runTests() - - self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, - 'failfast': failfast, - 'buffer': None})]) + + self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, + 'failfast': failfast, + 'buffer': None})]) self.assertEqual(FakeRunner.runArgs, [test]) self.assertEqual(p.result, result) - + self.assertEqual(signal.getsignal(signal.SIGINT), default_handler) - + FakeRunner.initArgs = [] FakeRunner.runArgs = [] p = Program(True) p.runTests() - - self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, - 'failfast': failfast, - 'buffer': None})]) + + self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, + 'failfast': failfast, + 'buffer': None})]) self.assertEqual(FakeRunner.runArgs, [test]) self.assertEqual(p.result, result) - - self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) + self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) def testRemoveHandler(self): default_handler = signal.getsignal(signal.SIGINT) @@ -238,21 +236,21 @@ class TestBreak(unittest2.TestCase): # check that calling removeHandler multiple times has no ill-effect unittest2.removeHandler() self.assertEqual(signal.getsignal(signal.SIGINT), default_handler) - + def testRemoveHandlerAsDecorator(self): default_handler = signal.getsignal(signal.SIGINT) unittest2.installHandler() - + @unittest2.removeHandler def test(): self.assertEqual(signal.getsignal(signal.SIGINT), default_handler) - + test() self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) - + # Should also skip some tests on Jython -skipper = unittest2.skipUnless(hasattr(os, 'kill') and signal is not None, +skipper = unittest2.skipUnless(hasattr(os, 'kill') and signal is not None, "test uses os.kill(...) and the signal module") TestBreak = skipper(TestBreak) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py index 5f310ecb046..acf7e4edc57 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py @@ -20,10 +20,13 @@ class Test(object): "Keep these TestCase classes out of the main namespace" class Foo(unittest2.TestCase): + def runTest(self): pass + def test1(self): pass class Bar(Foo): + def test2(self): pass class LoggingTestCase(unittest2.TestCase): @@ -43,11 +46,11 @@ class Test(object): self.events.append('tearDown') - class TestCleanUp(unittest2.TestCase): def testCleanUp(self): class TestableTest(unittest2.TestCase): + def testNothing(self): pass @@ -65,22 +68,28 @@ class TestCleanUp(unittest2.TestCase): test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye') test.addCleanup(cleanup2) - self.assertEqual(test._cleanups, - [(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')), - (cleanup2, (), {})]) + self.assertEqual( + test._cleanups, [ + (cleanup1, (1, 2, 3), dict( + four='hello', five='goodbye')), (cleanup2, (), {})]) result = test.doCleanups() self.assertTrue(result) - self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3), dict(four='hello', five='goodbye'))]) + self.assertEqual( + cleanups, [ + (2, (), {}), (1, (1, 2, 3), dict( + four='hello', five='goodbye'))]) def testCleanUpWithErrors(self): class TestableTest(unittest2.TestCase): + def testNothing(self): pass class MockResult(object): errors = [] + def addError(self, test, exc_info): self.errors.append((test, exc_info)) @@ -90,6 +99,7 @@ class TestCleanUp(unittest2.TestCase): exc1 = Exception('foo') exc2 = Exception('bar') + def cleanup1(): raise exc1 @@ -101,7 +111,8 @@ class TestCleanUp(unittest2.TestCase): self.assertFalse(test.doCleanups()) - (test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors) + (test1, (Type1, instance1, _)), (test2, + (Type2, instance2, _)) = reversed(MockResult.errors) self.assertEqual((test1, Type1, instance1), (test, Exception, exc1)) self.assertEqual((test2, Type2, instance2), (test, Exception, exc2)) @@ -110,6 +121,7 @@ class TestCleanUp(unittest2.TestCase): ordering = [] class TestableTest(unittest2.TestCase): + def setUp(self): ordering.append('setUp') if blowUp: @@ -125,6 +137,7 @@ class TestCleanUp(unittest2.TestCase): def cleanup1(): ordering.append('cleanup1') + def cleanup2(): ordering.append('cleanup2') test.addCleanup(cleanup1) @@ -152,6 +165,7 @@ class TestCleanUp(unittest2.TestCase): ordering = [] class TestableTest(unittest2.TestCase): + def setUp(self): ordering.append('setUp') self.addCleanup(cleanup1) @@ -167,16 +181,19 @@ class TestCleanUp(unittest2.TestCase): def cleanup1(): ordering.append('cleanup1') test.addCleanup(cleanup2) + def cleanup2(): ordering.append('cleanup2') test.debug() - self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2']) + self.assertEqual( + ordering, [ + 'setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2']) class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): - ### Set up attributes used by inherited tests + # Set up attributes used by inherited tests ################################################################ # Used by HashingMixin.test_hash and EqualityMixin.test_eq @@ -188,8 +205,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): (Test.Foo('test1'), Test.Bar('test2'))] ################################################################ - ### /Set up attributes used by inherited tests - + # /Set up attributes used by inherited tests # "class TestCase([methodName])" # ... @@ -202,7 +218,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # thing. def test_init__no_test_name(self): class Test(unittest2.TestCase): + def runTest(self): raise MyException() + def test(self): pass self.assertEqual(Test().id()[-13:], '.Test.runTest') @@ -213,7 +231,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # method named methodName." def test_init__test_name__valid(self): class Test(unittest2.TestCase): + def runTest(self): raise MyException() + def test(self): pass self.assertEqual(Test('test').id()[-10:], '.Test.test') @@ -224,7 +244,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # method named methodName." def test_init__test_name__invalid(self): class Test(unittest2.TestCase): + def runTest(self): raise MyException() + def test(self): pass try: @@ -238,6 +260,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # TestCase instances, this will always be 1" def test_countTestCases(self): class Foo(unittest2.TestCase): + def test(self): pass self.assertEqual(Foo('test').countTestCases(), 1) @@ -248,6 +271,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # override this as necessary." def test_defaultTestResult(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -266,6 +290,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def setUp(self): super(Foo, self).setUp() raise RuntimeError('raised by Foo.setUp') @@ -279,6 +304,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): events = [] class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) @@ -303,6 +329,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def test(self): super(Foo, self).test() raise RuntimeError('raised by Foo.test') @@ -318,6 +345,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): events = [] class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) @@ -342,6 +370,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def test(self): super(Foo, self).test() self.fail('raised by Foo.test') @@ -355,8 +384,10 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def test_run_call_order__failure_in_test_default_result(self): class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) + def test(self): super(Foo, self).test() self.fail('raised by Foo.test') @@ -379,6 +410,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def tearDown(self): super(Foo, self).tearDown() raise RuntimeError('raised by Foo.tearDown') @@ -392,8 +424,10 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def test_run_call_order__error_in_tearDown_default_result(self): class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) + def tearDown(self): super(Foo, self).tearDown() raise RuntimeError('raised by Foo.tearDown') @@ -409,8 +443,10 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def test_run_call_order_default_result(self): class Foo(unittest2.TestCase): + def defaultTestResult(self): return OldTestResult() + def test(self): pass @@ -423,6 +459,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # attribute is AssertionError" def test_failureException__default(self): class Foo(unittest2.TestCase): + def test(self): pass @@ -439,6 +476,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(unittest2.TestCase): + def test(self): raise RuntimeError() @@ -446,7 +484,6 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertTrue(Foo('test').failureException is RuntimeError) - Foo('test').run(result) expected = ['startTest', 'addFailure', 'stopTest'] self.assertEqual(events, expected) @@ -462,6 +499,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(unittest2.TestCase): + def test(self): self.fail("foo") @@ -469,7 +507,6 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertTrue(Foo('test').failureException is RuntimeError) - Foo('test').run(result) expected = ['startTest', 'addFailure', 'stopTest'] self.assertEqual(events, expected) @@ -477,6 +514,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # "The default implementation does nothing." def test_setUp(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -486,6 +524,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # "The default implementation does nothing." def test_tearDown(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -500,6 +539,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # just say "string") def test_id(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -513,6 +553,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): events = [] class Foo(unittest2.TestCase): + def test(self): events.append('test') @@ -523,7 +564,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): Foo('test').run() expected = ['startTestRun', 'startTest', 'test', 'addSuccess', - 'stopTest', 'stopTestRun'] + 'stopTest', 'stopTestRun'] self.assertEqual(events, expected) def testShortDescriptionWithoutDocstring(self): @@ -532,8 +573,8 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def testShortDescriptionWithOneLineDocstring(self): """Tests shortDescription() for a method with a docstring.""" self.assertEqual( - self.shortDescription(), - 'Tests shortDescription() for a method with a docstring.') + self.shortDescription(), + 'Tests shortDescription() for a method with a docstring.') def testShortDescriptionWithMultiLineDocstring(self): """Tests shortDescription() for a method with a longer docstring. @@ -543,15 +584,16 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): whole thing is. """ self.assertEqual( - self.shortDescription(), - 'Tests shortDescription() for a method with a longer ' - 'docstring.') + self.shortDescription(), + 'Tests shortDescription() for a method with a longer ' + 'docstring.') def testAddTypeEqualityFunc(self): class SadSnake(object): """Dummy class for test_addTypeEqualityFunc.""" s1, s2 = SadSnake(), SadSnake() self.assertNotEqual(s1, s2) + def AllSnakesCreatedEqual(a, b, msg=None): return type(a) is type(b) is SadSnake self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual) @@ -563,12 +605,20 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def testAssertIs(self): thing = object() self.assertIs(thing, thing) - self.assertRaises(self.failureException, self.assertIs, thing, object()) + self.assertRaises( + self.failureException, + self.assertIs, + thing, + object()) def testAssertIsNot(self): thing = object() self.assertIsNot(thing, object()) - self.assertRaises(self.failureException, self.assertIsNot, thing, thing) + self.assertRaises( + self.failureException, + self.assertIsNot, + thing, + thing) def testAssertIsInstance(self): thing = [] @@ -599,7 +649,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): animals) self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc') - self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3]) + self.assertRaises( + self.failureException, self.assertNotIn, 1, [ + 1, 2, 3]) self.assertRaises(self.failureException, self.assertNotIn, 'cow', animals) @@ -625,17 +677,17 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertRaises(unittest2.TestCase.failureException, self.assertDictContainsSubset, {'a': 1, 'c': 1}, {'a': 1}, '.*Missing:.*Mismatched values:.*') - + self.assertRaises(self.failureException, self.assertDictContainsSubset, {1: "one"}, {}) def testAssertEqual(self): equal_pairs = [ - ((), ()), - ({}, {}), - ([], []), - (set(), set()), - (frozenset(), frozenset())] + ((), ()), + ({}, {}), + ([], []), + (set(), set()), + (frozenset(), frozenset())] for a, b in equal_pairs: # This mess of try excepts is to test the assertEqual behavior # itself. @@ -654,11 +706,11 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): (a, b)) unequal_pairs = [ - ((), []), - ({}, set()), - (set([4,1]), frozenset([4,2])), - (frozenset([4,5]), set([2,3])), - (set([3,4]), set([5,4]))] + ((), []), + ({}, set()), + (set([4, 1]), frozenset([4, 2])), + (frozenset([4, 5]), set([2, 3])), + (set([3, 4]), set([5, 4]))] for a, b in unequal_pairs: self.assertRaises(self.failureException, self.assertEqual, a, b) self.assertRaises(self.failureException, self.assertEqual, a, b, @@ -702,7 +754,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertDictEqual({}, {}) - c = { 'x': 1 } + c = {'x': 1} d = {} self.assertRaises(unittest2.TestCase.failureException, self.assertDictEqual, c, d) @@ -734,7 +786,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertItemsEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}]) self.assertRaises(self.failureException, self.assertItemsEqual, [[1]], [[2]]) - + # Test unsortable objects self.assertItemsEqual([2j, None], [None, 2j]) self.assertRaises(self.failureException, self.assertItemsEqual, @@ -745,14 +797,26 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): set2 = set() self.assertSetEqual(set1, set2) - self.assertRaises(self.failureException, self.assertSetEqual, None, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + None, + set2) self.assertRaises(self.failureException, self.assertSetEqual, [], set2) - self.assertRaises(self.failureException, self.assertSetEqual, set1, None) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + None) self.assertRaises(self.failureException, self.assertSetEqual, set1, []) set1 = set(['a']) set2 = set() - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) set1 = set(['a']) set2 = set(['a']) @@ -760,11 +824,19 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): set1 = set(['a']) set2 = set(['a', 'b']) - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) set1 = set(['a']) set2 = frozenset(['a', 'b']) - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) set1 = set(['a', 'b']) set2 = frozenset(['a', 'b']) @@ -772,13 +844,25 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): set1 = set() set2 = "foo" - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) - self.assertRaises(self.failureException, self.assertSetEqual, set2, set1) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set2, + set1) # make sure any string formatting is tuple-safe set1 = set([(0, 1), (2, 3)]) set2 = set([(4, 5)]) - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) def testInequality(self): # Try ints @@ -804,10 +888,18 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLessEqual(1.0, 1.0) self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1) self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0) - self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1) + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + 1.0, + 1.1) self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0) self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0) - self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0) + self.assertRaises( + self.failureException, + self.assertLessEqual, + 1.1, + 1.0) # Try Strings self.assertGreater('bug', 'ant') @@ -816,12 +908,28 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLess('ant', 'bug') self.assertLessEqual('ant', 'bug') self.assertLessEqual('ant', 'ant') - self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug') - self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant') - self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + 'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + 'ant') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + 'ant', + 'bug') self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant') self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant') - self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + 'bug', + 'ant') # Try Unicode self.assertGreater(u'bug', u'ant') @@ -830,13 +938,36 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLess(u'ant', u'bug') self.assertLessEqual(u'ant', u'bug') self.assertLessEqual(u'ant', u'ant') - self.assertRaises(self.failureException, self.assertGreater, u'ant', u'bug') - self.assertRaises(self.failureException, self.assertGreater, u'ant', u'ant') - self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant', - u'bug') - self.assertRaises(self.failureException, self.assertLess, u'bug', u'ant') - self.assertRaises(self.failureException, self.assertLess, u'ant', u'ant') - self.assertRaises(self.failureException, self.assertLessEqual, u'bug', u'ant') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + u'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertLess, + u'bug', + u'ant') + self.assertRaises( + self.failureException, + self.assertLess, + u'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + u'bug', + u'ant') # Try Mixed String/Unicode self.assertGreater('bug', u'ant') @@ -851,20 +982,66 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLessEqual(u'ant', 'bug') self.assertLessEqual('ant', u'ant') self.assertLessEqual(u'ant', 'ant') - self.assertRaises(self.failureException, self.assertGreater, 'ant', u'bug') - self.assertRaises(self.failureException, self.assertGreater, u'ant', 'bug') - self.assertRaises(self.failureException, self.assertGreater, 'ant', u'ant') - self.assertRaises(self.failureException, self.assertGreater, u'ant', 'ant') - self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', - u'bug') - self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant', - 'bug') - self.assertRaises(self.failureException, self.assertLess, 'bug', u'ant') - self.assertRaises(self.failureException, self.assertLess, u'bug', 'ant') - self.assertRaises(self.failureException, self.assertLess, 'ant', u'ant') - self.assertRaises(self.failureException, self.assertLess, u'ant', 'ant') - self.assertRaises(self.failureException, self.assertLessEqual, 'bug', u'ant') - self.assertRaises(self.failureException, self.assertLessEqual, u'bug', 'ant') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + 'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + 'ant') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + 'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + u'ant', + 'bug') + self.assertRaises( + self.failureException, + self.assertLess, + 'bug', + u'ant') + self.assertRaises( + self.failureException, + self.assertLess, + u'bug', + 'ant') + self.assertRaises( + self.failureException, + self.assertLess, + 'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertLess, + u'ant', + 'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + 'bug', + u'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + u'bug', + 'ant') def testAssertMultiLineEqual(self): sample_text = """\ @@ -903,7 +1080,7 @@ test case self.assertTrue(sample_text_error == error) def testAssertSequenceEqualMaxDiff(self): - self.assertEqual(self.maxDiff, 80*8) + self.assertEqual(self.maxDiff, 80 * 8) seq1 = 'a' + 'x' * 80**2 seq2 = 'b' + 'x' * 80**2 diff = '\n'.join(difflib.ndiff(pprint.pformat(seq1).splitlines(), @@ -911,7 +1088,7 @@ test case # the +1 is the leading \n added by assertSequenceEqual omitted = unittest2.case.DIFF_OMITTED % (len(diff) + 1,) - self.maxDiff = len(diff)//2 + self.maxDiff = len(diff) // 2 try: self.assertSequenceEqual(seq1, seq2) except self.failureException as e: @@ -957,6 +1134,7 @@ test case def testAssertDictEqualTruncates(self): test = unittest2.TestCase('assertEqual') + def truncate(msg, diff): return 'foo' test._truncateMessage = truncate @@ -969,6 +1147,7 @@ test case def testAssertMultiLineEqualTruncates(self): test = unittest2.TestCase('assertEqual') + def truncate(msg, diff): return 'foo' test._truncateMessage = truncate @@ -1003,38 +1182,37 @@ test case def testAssertNotRaisesRegexp(self): self.assertRaisesRegexp( - self.failureException, '^Exception not raised$', - self.assertRaisesRegexp, Exception, re.compile('x'), - lambda: None) + self.failureException, '^Exception not raised$', + self.assertRaisesRegexp, Exception, re.compile('x'), + lambda: None) self.assertRaisesRegexp( - self.failureException, '^Exception not raised$', - self.assertRaisesRegexp, Exception, 'x', - lambda: None) + self.failureException, '^Exception not raised$', + self.assertRaisesRegexp, Exception, 'x', + lambda: None) self.assertRaisesRegexp( - self.failureException, '^Exception not raised$', - self.assertRaisesRegexp, Exception, u'x', - lambda: None) + self.failureException, '^Exception not raised$', + self.assertRaisesRegexp, Exception, u'x', + lambda: None) def testAssertRaisesRegexpMismatch(self): def Stub(): raise Exception('Unexpected') self.assertRaisesRegexp( - self.failureException, - r'"\^Expected\$" does not match "Unexpected"', - self.assertRaisesRegexp, Exception, '^Expected$', - Stub) + self.failureException, + r'"\^Expected\$" does not match "Unexpected"', + self.assertRaisesRegexp, Exception, '^Expected$', + Stub) self.assertRaisesRegexp( - self.failureException, - r'"\^Expected\$" does not match "Unexpected"', - self.assertRaisesRegexp, Exception, u'^Expected$', - Stub) + self.failureException, + r'"\^Expected\$" does not match "Unexpected"', + self.assertRaisesRegexp, Exception, u'^Expected$', + Stub) self.assertRaisesRegexp( - self.failureException, - r'"\^Expected\$" does not match "Unexpected"', - self.assertRaisesRegexp, Exception, - re.compile('^Expected$'), Stub) - + self.failureException, + r'"\^Expected\$" does not match "Unexpected"', + self.assertRaisesRegexp, Exception, + re.compile('^Expected$'), Stub) def testSynonymAssertMethodNames(self): """Test undocumented method name synonyms. @@ -1053,6 +1231,7 @@ test case def testDeepcopy(self): # Issue: 5660 class TestableTest(unittest2.TestCase): + def testNothing(self): pass diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py index f78c4d826b8..70bc588e5ac 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py @@ -27,12 +27,15 @@ class TestDiscovery(unittest2.TestCase): loader = unittest2.TestLoader() original_listdir = os.listdir + def restore_listdir(): os.listdir = original_listdir original_isfile = os.path.isfile + def restore_isfile(): os.path.isfile = original_isfile original_isdir = os.path.isdir + def restore_isdir(): os.path.isdir = original_isdir @@ -63,19 +66,22 @@ class TestDiscovery(unittest2.TestCase): expected = [name + ' module tests' for name in ('test1', 'test2')] expected.extend([('test_dir.%s' % name) + ' module tests' for name in - ('test3', 'test4')]) + ('test3', 'test4')]) self.assertEqual(suite, expected) def test_find_tests_with_package(self): loader = unittest2.TestLoader() original_listdir = os.listdir + def restore_listdir(): os.listdir = original_listdir original_isfile = os.path.isfile + def restore_isfile(): os.path.isfile = original_isfile original_isdir = os.path.isdir + def restore_isdir(): os.path.isdir = original_isdir @@ -110,9 +116,11 @@ class TestDiscovery(unittest2.TestCase): __hash__ = None loader._get_module_from_name = lambda name: Module(name) + def loadTestsFromModule(module, use_load_tests): if use_load_tests: - raise self.failureException('use_load_tests should be False for packages') + raise self.failureException( + 'use_load_tests should be False for packages') return module.path + ' module tests' loader.loadTestsFromModule = loadTestsFromModule @@ -127,15 +135,18 @@ class TestDiscovery(unittest2.TestCase): ['load_tests', 'test_directory2' + ' module tests']) self.assertEqual(Module.paths, ['test_directory', 'test_directory2']) - # load_tests should have been called once with loader, tests and pattern - self.assertEqual(Module.load_tests_args, - [(loader, 'test_directory' + ' module tests', 'test*')]) + # load_tests should have been called once with loader, tests and + # pattern + self.assertEqual( + Module.load_tests_args, [ + (loader, 'test_directory' + ' module tests', 'test*')]) def test_discover(self): loader = unittest2.TestLoader() original_isfile = os.path.isfile original_isdir = os.path.isdir + def restore_isfile(): os.path.isfile = original_isfile @@ -143,6 +154,7 @@ class TestDiscovery(unittest2.TestCase): self.addCleanup(restore_isfile) orig_sys_path = sys.path[:] + def restore_path(): sys.path[:] = orig_sys_path self.addCleanup(restore_path) @@ -163,6 +175,7 @@ class TestDiscovery(unittest2.TestCase): self.addCleanup(restore_isdir) _find_tests_args = [] + def _find_tests(start_dir, pattern): _find_tests_args.append((start_dir, pattern)) return ['tests'] @@ -186,6 +199,7 @@ class TestDiscovery(unittest2.TestCase): isfile = os.path.isfile os.path.isfile = lambda _: True orig_sys_path = sys.path[:] + def restore(): os.path.isfile = isfile os.listdir = listdir @@ -195,16 +209,17 @@ class TestDiscovery(unittest2.TestCase): suite = loader.discover('.') self.assertIn(os.getcwd(), sys.path) self.assertEqual(suite.countTestCases(), 1) - test = list(list(suite)[0])[0] # extract test from suite + test = list(list(suite)[0])[0] # extract test from suite self.assertRaises(ImportError, - lambda: test.test_this_does_not_exist()) + lambda: test.test_this_does_not_exist()) def test_command_line_handling_parseArgs(self): # Haha - take that uninstantiable class program = object.__new__(unittest2.TestProgram) args = [] + def do_discovery(argv): args.extend(argv) program._do_discovery = do_discovery @@ -217,6 +232,7 @@ class TestDiscovery(unittest2.TestCase): def test_command_line_handling_do_discovery_too_many_arguments(self): class Stop(Exception): pass + def usageExit(): raise Stop @@ -224,15 +240,15 @@ class TestDiscovery(unittest2.TestCase): program.usageExit = usageExit self.assertRaises(Stop, - # too many args - lambda: program._do_discovery(['one', 'two', 'three', 'four'])) - + # too many args + lambda: program._do_discovery(['one', 'two', 'three', 'four'])) def test_command_line_handling_do_discovery_calls_loader(self): program = object.__new__(unittest2.TestProgram) class Loader(object): args = [] + def discover(self, start_dir, pattern, top_level_dir): self.args.append((start_dir, pattern, top_level_dir)) return 'tests' @@ -317,7 +333,7 @@ class TestDiscovery(unittest2.TestCase): original_listdir = os.listdir original_isfile = os.path.isfile original_isdir = os.path.isdir - + def cleanup(): os.listdir = original_listdir os.path.isfile = original_isfile @@ -326,37 +342,42 @@ class TestDiscovery(unittest2.TestCase): if full_path in sys.path: sys.path.remove(full_path) self.addCleanup(cleanup) - + def listdir(_): return ['foo.py'] + def isfile(_): return True + def isdir(_): return True os.listdir = listdir os.path.isfile = isfile os.path.isdir = isdir - + loader = unittest2.TestLoader() - + mod_dir = os.path.abspath('bar') expected_dir = os.path.abspath('foo') - msg = re.escape(r"'foo' module incorrectly imported from %r. Expected %r. " - "Is this module globally installed?" % (mod_dir, expected_dir)) + msg = re.escape( + r"'foo' module incorrectly imported from %r. Expected %r. " + "Is this module globally installed?" % + (mod_dir, expected_dir)) self.assertRaisesRegexp( ImportError, '^%s$' % msg, loader.discover, start_dir='foo', pattern='foo.py' ) self.assertEqual(sys.path[0], full_path) - def test_discovery_from_dotted_path(self): loader = unittest2.TestLoader() - + tests = [self] - expectedPath = os.path.abspath(os.path.dirname(unittest2.test.__file__)) + expectedPath = os.path.abspath( + os.path.dirname(unittest2.test.__file__)) self.wasRun = False + def _find_tests(start_dir, pattern): self.wasRun = True self.assertEqual(start_dir, expectedPath) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py index 263aed5a9bf..ccfadc97d36 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py @@ -145,6 +145,5 @@ class Test_FunctionTestCase(unittest2.TestCase): self.assertEqual(test.shortDescription(), "this tests foo") - if __name__ == '__main__': unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py index 3a61f33e319..45fea56aad0 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py @@ -6,15 +6,18 @@ import unittest2 class Test_TestLoader(unittest2.TestCase): - ### Tests for TestLoader.loadTestsFromTestCase + # Tests for TestLoader.loadTestsFromTestCase ################################################################ # "Return a suite of all tests cases contained in the TestCase-derived # class testCaseClass" def test_loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass tests = unittest2.TestSuite([Foo('test_1'), Foo('test_2')]) @@ -28,6 +31,7 @@ class Test_TestLoader(unittest2.TestCase): # Make sure it does the right thing even if no tests were found def test_loadTestsFromTestCase__no_matches(self): class Foo(unittest2.TestCase): + def foo_bar(self): pass empty_suite = unittest2.TestSuite() @@ -64,6 +68,7 @@ class Test_TestLoader(unittest2.TestCase): # not match the default TestLoader.testMethodPrefix string def test_loadTestsFromTestCase__default_method_name(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -76,15 +81,17 @@ class Test_TestLoader(unittest2.TestCase): self.assertEqual(list(suite), [Foo('runTest')]) ################################################################ - ### /Tests for TestLoader.loadTestsFromTestCase + # /Tests for TestLoader.loadTestsFromTestCase - ### Tests for TestLoader.loadTestsFromModule + # Tests for TestLoader.loadTestsFromModule ################################################################ # "This method searches `module` for classes derived from TestCase" def test_loadTestsFromModule__TestCase_subclass(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -112,6 +119,7 @@ class Test_TestLoader(unittest2.TestCase): # What happens if no tests are found (TestCases instances, but no tests)? def test_loadTestsFromModule__no_TestCase_tests(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): pass m.testcase_1 = MyTestCase @@ -134,6 +142,7 @@ class Test_TestLoader(unittest2.TestCase): # XXX Certain people are using this behaviour. We'll add a test for it def test_loadTestsFromModule__not_a_module(self): class MyTestCase(unittest2.TestCase): + def test(self): pass @@ -146,17 +155,19 @@ class Test_TestLoader(unittest2.TestCase): reference = [unittest2.TestSuite([MyTestCase('test')])] self.assertEqual(list(suite), reference) - # Check that loadTestsFromModule honors (or not) a module # with a load_tests function. def test_loadTestsFromModule__load_tests(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase load_tests_args = [] + def load_tests(loader, tests, pattern): self.assertIsInstance(tests, unittest2.TestSuite) load_tests_args.extend((loader, tests, pattern)) @@ -184,14 +195,13 @@ class Test_TestLoader(unittest2.TestCase): self.assertIsInstance(suite, unittest2.TestSuite) self.assertEqual(suite.countTestCases(), 1) test = list(suite)[0] - + self.assertRaisesRegexp(TypeError, "some failure", test.m) - ################################################################ - ### /Tests for TestLoader.loadTestsFromModule() + # /Tests for TestLoader.loadTestsFromModule() - ### Tests for TestLoader.loadTestsFromName() + # Tests for TestLoader.loadTestsFromName() ################################################################ # "The specifier name is a ``dotted name'' that may resolve either to @@ -255,9 +265,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromName('unittest2.sdasfasfasdf') except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -272,9 +284,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromName('sdasfasfasdf', unittest2) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -330,6 +344,7 @@ class Test_TestLoader(unittest2.TestCase): # XXX Some people are relying on this, so keep it for now def test_loadTestsFromName__relative_not_a_module(self): class MyTestCase(unittest2.TestCase): + def test(self): pass @@ -365,7 +380,9 @@ class Test_TestLoader(unittest2.TestCase): # resolve either to ... a test case class" def test_loadTestsFromName__relative_TestCase_subclass(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -381,7 +398,9 @@ class Test_TestLoader(unittest2.TestCase): # TestCase or TestSuite instance." def test_loadTestsFromName__relative_TestSuite(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testsuite = unittest2.TestSuite([MyTestCase('test')]) @@ -396,7 +415,9 @@ class Test_TestLoader(unittest2.TestCase): # ... a test method within a test case class" def test_loadTestsFromName__relative_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -417,7 +438,9 @@ class Test_TestLoader(unittest2.TestCase): # for the given name (relative to a provided module)? def test_loadTestsFromName__relative_invalid_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -426,7 +449,8 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromName('testcase_1.testfoo', m) except AttributeError as e: - self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") + self.assertEqual( + str(e), "type object 'MyTestCase' has no attribute 'testfoo'") else: self.fail("Failed to raise AttributeError") @@ -436,6 +460,7 @@ class Test_TestLoader(unittest2.TestCase): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) testcase_2 = unittest2.FunctionTestCase(lambda: None) + def return_TestSuite(): return unittest2.TestSuite([testcase_1, testcase_2]) m.return_TestSuite = return_TestSuite @@ -450,6 +475,7 @@ class Test_TestLoader(unittest2.TestCase): def test_loadTestsFromName__callable__TestCase_instance(self): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) + def return_TestCase(): return testcase_1 m.return_TestCase = return_TestCase @@ -462,13 +488,15 @@ class Test_TestLoader(unittest2.TestCase): # "The specifier name is a ``dotted name'' that may resolve ... to # ... a callable object which returns a TestCase ... instance" #***************************************************************** - #Override the suiteClass attribute to ensure that the suiteClass + # Override the suiteClass attribute to ensure that the suiteClass #attribute is used - def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass(self): + def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass( + self): class SubTestSuite(unittest2.TestSuite): pass m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) + def return_TestCase(): return testcase_1 m.return_TestCase = return_TestCase @@ -482,19 +510,21 @@ class Test_TestLoader(unittest2.TestCase): # "The specifier name is a ``dotted name'' that may resolve ... to # ... a test method within a test case class" #***************************************************************** - #Override the suiteClass attribute to ensure that the suiteClass + # Override the suiteClass attribute to ensure that the suiteClass #attribute is used def test_loadTestsFromName__relative_testmethod_ProperSuiteClass(self): class SubTestSuite(unittest2.TestSuite): pass m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase loader = unittest2.TestLoader() - loader.suiteClass=SubTestSuite + loader.suiteClass = SubTestSuite suite = loader.loadTestsFromName('testcase_1.test', m) self.assertIsInstance(suite, loader.suiteClass) @@ -506,6 +536,7 @@ class Test_TestLoader(unittest2.TestCase): # What happens if the callable returns something else? def test_loadTestsFromName__callable__wrong_type(self): m = types.ModuleType('m') + def return_wrong(): return 6 m.return_wrong = return_wrong @@ -541,9 +572,9 @@ class Test_TestLoader(unittest2.TestCase): del sys.modules[module_name] ################################################################ - ### Tests for TestLoader.loadTestsFromName() + # Tests for TestLoader.loadTestsFromName() - ### Tests for TestLoader.loadTestsFromNames() + # Tests for TestLoader.loadTestsFromNames() ################################################################ # "Similar to loadTestsFromName(), but takes a sequence of names rather @@ -635,9 +666,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['unittest2.sdasfasfasdf', 'unittest2']) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromNames failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromNames failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -654,9 +687,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['sdasfasfasdf'], unittest2) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -673,9 +708,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest2) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -728,6 +765,7 @@ class Test_TestLoader(unittest2.TestCase): # either be documented or a TypeError should be raised. def test_loadTestsFromNames__relative_not_a_module(self): class MyTestCase(unittest2.TestCase): + def test(self): pass @@ -763,7 +801,9 @@ class Test_TestLoader(unittest2.TestCase): # ... a test case class" def test_loadTestsFromNames__relative_TestCase_subclass(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -779,7 +819,9 @@ class Test_TestLoader(unittest2.TestCase): # ... a TestSuite instance" def test_loadTestsFromNames__relative_TestSuite(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testsuite = unittest2.TestSuite([MyTestCase('test')]) @@ -794,7 +836,9 @@ class Test_TestLoader(unittest2.TestCase): # test method within a test case class" def test_loadTestsFromNames__relative_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -813,7 +857,9 @@ class Test_TestLoader(unittest2.TestCase): # resolve to "a test method within a test case class" but don't? def test_loadTestsFromNames__relative_invalid_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -822,7 +868,8 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['testcase_1.testfoo'], m) except AttributeError as e: - self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") + self.assertEqual( + str(e), "type object 'MyTestCase' has no attribute 'testfoo'") else: self.fail("Failed to raise AttributeError") @@ -832,6 +879,7 @@ class Test_TestLoader(unittest2.TestCase): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) testcase_2 = unittest2.FunctionTestCase(lambda: None) + def return_TestSuite(): return unittest2.TestSuite([testcase_1, testcase_2]) m.return_TestSuite = return_TestSuite @@ -848,6 +896,7 @@ class Test_TestLoader(unittest2.TestCase): def test_loadTestsFromNames__callable__TestCase_instance(self): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) + def return_TestCase(): return testcase_1 m.return_TestCase = return_TestCase @@ -865,12 +914,16 @@ class Test_TestLoader(unittest2.TestCase): # Are staticmethods handled correctly? def test_loadTestsFromNames__callable__call_staticmethod(self): m = types.ModuleType('m') + class Test1(unittest2.TestCase): + def test(self): pass testcase_1 = Test1('test') + class Foo(unittest2.TestCase): + @staticmethod def foo(): return testcase_1 @@ -889,6 +942,7 @@ class Test_TestLoader(unittest2.TestCase): # What happens when the callable returns something else? def test_loadTestsFromNames__callable__wrong_type(self): m = types.ModuleType('m') + def return_wrong(): return 6 m.return_wrong = return_wrong @@ -924,9 +978,9 @@ class Test_TestLoader(unittest2.TestCase): del sys.modules[module_name] ################################################################ - ### /Tests for TestLoader.loadTestsFromNames() + # /Tests for TestLoader.loadTestsFromNames() - ### Tests for TestLoader.getTestCaseNames() + # Tests for TestLoader.getTestCaseNames() ################################################################ # "Return a sorted sequence of method names found within testCaseClass" @@ -935,8 +989,11 @@ class Test_TestLoader(unittest2.TestCase): # loader.testMethodPrefix def test_getTestCaseNames(self): class Test(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foobar(self): pass loader = unittest2.TestLoader() @@ -948,6 +1005,7 @@ class Test_TestLoader(unittest2.TestCase): # Does getTestCaseNames() behave appropriately if no tests are found? def test_getTestCaseNames__no_tests(self): class Test(unittest2.TestCase): + def foobar(self): pass loader = unittest2.TestLoader() @@ -964,6 +1022,7 @@ class Test_TestLoader(unittest2.TestCase): # probably be revisited for 2.6 def test_getTestCaseNames__not_a_TestCase(self): class BadCase(int): + def test_foo(self): pass @@ -980,12 +1039,17 @@ class Test_TestLoader(unittest2.TestCase): # loader.testMethodPrefix def test_getTestCaseNames__inheritance(self): class TestP(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foobar(self): pass class TestC(TestP): + def test_1(self): pass + def test_3(self): pass loader = unittest2.TestLoader() @@ -994,9 +1058,9 @@ class Test_TestLoader(unittest2.TestCase): self.assertEqual(loader.getTestCaseNames(TestC), names) ################################################################ - ### /Tests for TestLoader.getTestCaseNames() + # /Tests for TestLoader.getTestCaseNames() - ### Tests for TestLoader.testMethodPrefix + # Tests for TestLoader.testMethodPrefix ################################################################ # "String giving the prefix of method names which will be interpreted as @@ -1006,8 +1070,11 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass tests_1 = unittest2.TestSuite([Foo('foo_bar')]) @@ -1027,9 +1094,13 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromModule(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1050,9 +1121,13 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromName(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1073,9 +1148,13 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromNames(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1096,16 +1175,18 @@ class Test_TestLoader(unittest2.TestCase): self.assertTrue(loader.testMethodPrefix == 'test') ################################################################ - ### /Tests for TestLoader.testMethodPrefix + # /Tests for TestLoader.testMethodPrefix - ### Tests for TestLoader.sortTestMethodsUsing + # Tests for TestLoader.sortTestMethodsUsing ################################################################ # "Function to be used to compare method names when sorting them in # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass loader = unittest2.TestLoader() @@ -1118,8 +1199,11 @@ class Test_TestLoader(unittest2.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromModule(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass m.Foo = Foo @@ -1133,8 +1217,11 @@ class Test_TestLoader(unittest2.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromName(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass m.Foo = Foo @@ -1148,8 +1235,11 @@ class Test_TestLoader(unittest2.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromNames(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass m.Foo = Foo @@ -1165,7 +1255,9 @@ class Test_TestLoader(unittest2.TestCase): # Does it actually affect getTestCaseNames()? def test_sortTestMethodsUsing__getTestCaseNames(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass loader = unittest2.TestLoader() @@ -1185,7 +1277,9 @@ class Test_TestLoader(unittest2.TestCase): # in a random order or something? This behaviour should die def test_sortTestMethodsUsing__None(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass loader = unittest2.TestLoader() @@ -1195,16 +1289,19 @@ class Test_TestLoader(unittest2.TestCase): self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names)) ################################################################ - ### /Tests for TestLoader.sortTestMethodsUsing + # /Tests for TestLoader.sortTestMethodsUsing - ### Tests for TestLoader.suiteClass + # Tests for TestLoader.suiteClass ################################################################ # "Callable object that constructs a test suite from a list of tests." def test_suiteClass__loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass tests = [Foo('test_1'), Foo('test_2')] @@ -1217,9 +1314,13 @@ class Test_TestLoader(unittest2.TestCase): # all TestLoader.loadTestsFrom* methods respect it. Let's make sure def test_suiteClass__loadTestsFromModule(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1233,9 +1334,13 @@ class Test_TestLoader(unittest2.TestCase): # all TestLoader.loadTestsFrom* methods respect it. Let's make sure def test_suiteClass__loadTestsFromName(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1249,9 +1354,13 @@ class Test_TestLoader(unittest2.TestCase): # all TestLoader.loadTestsFrom* methods respect it. Let's make sure def test_suiteClass__loadTestsFromNames(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py index cc96bcb6a05..0b456c08927 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py @@ -7,40 +7,46 @@ from unittest2.test.support import resultFactory class TestUnittest(unittest2.TestCase): - + def assertIsSubclass(self, actual, klass): self.assertTrue(issubclass(actual, klass), "Not a subclass.") - + def testInheritance(self): self.assertIsSubclass(unittest2.TestCase, unittest.TestCase) self.assertIsSubclass(unittest2.TestResult, unittest.TestResult) self.assertIsSubclass(unittest2.TestSuite, unittest.TestSuite) - self.assertIsSubclass(unittest2.TextTestRunner, unittest.TextTestRunner) + self.assertIsSubclass( + unittest2.TextTestRunner, + unittest.TextTestRunner) self.assertIsSubclass(unittest2.TestLoader, unittest.TestLoader) self.assertIsSubclass(unittest2.TextTestResult, unittest.TestResult) - + def test_new_runner_old_case(self): runner = unittest2.TextTestRunner(resultclass=resultFactory, stream=StringIO()) + class Test(unittest.TestCase): + def testOne(self): pass suite = unittest2.TestSuite((Test('testOne'),)) result = runner.run(suite) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 0) - + def test_old_runner_new_case(self): runner = unittest.TextTestRunner(stream=StringIO()) + class Test(unittest2.TestCase): + def testOne(self): self.assertDictEqual({}, {}) - + suite = unittest.TestSuite((Test('testOne'),)) result = runner.run(suite) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 0) - - + + if __name__ == '__main__': - unittest2.main()
\ No newline at end of file + unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py index 56077a6bb3a..eb864871e16 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py @@ -5,6 +5,7 @@ import unittest2 hasInstallHandler = hasattr(unittest2, 'installHandler') + class Test_TestProgram(unittest2.TestCase): # Horrible white box test @@ -13,6 +14,7 @@ class Test_TestProgram(unittest2.TestCase): test = object() class FakeRunner(object): + def run(self, test): self.test = test return result @@ -20,6 +22,7 @@ class Test_TestProgram(unittest2.TestCase): runner = FakeRunner() oldParseArgs = unittest2.TestProgram.parseArgs + def restoreParseArgs(): unittest2.TestProgram.parseArgs = oldParseArgs unittest2.TestProgram.parseArgs = lambda *args: None @@ -30,33 +33,37 @@ class Test_TestProgram(unittest2.TestCase): unittest2.TestProgram.test = test self.addCleanup(removeTest) - program = unittest2.TestProgram(testRunner=runner, exit=False, verbosity=2) + program = unittest2.TestProgram( + testRunner=runner, exit=False, verbosity=2) self.assertEqual(program.result, result) self.assertEqual(runner.test, test) self.assertEqual(program.verbosity, 2) class FooBar(unittest2.TestCase): + def testPass(self): assert True + def testFail(self): assert False class FooBarLoader(unittest2.TestLoader): """Test loader that returns a suite containing FooBar.""" + def loadTestsFromModule(self, module): return self.suiteClass( [self.loadTestsFromTestCase(Test_TestProgram.FooBar)]) - def test_NonExit(self): - program = unittest2.main(exit=False, - argv=["foobar"], - testRunner=unittest2.TextTestRunner(stream=StringIO()), - testLoader=self.FooBarLoader()) + program = unittest2.main( + exit=False, + argv=["foobar"], + testRunner=unittest2.TextTestRunner( + stream=StringIO()), + testLoader=self.FooBarLoader()) self.assertTrue(hasattr(program, 'result')) - def test_Exit(self): self.assertRaises( SystemExit, @@ -66,7 +73,6 @@ class Test_TestProgram(unittest2.TestCase): exit=True, testLoader=self.FooBarLoader()) - def test_ExitAsDefault(self): self.assertRaises( SystemExit, @@ -85,11 +91,13 @@ class InitialisableProgram(unittest2.TestProgram): testLoader = unittest2.defaultTestLoader progName = 'test' test = 'test' + def __init__(self, *args): pass RESULT = object() + class FakeRunner(object): initArgs = None test = None @@ -105,35 +113,37 @@ class FakeRunner(object): FakeRunner.test = test return RESULT + class TestCommandLineArgs(unittest2.TestCase): - + def setUp(self): self.program = InitialisableProgram() self.program.createTests = lambda: None FakeRunner.initArgs = None FakeRunner.test = None FakeRunner.raiseError = False - + def testHelpAndUnknown(self): program = self.program + def usageExit(msg=None): program.msg = msg program.exit = True program.usageExit = usageExit - + for opt in '-h', '-H', '--help': program.exit = False program.parseArgs([None, opt]) self.assertTrue(program.exit) self.assertIsNone(program.msg) - + program.parseArgs([None, '-$']) self.assertTrue(program.exit) self.assertIsNotNone(program.msg) - + def testVerbosity(self): program = self.program - + for opt in '-q', '--quiet': program.verbosity = 1 program.parseArgs([None, opt]) @@ -147,90 +157,92 @@ class TestCommandLineArgs(unittest2.TestCase): def testBufferCatchFailfast(self): program = self.program for arg, attr in (('buffer', 'buffer'), ('failfast', 'failfast'), - ('catch', 'catchbreak')): + ('catch', 'catchbreak')): if attr == 'catch' and not hasInstallHandler: continue - + short_opt = '-%s' % arg[0] long_opt = '--%s' % arg for opt in short_opt, long_opt: setattr(program, attr, None) - + program.parseArgs([None, opt]) self.assertTrue(getattr(program, attr)) for opt in short_opt, long_opt: not_none = object() setattr(program, attr, not_none) - + program.parseArgs([None, opt]) self.assertEqual(getattr(program, attr), not_none) def testRunTestsRunnerClass(self): program = self.program - + program.testRunner = FakeRunner program.verbosity = 'verbosity' program.failfast = 'failfast' program.buffer = 'buffer' - + program.runTests() - - self.assertEqual(FakeRunner.initArgs, {'verbosity': 'verbosity', - 'failfast': 'failfast', - 'buffer': 'buffer'}) + + self.assertEqual(FakeRunner.initArgs, {'verbosity': 'verbosity', + 'failfast': 'failfast', + 'buffer': 'buffer'}) self.assertEqual(FakeRunner.test, 'test') self.assertIs(program.result, RESULT) def testRunTestsRunnerInstance(self): program = self.program - + program.testRunner = FakeRunner() FakeRunner.initArgs = None - + program.runTests() # A new FakeRunner should not have been instantiated self.assertIsNone(FakeRunner.initArgs) - + self.assertEqual(FakeRunner.test, 'test') self.assertIs(program.result, RESULT) def testRunTestsOldRunnerClass(self): program = self.program - + FakeRunner.raiseError = True program.testRunner = FakeRunner program.verbosity = 'verbosity' program.failfast = 'failfast' program.buffer = 'buffer' program.test = 'test' - + program.runTests() - + # If initialising raises a type error it should be retried # without the new keyword arguments self.assertEqual(FakeRunner.initArgs, {}) self.assertEqual(FakeRunner.test, 'test') self.assertIs(program.result, RESULT) - + def testCatchBreakInstallsHandler(self): module = sys.modules['unittest2.main'] original = module.installHandler + def restore(): module.installHandler = original self.addCleanup(restore) self.installed = False + def fakeInstallHandler(): self.installed = True module.installHandler = fakeInstallHandler - + program = self.program program.catchbreak = True - + program.testRunner = FakeRunner - + program.runTests() self.assertTrue(self.installed) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py index 69b31d542ea..e4e26bd51fe 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py @@ -42,6 +42,7 @@ class Test_TestResult(unittest2.TestCase): # implementation simply increments the instance's testsRun counter." def test_startTest(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -63,6 +64,7 @@ class Test_TestResult(unittest2.TestCase): # the outcome. The default implementation does nothing." def test_stopTest(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -114,6 +116,7 @@ class Test_TestResult(unittest2.TestCase): # of sys.exc_info() results." def test_addSuccess(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -153,6 +156,7 @@ class Test_TestResult(unittest2.TestCase): # of sys.exc_info() results." def test_addFailure(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -201,6 +205,7 @@ class Test_TestResult(unittest2.TestCase): # of sys.exc_info() results." def test_addError(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -229,18 +234,18 @@ class Test_TestResult(unittest2.TestCase): def testGetDescriptionWithoutDocstring(self): result = unittest2.TextTestResult(None, True, 1) self.assertEqual( - result.getDescription(self), - 'testGetDescriptionWithoutDocstring (' + __name__ + - '.Test_TestResult)') + result.getDescription(self), + 'testGetDescriptionWithoutDocstring (' + __name__ + + '.Test_TestResult)') def testGetDescriptionWithOneLineDocstring(self): """Tests getDescription() for a method with a docstring.""" result = unittest2.TextTestResult(None, True, 1) self.assertEqual( - result.getDescription(self), - ('testGetDescriptionWithOneLineDocstring ' - '(' + __name__ + '.Test_TestResult)\n' - 'Tests getDescription() for a method with a docstring.')) + result.getDescription(self), + ('testGetDescriptionWithOneLineDocstring ' + '(' + __name__ + '.Test_TestResult)\n' + 'Tests getDescription() for a method with a docstring.')) def testGetDescriptionWithMultiLineDocstring(self): """Tests getDescription() for a method with a longer docstring. @@ -248,19 +253,20 @@ class Test_TestResult(unittest2.TestCase): """ result = unittest2.TextTestResult(None, True, 1) self.assertEqual( - result.getDescription(self), - ('testGetDescriptionWithMultiLineDocstring ' - '(' + __name__ + '.Test_TestResult)\n' - 'Tests getDescription() for a method with a longer ' - 'docstring.')) + 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 = unittest2.TestResult() self.assertFalse(result._is_relevant_tb_level(Frame)) - + Frame.tb_frame.f_globals['__unittest'] = True self.assertTrue(result._is_relevant_tb_level(Frame)) @@ -286,6 +292,7 @@ class Test_TestResult(unittest2.TestCase): def testFailFastSetByRunner(self): runner = unittest2.TextTestRunner(stream=StringIO(), failfast=True) self.testRan = False + def test(result): self.testRan = True self.assertTrue(result.failfast) @@ -306,65 +313,64 @@ class TestOutputBuffering(unittest2.TestCase): def testBufferOutputOff(self): real_out = self._real_out real_err = self._real_err - + result = unittest2.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 = unittest2.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('bar', file=sys.stderr) - + 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 = unittest2.TestResult() @@ -374,26 +380,26 @@ class TestOutputBuffering(unittest2.TestCase): def testBufferOutputAddErrorOrFailure(self): for message_attr, add_attr, include_error in [ - ('errors', 'addError', True), + ('errors', 'addError', True), ('failures', 'addFailure', False), - ('errors', 'addError', True), + ('errors', 'addError', True), ('failures', 'addFailure', False) ]: result = self.getStartedResult() result._original_stderr = StringIO() result._original_stdout = StringIO() - + print('foo') if include_error: print('bar', file=sys.stderr) - + 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: @@ -405,14 +411,18 @@ class TestOutputBuffering(unittest2.TestCase): Stderr: bar """) - expectedFullMessage = 'None\n%s%s' % (expectedOutMessage, expectedErrMessage) + expectedFullMessage = 'None\n%s%s' % ( + expectedOutMessage, expectedErrMessage) self.assertIs(test, self) - self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage) - self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage) + self.assertEqual( + result._original_stdout.getvalue(), + expectedOutMessage) + self.assertEqual( + result._original_stderr.getvalue(), + expectedErrMessage) self.assertMultiLineEqual(message, expectedFullMessage) - - + if __name__ == '__main__': unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py index 38b39efb006..cfdf1326fa3 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py @@ -17,63 +17,70 @@ class Test_TextTestRunner(unittest2.TestCase): self.assertTrue(runner.descriptions) self.assertEqual(runner.resultclass, unittest2.TextTestResult) - def testBufferAndFailfast(self): class Test(unittest2.TestCase): + def testFoo(self): pass result = unittest2.TestResult() runner = unittest2.TextTestRunner(stream=StringIO(), failfast=True, - buffer=True) + buffer=True) # Use our result object runner._makeResult = lambda: result runner.run(Test('testFoo')) - + self.assertTrue(result.failfast) self.assertTrue(result.buffer) def testRunnerRegistersResult(self): class Test(unittest2.TestCase): + def testFoo(self): pass originalRegisterResult = unittest2.runner.registerResult + def cleanup(): unittest2.runner.registerResult = originalRegisterResult self.addCleanup(cleanup) - + result = unittest2.TestResult() runner = unittest2.TextTestRunner(stream=StringIO()) # Use our result object runner._makeResult = lambda: result - + self.wasRegistered = 0 + def fakeRegisterResult(thisResult): self.wasRegistered += 1 self.assertEqual(thisResult, result) unittest2.runner.registerResult = fakeRegisterResult - + runner.run(unittest2.TestSuite()) self.assertEqual(self.wasRegistered, 1) - + def test_works_with_result_without_startTestRun_stopTestRun(self): class OldTextResult(OldTestResult): + def __init__(self, *_): super(OldTextResult, self).__init__() separator2 = '' + def printErrors(self): pass - runner = unittest2.TextTestRunner(stream=StringIO(), + runner = unittest2.TextTestRunner(stream=StringIO(), resultclass=OldTextResult) runner.run(unittest2.TestSuite()) def test_startTestRun_stopTestRun_called(self): class LoggingTextResult(LoggingResult): separator2 = '' + def printErrors(self): pass class LoggingRunner(unittest2.TextTestRunner): + def __init__(self, events): super(LoggingRunner, self).__init__(StringIO()) self._events = events @@ -107,15 +114,15 @@ class Test_TextTestRunner(unittest2.TestCase): DESCRIPTIONS = object() VERBOSITY = object() runner = unittest2.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY, - resultclass=MockResultClass) + resultclass=MockResultClass) self.assertEqual(runner.resultclass, MockResultClass) expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY) self.assertEqual(runner._makeResult(), expectedresult) - def test_oldresult(self): class Test(unittest2.TestCase): + def testFoo(self): pass runner = unittest2.TextTestRunner(resultclass=OldTestResult, @@ -126,4 +133,4 @@ class Test_TextTestRunner(unittest2.TestCase): if __name__ == '__main__': - unittest2.main()
\ No newline at end of file + unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py index 55c7f578df1..73526894aaa 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py @@ -7,18 +7,19 @@ from unittest2.test.support import resultFactory class TestSetups(unittest2.TestCase): - + def getRunner(self): return unittest2.TextTestRunner(resultclass=resultFactory, - stream=StringIO()) + stream=StringIO()) + def runTests(self, *cases): suite = unittest2.TestSuite() for case in cases: tests = unittest2.defaultTestLoader.loadTestsFromTestCase(case) suite.addTests(tests) - + runner = self.getRunner() - + # creating a nested suite exposes some potential bugs realSuite = unittest2.TestSuite() realSuite.addTest(suite) @@ -26,21 +27,24 @@ class TestSetups(unittest2.TestCase): suite.addTest(unittest2.TestSuite()) realSuite.addTest(unittest2.TestSuite()) return runner.run(realSuite) - + def test_setup_class(self): class Test(unittest2.TestCase): setUpCalled = 0 + @classmethod def setUpClass(cls): Test.setUpCalled += 1 unittest2.TestCase.setUpClass() + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test) - + self.assertEqual(Test.setUpCalled, 1) self.assertEqual(result.testsRun, 2) self.assertEqual(len(result.errors), 0) @@ -48,46 +52,55 @@ class TestSetups(unittest2.TestCase): def test_teardown_class(self): class Test(unittest2.TestCase): tearDownCalled = 0 + @classmethod def tearDownClass(cls): Test.tearDownCalled += 1 unittest2.TestCase.tearDownClass() + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test) - + self.assertEqual(Test.tearDownCalled, 1) self.assertEqual(result.testsRun, 2) self.assertEqual(len(result.errors), 0) - + def test_teardown_class_two_classes(self): class Test(unittest2.TestCase): tearDownCalled = 0 + @classmethod def tearDownClass(cls): Test.tearDownCalled += 1 unittest2.TestCase.tearDownClass() + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): tearDownCalled = 0 + @classmethod def tearDownClass(cls): Test2.tearDownCalled += 1 unittest2.TestCase.tearDownClass() + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test, Test2) - + self.assertEqual(Test.tearDownCalled, 1) self.assertEqual(Test2.tearDownCalled, 1) self.assertEqual(result.testsRun, 4) @@ -95,81 +108,96 @@ class TestSetups(unittest2.TestCase): def test_error_in_setupclass(self): class BrokenTest(unittest2.TestCase): + @classmethod def setUpClass(cls): raise TypeError('foo') + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(BrokenTest) - + self.assertEqual(result.testsRun, 0) self.assertEqual(len(result.errors), 1) error, _ = result.errors[0] - self.assertEqual(str(error), - 'setUpClass (%s.BrokenTest)' % __name__) + self.assertEqual(str(error), + 'setUpClass (%s.BrokenTest)' % __name__) def test_error_in_teardown_class(self): class Test(unittest2.TestCase): tornDown = 0 + @classmethod def tearDownClass(cls): Test.tornDown += 1 raise TypeError('foo') + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): tornDown = 0 + @classmethod def tearDownClass(cls): Test2.tornDown += 1 raise TypeError('foo') + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test, Test2) self.assertEqual(result.testsRun, 4) self.assertEqual(len(result.errors), 2) self.assertEqual(Test.tornDown, 1) self.assertEqual(Test2.tornDown, 1) - + error, _ = result.errors[0] - self.assertEqual(str(error), - 'tearDownClass (%s.Test)' % __name__) + self.assertEqual(str(error), + 'tearDownClass (%s.Test)' % __name__) def test_class_not_torndown_when_setup_fails(self): class Test(unittest2.TestCase): tornDown = False + @classmethod def setUpClass(cls): raise TypeError + @classmethod def tearDownClass(cls): Test.tornDown = True raise TypeError('foo') + def test_one(self): pass self.runTests(Test) self.assertFalse(Test.tornDown) - + def test_class_not_setup_or_torndown_when_skipped(self): class Test(unittest2.TestCase): classSetUp = False tornDown = False + @classmethod def setUpClass(cls): Test.classSetUp = True + @classmethod def tearDownClass(cls): Test.tornDown = True + def test_one(self): pass @@ -180,141 +208,169 @@ class TestSetups(unittest2.TestCase): def test_setup_teardown_order_with_pathological_suite(self): results = [] - + class Module1(object): + @staticmethod def setUpModule(): results.append('Module1.setUpModule') + @staticmethod def tearDownModule(): results.append('Module1.tearDownModule') - + class Module2(object): + @staticmethod def setUpModule(): results.append('Module2.setUpModule') + @staticmethod def tearDownModule(): results.append('Module2.tearDownModule') - + class Test1(unittest2.TestCase): + @classmethod def setUpClass(cls): results.append('setup 1') + @classmethod def tearDownClass(cls): results.append('teardown 1') + def testOne(self): results.append('Test1.testOne') + def testTwo(self): results.append('Test1.testTwo') - + class Test2(unittest2.TestCase): + @classmethod def setUpClass(cls): results.append('setup 2') + @classmethod def tearDownClass(cls): results.append('teardown 2') + def testOne(self): results.append('Test2.testOne') + def testTwo(self): results.append('Test2.testTwo') - + class Test3(unittest2.TestCase): + @classmethod def setUpClass(cls): results.append('setup 3') + @classmethod def tearDownClass(cls): results.append('teardown 3') + def testOne(self): results.append('Test3.testOne') + def testTwo(self): results.append('Test3.testTwo') - + Test1.__module__ = Test2.__module__ = 'Module' Test3.__module__ = 'Module2' sys.modules['Module'] = Module1 sys.modules['Module2'] = Module2 - + first = unittest2.TestSuite((Test1('testOne'),)) second = unittest2.TestSuite((Test1('testTwo'),)) third = unittest2.TestSuite((Test2('testOne'),)) fourth = unittest2.TestSuite((Test2('testTwo'),)) fifth = unittest2.TestSuite((Test3('testOne'),)) sixth = unittest2.TestSuite((Test3('testTwo'),)) - suite = unittest2.TestSuite((first, second, third, fourth, fifth, sixth)) - + suite = unittest2.TestSuite( + (first, second, third, fourth, fifth, sixth)) + runner = self.getRunner() result = runner.run(suite) self.assertEqual(result.testsRun, 6) self.assertEqual(len(result.errors), 0) self.assertEqual(results, - ['Module1.setUpModule', 'setup 1', + ['Module1.setUpModule', 'setup 1', 'Test1.testOne', 'Test1.testTwo', 'teardown 1', - 'setup 2', 'Test2.testOne', 'Test2.testTwo', + 'setup 2', 'Test2.testOne', 'Test2.testTwo', 'teardown 2', 'Module1.tearDownModule', 'Module2.setUpModule', 'setup 3', - 'Test3.testOne', 'Test3.testTwo', + 'Test3.testOne', 'Test3.testTwo', 'teardown 3', 'Module2.tearDownModule']) - + def test_setup_module(self): class Module(object): moduleSetup = 0 + @staticmethod def setUpModule(): Module.moduleSetup += 1 - + class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test) self.assertEqual(Module.moduleSetup, 1) self.assertEqual(result.testsRun, 2) self.assertEqual(len(result.errors), 0) - + def test_error_in_setup_module(self): class Module(object): moduleSetup = 0 moduleTornDown = 0 + @staticmethod def setUpModule(): Module.moduleSetup += 1 raise TypeError('foo') + @staticmethod def tearDownModule(): Module.moduleTornDown += 1 - + class Test(unittest2.TestCase): classSetUp = False classTornDown = False + @classmethod def setUpClass(cls): Test.classSetUp = True + @classmethod def tearDownClass(cls): Test.classTornDown = True + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' Test2.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test, Test2) self.assertEqual(Module.moduleSetup, 1) self.assertEqual(Module.moduleTornDown, 0) @@ -324,34 +380,39 @@ class TestSetups(unittest2.TestCase): self.assertEqual(len(result.errors), 1) error, _ = result.errors[0] self.assertEqual(str(error), 'setUpModule (Module)') - + def test_testcase_with_missing_module(self): class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' sys.modules.pop('Module', None) - + result = self.runTests(Test) self.assertEqual(result.testsRun, 2) def test_teardown_module(self): class Module(object): moduleTornDown = 0 + @staticmethod def tearDownModule(): Module.moduleTornDown += 1 - + class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test) self.assertEqual(Module.moduleTornDown, 1) self.assertEqual(result.testsRun, 2) @@ -360,34 +421,41 @@ class TestSetups(unittest2.TestCase): def test_error_in_teardown_module(self): class Module(object): moduleTornDown = 0 + @staticmethod def tearDownModule(): Module.moduleTornDown += 1 raise TypeError('foo') - + class Test(unittest2.TestCase): classSetUp = False classTornDown = False + @classmethod def setUpClass(cls): Test.classSetUp = True + @classmethod def tearDownClass(cls): Test.classTornDown = True + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' Test2.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test, Test2) self.assertEqual(Module.moduleTornDown, 1) self.assertEqual(result.testsRun, 4) @@ -399,11 +467,14 @@ class TestSetups(unittest2.TestCase): def test_skiptest_in_setupclass(self): class Test(unittest2.TestCase): + @classmethod def setUpClass(cls): raise unittest2.SkipTest('foo') + def test_one(self): pass + def test_two(self): pass @@ -416,12 +487,15 @@ class TestSetups(unittest2.TestCase): def test_skiptest_in_setupmodule(self): class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass class Module(object): + @staticmethod def setUpModule(): raise unittest2.SkipTest('foo') @@ -440,20 +514,25 @@ class TestSetups(unittest2.TestCase): ordering = [] class Module(object): + @staticmethod def setUpModule(): ordering.append('setUpModule') + @staticmethod def tearDownModule(): ordering.append('tearDownModule') class Test(unittest2.TestCase): + @classmethod def setUpClass(cls): ordering.append('setUpClass') + @classmethod def tearDownClass(cls): ordering.append('tearDownClass') + def test_something(self): ordering.append('test_something') @@ -462,29 +541,39 @@ class TestSetups(unittest2.TestCase): suite = unittest2.defaultTestLoader.loadTestsFromTestCase(Test) suite.debug() - expectedOrder = ['setUpModule', 'setUpClass', 'test_something', 'tearDownClass', 'tearDownModule'] + expectedOrder = [ + 'setUpModule', + 'setUpClass', + 'test_something', + 'tearDownClass', + 'tearDownModule'] self.assertEqual(ordering, expectedOrder) def test_suite_debug_propagates_exceptions(self): class Module(object): + @staticmethod def setUpModule(): if phase == 0: raise Exception('setUpModule') + @staticmethod def tearDownModule(): if phase == 1: raise Exception('tearDownModule') class Test(unittest2.TestCase): + @classmethod def setUpClass(cls): if phase == 2: raise Exception('setUpClass') + @classmethod def tearDownClass(cls): if phase == 3: raise Exception('tearDownClass') + def test_something(self): if phase == 4: raise Exception('test_something') @@ -494,9 +583,14 @@ class TestSetups(unittest2.TestCase): _suite = unittest2.defaultTestLoader.loadTestsFromTestCase(Test) suite = unittest2.TestSuite() - + # nesting a suite again exposes a bug in the initial implementation suite.addTest(_suite) - messages = ('setUpModule', 'tearDownModule', 'setUpClass', 'tearDownClass', 'test_something') + messages = ( + 'setUpModule', + 'tearDownModule', + 'setUpClass', + 'tearDownClass', + 'test_something') for phase, msg in enumerate(messages): self.assertRaisesRegexp(Exception, msg, suite.debug) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py index 9555b9ff770..6ad12e988cb 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py @@ -7,6 +7,7 @@ class Test_TestSkipping(unittest2.TestCase): def test_skipping(self): class Foo(unittest2.TestCase): + def test_skip_me(self): self.skipTest("skip") events = [] @@ -18,8 +19,10 @@ class Test_TestSkipping(unittest2.TestCase): # Try letting setUp skip the test now. class Foo(unittest2.TestCase): + def setUp(self): self.skipTest("testing") + def test_nothing(self): pass events = [] result = LoggingResult(events) @@ -34,14 +37,15 @@ class Test_TestSkipping(unittest2.TestCase): (unittest2.skipIf, True, False)) for deco, do_skip, dont_skip in op_table: class Foo(unittest2.TestCase): + @deco(do_skip, "testing") - def test_skip(self): + def test_skip(self): pass @deco(dont_skip, "testing") - def test_dont_skip(self): + def test_dont_skip(self): pass - + test_do_skip = Foo("test_skip") test_dont_skip = Foo("test_dont_skip") suite = unittest2.TestSuite([test_do_skip, test_dont_skip]) @@ -55,12 +59,13 @@ class Test_TestSkipping(unittest2.TestCase): self.assertEqual(result.testsRun, 2) self.assertEqual(result.skipped, [(test_do_skip, "testing")]) self.assertTrue(result.wasSuccessful()) - + def test_skip_class(self): class Foo(unittest2.TestCase): + def test_1(self): record.append(1) - + # was originally a class decorator... Foo = unittest2.skip("testing")(Foo) record = [] @@ -73,6 +78,7 @@ class Test_TestSkipping(unittest2.TestCase): def test_expected_failure(self): class Foo(unittest2.TestCase): + @unittest2.expectedFailure def test_die(self): self.fail("help me!") @@ -87,6 +93,7 @@ class Test_TestSkipping(unittest2.TestCase): def test_unexpected_success(self): class Foo(unittest2.TestCase): + @unittest2.expectedFailure def test_die(self): pass @@ -104,14 +111,17 @@ class Test_TestSkipping(unittest2.TestCase): class Foo(unittest2.TestCase): wasSetUp = False wasTornDown = False + def setUp(self): Foo.wasSetUp = True + def tornDown(self): Foo.wasTornDown = True + @unittest2.skip('testing') def test_1(self): pass - + result = unittest2.TestResult() test = Foo("test_1") suite = unittest2.TestSuite([test]) @@ -119,19 +129,20 @@ class Test_TestSkipping(unittest2.TestCase): self.assertEqual(result.skipped, [(test, "testing")]) self.assertFalse(Foo.wasSetUp) self.assertFalse(Foo.wasTornDown) - + def test_decorated_skip(self): def decorator(func): def inner(*a): return func(*a) return inner - + class Foo(unittest2.TestCase): + @decorator @unittest2.skip('testing') def test_1(self): pass - + result = unittest2.TestResult() test = Foo("test_1") suite = unittest2.TestSuite([test]) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py index 64a72bbdf14..570a9c6b17a 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py @@ -3,20 +3,27 @@ from unittest2.test.support import EqualityMixin, LoggingResult import sys import unittest2 + class Test(object): + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def test_3(self): pass + def runTest(self): pass + def _mk_TestSuite(*names): return unittest2.TestSuite(Test.Foo(n) for n in names) class Test_TestSuite(unittest2.TestCase, EqualityMixin): - ### Set up attributes needed by inherited tests + # Set up attributes needed by inherited tests ################################################################ # Used by EqualityMixin.test_eq @@ -31,9 +38,9 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): (_mk_TestSuite('test_1'), _mk_TestSuite('test_2'))] ################################################################ - ### /Set up attributes needed by inherited tests + # /Set up attributes needed by inherited tests - ### Tests for TestSuite.__init__ + # Tests for TestSuite.__init__ ################################################################ # "class TestSuite([tests])" @@ -93,7 +100,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): self.assertEqual(suite.countTestCases(), 2) ################################################################ - ### /Tests for TestSuite.__init__ + # /Tests for TestSuite.__init__ # Container types should support the iter protocol def test_iter(self): @@ -121,6 +128,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # TestSuite instances) returns 0? def test_countTestCases_zero_nested(self): class Test1(unittest2.TestCase): + def test(self): pass @@ -145,7 +153,9 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # Make sure this holds for nested TestSuite instances, too def test_countTestCases_nested(self): class Test1(unittest2.TestCase): + def test1(self): pass + def test2(self): pass test2 = unittest2.FunctionTestCase(lambda: None) @@ -188,10 +198,12 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): result = LoggingResult(events) class LoggingCase(unittest2.TestCase): + def run(self, result): events.append('run %s' % self._testMethodName) def test1(self): pass + def test2(self): pass tests = [LoggingCase('test1'), LoggingCase('test2')] @@ -203,6 +215,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # "Add a TestCase ... to the suite" def test_addTest__TestCase(self): class Foo(unittest2.TestCase): + def test(self): pass test = Foo('test') @@ -216,6 +229,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # "Add a ... TestSuite to the suite" def test_addTest__TestSuite(self): class Foo(unittest2.TestCase): + def test(self): pass suite_2 = unittest2.TestSuite([Foo('test')]) @@ -233,7 +247,9 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # each element" def test_addTests(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass test_1 = Foo('test_1') @@ -294,35 +310,41 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # when the bug is fixed this line will not crash suite.run(unittest2.TestResult()) - def test_basetestsuite(self): class Test(unittest2.TestCase): wasSetUp = False wasTornDown = False + @classmethod def setUpClass(cls): cls.wasSetUp = True + @classmethod def tearDownClass(cls): cls.wasTornDown = True + def testPass(self): pass + def testFail(self): fail + class Module(object): wasSetUp = False wasTornDown = False + @staticmethod def setUpModule(): Module.wasSetUp = True + @staticmethod def tearDownModule(): Module.wasTornDown = True - + Test.__module__ = 'Module' sys.modules['Module'] = Module self.addCleanup(sys.modules.pop, 'Module') - + suite = unittest2.BaseTestSuite() suite.addTests([Test('testPass'), Test('testFail')]) self.assertEqual(suite.countTestCases(), 2) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py index ddb88ace82a..6ebf6ce9c04 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py @@ -7,6 +7,7 @@ import warnings # needed to enable the deprecation warnings warnings.simplefilter('default') + class TestWith(unittest2.TestCase): """Tests that use the with statement live in this module so that all other tests can be run with Python 2.4. @@ -27,7 +28,6 @@ class TestWith(unittest2.TestCase): self.assertIsInstance(e, ExceptionMock) self.assertEqual(e.args[0], v) - def test_assertRaises(self): def _raise(e): raise e @@ -73,7 +73,8 @@ class TestWith(unittest2.TestCase): with catch_warnings(record=True): # This causes a UnicodeWarning due to its craziness one = ''.join(chr(i) for i in range(255)) - # this used to cause a UnicodeDecodeError constructing the failure msg + # this used to cause a UnicodeDecodeError constructing the failure + # msg with self.assertRaises(self.failureException): self.assertDictContainsSubset({'foo': one}, {'foo': u'\uFFFD'}) @@ -83,7 +84,7 @@ class TestWith(unittest2.TestCase): one = ''.join(chr(i) for i in range(255)) # this used to cause a UnicodeDecodeError constructing msg self._formatMessage(one, u'\uFFFD') - + def assertOldResultWarning(self, test, failures): with catch_warnings(record=True) as log: result = OldTestResult() @@ -94,31 +95,37 @@ class TestWith(unittest2.TestCase): def test_old_testresult(self): class Test(unittest2.TestCase): + def testSkip(self): self.skipTest('foobar') + @unittest2.expectedFailure def testExpectedFail(self): raise TypeError + @unittest2.expectedFailure def testUnexpectedSuccess(self): pass - - for test_name, should_pass in (('testSkip', True), - ('testExpectedFail', True), + + for test_name, should_pass in (('testSkip', True), + ('testExpectedFail', True), ('testUnexpectedSuccess', False)): test = Test(test_name) self.assertOldResultWarning(test, int(not should_pass)) - + def test_old_testresult_setup(self): class Test(unittest2.TestCase): + def setUp(self): self.skipTest('no reason') + def testFoo(self): pass self.assertOldResultWarning(Test('testFoo'), 0) - + def test_old_testresult_class(self): class Test(unittest2.TestCase): + def testFoo(self): pass Test = unittest2.skip('no reason')(Test) |
