diff options
Diffstat (limited to 'lldb/third_party/Python/module/unittest2')
27 files changed, 1237 insertions, 620 deletions
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/__init__.py b/lldb/third_party/Python/module/unittest2/unittest2/__init__.py index 8ec6c7a478a..14fea5a2599 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/__init__.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/__init__.py @@ -34,7 +34,7 @@ if sys.version_info[0] >= 3: else: cmp_ = cmp -reversed_cmp_ = lambda x, y: -cmp_(x,y) +reversed_cmp_ = lambda x, y: -cmp_(x, y) __all__ = ['TestResult', 'TestCase', 'TestSuite', 'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main', @@ -69,7 +69,7 @@ except ImportError: # Compatibility with platforms that don't have the signal module pass else: - __all__.extend(['installHandler', 'registerResult', 'removeResult', + __all__.extend(['installHandler', 'registerResult', 'removeResult', 'removeHandler']) # deprecated diff --git a/lldb/third_party/Python/module/unittest2/unittest2/case.py b/lldb/third_party/Python/module/unittest2/unittest2/case.py index de7cb6a71e9..7d6c54eff96 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/case.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/case.py @@ -21,7 +21,8 @@ __unittest = True DIFF_OMITTED = ('\nDiff is %s characters long. ' - 'Set self.maxDiff to None to see it.') + 'Set self.maxDiff to None to see it.') + class SkipTest(Exception): """ @@ -31,6 +32,7 @@ class SkipTest(Exception): instead of raising this directly. """ + class _ExpectedFailure(Exception): """ Raise this when a test is expected to fail. @@ -44,6 +46,7 @@ class _ExpectedFailure(Exception): self.exc_info = exc_info self.bugnumber = bugnumber + class _UnexpectedSuccess(Exception): """ The test was supposed to fail, but it didn't! @@ -55,25 +58,33 @@ class _UnexpectedSuccess(Exception): self.exc_info = exc_info self.bugnumber = bugnumber + def _id(obj): return obj + def skip(reason): """ Unconditionally skip a test. """ def decorator(test_item): - if not (isinstance(test_item, type) and issubclass(test_item, TestCase)): + if not ( + isinstance( + test_item, + type) and issubclass( + test_item, + TestCase)): @wraps(test_item) def skip_wrapper(*args, **kwargs): raise SkipTest(reason) test_item = skip_wrapper - + test_item.__unittest_skip__ = True test_item.__unittest_skip_why__ = reason return test_item return decorator + def skipIf(condition, reason): """ Skip a test if the condition is true. @@ -82,6 +93,7 @@ def skipIf(condition, reason): return skip(reason) return _id + def skipUnless(condition, reason): """ Skip a test unless the condition is true. @@ -90,28 +102,30 @@ def skipUnless(condition, reason): return skip(reason) return _id + def expectedFailure(bugnumber=None): - if callable(bugnumber): + if callable(bugnumber): @wraps(bugnumber) def expectedFailure_easy_wrapper(*args, **kwargs): - try: + try: bugnumber(*args, **kwargs) - except Exception: - raise _ExpectedFailure(sys.exc_info(),None) - raise _UnexpectedSuccess(sys.exc_info(),None) + except Exception: + raise _ExpectedFailure(sys.exc_info(), None) + raise _UnexpectedSuccess(sys.exc_info(), None) return expectedFailure_easy_wrapper - else: + else: def expectedFailure_impl(func): - @wraps(func) - def wrapper(*args, **kwargs): - try: - func(*args, **kwargs) - except Exception: - raise _ExpectedFailure(sys.exc_info(),bugnumber) - raise _UnexpectedSuccess(sys.exc_info(),bugnumber) - return wrapper + @wraps(func) + def wrapper(*args, **kwargs): + try: + func(*args, **kwargs) + except Exception: + raise _ExpectedFailure(sys.exc_info(), bugnumber) + raise _UnexpectedSuccess(sys.exc_info(), bugnumber) + return wrapper return expectedFailure_impl + class _AssertRaisesContext(object): """A context manager used to implement TestCase.assertRaises* methods.""" @@ -134,7 +148,7 @@ class _AssertRaisesContext(object): if not issubclass(exc_type, self.expected): # let unexpected exceptions pass through return False - self.exception = exc_value # store for later retrieval + self.exception = exc_value # store for later retrieval if self.expected_regexp is None: return True @@ -142,26 +156,27 @@ class _AssertRaisesContext(object): if isinstance(expected_regexp, six.string_types): expected_regexp = re.compile(expected_regexp) if not expected_regexp.search(str(exc_value)): - raise self.failureException('"%s" does not match "%s"' % - (expected_regexp.pattern, str(exc_value))) + raise self.failureException( + '"%s" does not match "%s"' % + (expected_regexp.pattern, str(exc_value))) return True class _TypeEqualityDict(object): - + def __init__(self, testcase): self.testcase = testcase self._store = {} - + def __setitem__(self, key, value): self._store[key] = value - + def __getitem__(self, key): value = self._store[key] if isinstance(value, six.string_types): return getattr(self.testcase, value) return value - + def get(self, key, default=None): if key in self._store: return self[key] @@ -200,16 +215,16 @@ class TestCase(unittest.TestCase): # by assert methods using difflib. It is looked up as an instance attribute # so can be configured by individual tests if required. - maxDiff = 80*8 + maxDiff = 80 * 8 # This attribute determines whether long messages (including repr of # objects used in assert methods) will be printed on failure in *addition* # to any explicit message passed. longMessage = True - + # Attribute used by TestSuite for classSetUp - + _classSetupFailed = False def __init__(self, methodName='runTest'): @@ -222,8 +237,8 @@ class TestCase(unittest.TestCase): try: testMethod = getattr(self, methodName) except AttributeError: - raise ValueError("no such test method in %s: %s" % \ - (self.__class__, methodName)) + raise ValueError("no such test method in %s: %s" % + (self.__class__, methodName)) self._testMethodDoc = testMethod.__doc__ self._cleanups = [] @@ -266,7 +281,7 @@ class TestCase(unittest.TestCase): def setUp(self): "Hook method for setting up the test fixture before exercising it." - + @classmethod def setUpClass(cls): "Hook method for setting up class fixture before running tests in the class." @@ -294,12 +309,11 @@ class TestCase(unittest.TestCase): doc = self._testMethodDoc return doc and doc.split("\n")[0].strip() or None - def id(self): return "%s.%s" % (strclass(self.__class__), self._testMethodName) def __eq__(self, other): - if type(self) is not type(other): + if not isinstance(self, type(other)): return NotImplemented return self._testMethodName == other._testMethodName @@ -316,14 +330,16 @@ class TestCase(unittest.TestCase): def __repr__(self): return "<%s testMethod=%s>" % \ (strclass(self.__class__), self._testMethodName) - + def _addSkip(self, result, reason): addSkip = getattr(result, 'addSkip', None) if addSkip is not None: addSkip(self, reason) else: - warnings.warn("Use of a TestResult without an addSkip method is deprecated", - DeprecationWarning, 2) + warnings.warn( + "Use of a TestResult without an addSkip method is deprecated", + DeprecationWarning, + 2) result.addSuccess(self) def run(self, result=None): @@ -336,15 +352,21 @@ class TestCase(unittest.TestCase): self._resultForDoCleanups = result result.startTest(self) - + testMethod = getattr(self, self._testMethodName) - - if (getattr(self.__class__, "__unittest_skip__", False) or - getattr(testMethod, "__unittest_skip__", False)): + + if (getattr(self.__class__, "__unittest_skip__", False) or + getattr(testMethod, "__unittest_skip__", False)): # If the class or method was skipped. try: - skip_why = (getattr(self.__class__, '__unittest_skip_why__', '') - or getattr(testMethod, '__unittest_skip_why__', '')) + skip_why = ( + getattr( + self.__class__, + '__unittest_skip_why__', + '') or getattr( + testMethod, + '__unittest_skip_why__', + '')) self._addSkip(result, skip_why) finally: result.stopTest(self) @@ -396,16 +418,19 @@ class TestCase(unittest.TestCase): if addExpectedFailure is not None: addExpectedFailure(self, e.exc_info, e.bugnumber) else: - warnings.warn("Use of a TestResult without an addExpectedFailure method is deprecated", - DeprecationWarning) + warnings.warn( + "Use of a TestResult without an addExpectedFailure method is deprecated", + DeprecationWarning) result.addSuccess(self) except _UnexpectedSuccess as x: - addUnexpectedSuccess = getattr(result, 'addUnexpectedSuccess', None) + addUnexpectedSuccess = getattr( + result, 'addUnexpectedSuccess', None) if addUnexpectedSuccess is not None: addUnexpectedSuccess(self, x.bugnumber) else: - warnings.warn("Use of a TestResult without an addUnexpectedSuccess method is deprecated", - DeprecationWarning) + warnings.warn( + "Use of a TestResult without an addUnexpectedSuccess method is deprecated", + DeprecationWarning) result.addFailure(self, sys.exc_info()) except SkipTest as e: self._addSkip(result, str(e)) @@ -480,7 +505,6 @@ class TestCase(unittest.TestCase): except UnicodeDecodeError: return '%s : %s' % (safe_str(standardMsg), safe_str(msg)) - def assertRaises(self, excClass, callableObj=None, *args, **kwargs): """Fail unless an exception of class excClass is thrown by callableObj when invoked with arguments args and keyword @@ -510,8 +534,8 @@ class TestCase(unittest.TestCase): callableObj(*args, **kwargs) except excClass: return - - if hasattr(excClass,'__name__'): + + if hasattr(excClass, '__name__'): excName = excClass.__name__ else: excName = str(excClass) @@ -534,7 +558,7 @@ class TestCase(unittest.TestCase): # subclasses if the detailed comparison is desired and appropriate. # See the discussion in http://bugs.python.org/issue2578. # - if type(first) is type(second): + if isinstance(first, type(second)): asserter = self._type_equality_funcs.get(type(first)) if asserter is not None: return asserter @@ -560,11 +584,17 @@ class TestCase(unittest.TestCase): operator. """ if not first != second: - msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first), - safe_repr(second))) + msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first), + safe_repr(second))) raise self.failureException(msg) - def assertAlmostEqual(self, first, second, places=None, msg=None, delta=None): + def assertAlmostEqual( + self, + first, + second, + places=None, + msg=None, + delta=None): """Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the @@ -581,28 +611,34 @@ class TestCase(unittest.TestCase): return if delta is not None and places is not None: raise TypeError("specify delta or places not both") - + if delta is not None: if abs(first - second) <= delta: return - - standardMsg = '%s != %s within %s delta' % (safe_repr(first), - safe_repr(second), + + standardMsg = '%s != %s within %s delta' % (safe_repr(first), + safe_repr(second), safe_repr(delta)) else: if places is None: places = 7 - - if round(abs(second-first), places) == 0: + + if round(abs(second - first), places) == 0: return - - standardMsg = '%s != %s within %r places' % (safe_repr(first), - safe_repr(second), - places) + + standardMsg = '%s != %s within %r places' % (safe_repr(first), + safe_repr(second), + places) msg = self._formatMessage(msg, standardMsg) raise self.failureException(msg) - def assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None): + def assertNotAlmostEqual( + self, + first, + second, + places=None, + msg=None, + delta=None): """Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the @@ -618,15 +654,16 @@ class TestCase(unittest.TestCase): if delta is not None: if not (first == second) and abs(first - second) > delta: return - standardMsg = '%s == %s within %s delta' % (safe_repr(first), + standardMsg = '%s == %s within %s delta' % (safe_repr(first), safe_repr(second), safe_repr(delta)) else: if places is None: places = 7 - if not (first == second) and round(abs(second-first), places) != 0: + if not (first == second) and round( + abs(second - first), places) != 0: return - standardMsg = '%s == %s within %r places' % (safe_repr(first), + standardMsg = '%s == %s within %r places' % (safe_repr(first), safe_repr(second), places) @@ -663,7 +700,7 @@ class TestCase(unittest.TestCase): failIf = _deprecate(assertFalse) def assertSequenceEqual(self, seq1, seq2, - msg=None, seq_type=None, max_diff=80*8): + msg=None, seq_type=None, max_diff=80 * 8): """An equality assertion for ordered sequences (like lists and tuples). For the purposes of this function, a valid ordered sequence type is one @@ -694,14 +731,14 @@ class TestCase(unittest.TestCase): len1 = len(seq1) except (TypeError, NotImplementedError): differing = 'First %s has no length. Non-sequence?' % ( - seq_type_name) + seq_type_name) if differing is None: try: len2 = len(seq2) except (TypeError, NotImplementedError): differing = 'Second %s has no length. Non-sequence?' % ( - seq_type_name) + seq_type_name) if differing is None: if seq1 == seq2: @@ -721,29 +758,29 @@ class TestCase(unittest.TestCase): item1 = seq1[i] except (TypeError, IndexError, NotImplementedError): differing += ('\nUnable to index element %d of first %s\n' % - (i, seq_type_name)) + (i, seq_type_name)) break try: item2 = seq2[i] except (TypeError, IndexError, NotImplementedError): differing += ('\nUnable to index element %d of second %s\n' % - (i, seq_type_name)) + (i, seq_type_name)) break if item1 != item2: differing += ('\nFirst differing element %d:\n%s\n%s\n' % - (i, item1, item2)) + (i, item1, item2)) break else: if (len1 == len2 and seq_type is None and - type(seq1) != type(seq2)): + not isinstance(seq1, type(seq2))): # The sequences are the same, but have differing types. return if len1 > len2: differing += ('\nFirst %s contains %d additional ' - 'elements.\n' % (seq_type_name, len1 - len2)) + 'elements.\n' % (seq_type_name, len1 - len2)) try: differing += ('First extra element %d:\n%s\n' % (len2, seq1[len2])) @@ -752,7 +789,7 @@ class TestCase(unittest.TestCase): 'of first %s\n' % (len2, seq_type_name)) elif len1 < len2: differing += ('\nSecond %s contains %d additional ' - 'elements.\n' % (seq_type_name, len2 - len1)) + 'elements.\n' % (seq_type_name, len2 - len1)) try: differing += ('First extra element %d:\n%s\n' % (len1, seq2[len1])) @@ -822,7 +859,9 @@ class TestCase(unittest.TestCase): except TypeError as e: self.fail('invalid type when attempting set difference: %s' % e) except AttributeError as e: - self.fail('second argument does not support set difference: %s' % e) + self.fail( + 'second argument does not support set difference: %s' % + e) if not (difference1 or difference2): return @@ -843,15 +882,15 @@ class TestCase(unittest.TestCase): def assertIn(self, member, container, msg=None): """Just like self.assertTrue(a in b), but with a nicer default message.""" if member not in container: - standardMsg = '%s not found in %s' % (safe_repr(member), - safe_repr(container)) + standardMsg = '%s not found in %s' % (safe_repr(member), + safe_repr(container)) self.fail(self._formatMessage(msg, standardMsg)) def assertNotIn(self, member, container, msg=None): """Just like self.assertTrue(a not in b), but with a nicer default message.""" if member in container: - standardMsg = '%s unexpectedly found in %s' % (safe_repr(member), - safe_repr(container)) + standardMsg = '%s unexpectedly found in %s' % ( + safe_repr(member), safe_repr(container)) self.fail(self._formatMessage(msg, standardMsg)) def assertIs(self, expr1, expr2, msg=None): @@ -867,11 +906,20 @@ class TestCase(unittest.TestCase): self.fail(self._formatMessage(msg, standardMsg)) def assertDictEqual(self, d1, d2, msg=None): - self.assert_(isinstance(d1, dict), 'First argument is not a dictionary') - self.assert_(isinstance(d2, dict), 'Second argument is not a dictionary') + self.assert_( + isinstance( + d1, + dict), + 'First argument is not a dictionary') + self.assert_( + isinstance( + d2, + dict), + 'Second argument is not a dictionary') if d1 != d2: - standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True)) + standardMsg = '%s != %s' % ( + safe_repr(d1, True), safe_repr(d2, True)) diff = ('\n' + '\n'.join(difflib.ndiff( pprint.pformat(d1).splitlines(), pprint.pformat(d2).splitlines()))) @@ -887,7 +935,7 @@ class TestCase(unittest.TestCase): missing.append(key) elif value != actual[key]: mismatched.append('%s, expected: %s, actual: %s' % - (safe_repr(key), safe_repr(value), + (safe_repr(key), safe_repr(value), safe_repr(actual[key]))) if not (missing or mismatched): @@ -895,8 +943,8 @@ class TestCase(unittest.TestCase): standardMsg = '' if missing: - standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in - missing) + standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in + missing) if mismatched: if standardMsg: standardMsg += '; ' @@ -908,12 +956,12 @@ class TestCase(unittest.TestCase): """An unordered sequence specific comparison. It asserts that expected_seq and actual_seq contain the same elements. It is the equivalent of:: - + self.assertEqual(sorted(expected_seq), sorted(actual_seq)) Raises with an error message listing which elements of expected_seq are missing from actual_seq and vice versa if any. - + Asserts that each element has the same count in both sequences. Example: - [0, 1, 1] and [1, 0, 1] compare equal. @@ -934,11 +982,11 @@ class TestCase(unittest.TestCase): errors = [] if missing: - errors.append('Expected, but missing:\n %s' % - safe_repr(missing)) + errors.append('Expected, but missing:\n %s' % + safe_repr(missing)) if unexpected: - errors.append('Unexpected, but present:\n %s' % - safe_repr(unexpected)) + errors.append('Unexpected, but present:\n %s' % + safe_repr(unexpected)) if errors: standardMsg = '\n'.join(errors) self.fail(self._formatMessage(msg, standardMsg)) @@ -946,14 +994,15 @@ class TestCase(unittest.TestCase): def assertMultiLineEqual(self, first, second, msg=None): """Assert that two multi-line strings are equal.""" self.assert_(isinstance(first, six.string_types), ( - 'First argument is not a string')) + 'First argument is not a string')) self.assert_(isinstance(second, six.string_types), ( - 'Second argument is not a string')) + 'Second argument is not a string')) if first != second: - standardMsg = '%s != %s' % (safe_repr(first, True), safe_repr(second, True)) + standardMsg = '%s != %s' % ( + safe_repr(first, True), safe_repr(second, True)) diff = '\n' + ''.join(difflib.ndiff(first.splitlines(True), - second.splitlines(True))) + second.splitlines(True))) standardMsg = self._truncateMessage(standardMsg, diff) self.fail(self._formatMessage(msg, standardMsg)) @@ -966,19 +1015,22 @@ class TestCase(unittest.TestCase): def assertLessEqual(self, a, b, msg=None): """Just like self.assertTrue(a <= b), but with a nicer default message.""" if not a <= b: - standardMsg = '%s not less than or equal to %s' % (safe_repr(a), safe_repr(b)) + standardMsg = '%s not less than or equal to %s' % ( + safe_repr(a), safe_repr(b)) self.fail(self._formatMessage(msg, standardMsg)) def assertGreater(self, a, b, msg=None): """Just like self.assertTrue(a > b), but with a nicer default message.""" if not a > b: - standardMsg = '%s not greater than %s' % (safe_repr(a), safe_repr(b)) + standardMsg = '%s not greater than %s' % ( + safe_repr(a), safe_repr(b)) self.fail(self._formatMessage(msg, standardMsg)) def assertGreaterEqual(self, a, b, msg=None): """Just like self.assertTrue(a >= b), but with a nicer default message.""" if not a >= b: - standardMsg = '%s not greater than or equal to %s' % (safe_repr(a), safe_repr(b)) + standardMsg = '%s not greater than or equal to %s' % ( + safe_repr(a), safe_repr(b)) self.fail(self._formatMessage(msg, standardMsg)) def assertIsNone(self, obj, msg=None): @@ -1019,30 +1071,32 @@ class TestCase(unittest.TestCase): kwargs: Extra kwargs. """ if callable_obj is None: - return _AssertRaisesContext(expected_exception, self, expected_regexp) + return _AssertRaisesContext( + expected_exception, self, expected_regexp) try: callable_obj(*args, **kwargs) except expected_exception as exc_value: if isinstance(expected_regexp, six.string_types): expected_regexp = re.compile(expected_regexp) if not expected_regexp.search(str(exc_value)): - raise self.failureException('"%s" does not match "%s"' % - (expected_regexp.pattern, str(exc_value))) + raise self.failureException( + '"%s" does not match "%s"' % + (expected_regexp.pattern, str(exc_value))) else: - if hasattr(expected_exception, '__name__'): + if hasattr(expected_exception, '__name__'): excName = expected_exception.__name__ - else: + else: excName = str(expected_exception) raise self.failureException("%s not raised" % excName) - def assertRegexpMatches(self, text, expected_regexp, msg=None): """Fail the test unless the text matches the regular expression.""" if isinstance(expected_regexp, six.string_types): expected_regexp = re.compile(expected_regexp) if not expected_regexp.search(text): msg = msg or "Regexp didn't match" - msg = '%s: %r not found in %r' % (msg, expected_regexp.pattern, text) + msg = '%s: %r not found in %r' % ( + msg, expected_regexp.pattern, text) raise self.failureException(msg) def assertNotRegexpMatches(self, text, unexpected_regexp, msg=None): @@ -1058,6 +1112,7 @@ class TestCase(unittest.TestCase): text) raise self.failureException(msg) + class FunctionTestCase(TestCase): """A test case that wraps a test function. @@ -1093,9 +1148,9 @@ class FunctionTestCase(TestCase): return NotImplemented return self._setUpFunc == other._setUpFunc and \ - self._tearDownFunc == other._tearDownFunc and \ - self._testFunc == other._testFunc and \ - self._description == other._description + self._tearDownFunc == other._tearDownFunc and \ + self._testFunc == other._testFunc and \ + self._description == other._description def __ne__(self, other): return not self == other diff --git a/lldb/third_party/Python/module/unittest2/unittest2/collector.py b/lldb/third_party/Python/module/unittest2/unittest2/collector.py index 28ff3f89ce7..b9013e88888 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/collector.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/collector.py @@ -2,6 +2,7 @@ import os import sys from unittest2.loader import defaultTestLoader + def collector(): # import __main__ triggers code re-execution __main__ = sys.modules['__main__'] diff --git a/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py b/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py index b8f15dd1428..3adcdc4b35b 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py @@ -12,6 +12,7 @@ except ImportError: __unittest = True + def _relpath_nt(path, start=os.path.curdir): """Return a relative version of a path""" @@ -24,10 +25,10 @@ def _relpath_nt(path, start=os.path.curdir): unc_start, rest = os.path.splitunc(start) if bool(unc_path) ^ bool(unc_start): raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)" - % (path, start)) + % (path, start)) else: raise ValueError("path is on drive %s, start on drive %s" - % (path_list[0], start_list[0])) + % (path_list[0], start_list[0])) # Work out how much of the filepath is shared by start and path. for i in range(min(len(start_list), len(path_list))): if start_list[i].lower() != path_list[i].lower(): @@ -35,25 +36,27 @@ def _relpath_nt(path, start=os.path.curdir): else: i += 1 - rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:] + rel_list = [os.path.pardir] * (len(start_list) - i) + path_list[i:] if not rel_list: return os.path.curdir return os.path.join(*rel_list) # default to posixpath definition + + def _relpath_posix(path, start=os.path.curdir): """Return a relative version of a path""" if not path: raise ValueError("no path specified") - + start_list = os.path.abspath(start).split(os.path.sep) path_list = os.path.abspath(path).split(os.path.sep) # Work out how much of the filepath is shared by start and path. i = len(os.path.commonprefix([start_list, path_list])) - rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:] + rel_list = [os.path.pardir] * (len(start_list) - i) + path_list[i:] if not rel_list: return os.path.curdir return os.path.join(*rel_list) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/loader.py b/lldb/third_party/Python/module/unittest2/unittest2/loader.py index fe86db1e475..996dd766475 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/loader.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/loader.py @@ -34,16 +34,18 @@ def _make_failed_import_test(name, suiteClass): return _make_failed_test('ModuleImportFailure', name, ImportError(message), suiteClass) + def _make_failed_load_tests(name, exception, suiteClass): return _make_failed_test('LoadTestsFailure', name, exception, suiteClass) + def _make_failed_test(classname, methodname, exception, suiteClass): def testFailure(self): raise exception attrs = {methodname: testFailure} TestClass = type(classname, (case.TestCase,), attrs) return suiteClass((TestClass(methodname),)) - + class TestLoader(unittest.TestLoader): """ @@ -149,7 +151,9 @@ class TestLoader(unittest.TestLoader): hasattr(getattr(testCaseClass, attrname), '__call__') testFnNames = list(filter(isTestMethod, dir(testCaseClass))) if self.sortTestMethodsUsing: - testFnNames.sort(key=functools.cmp_to_key(self.sortTestMethodsUsing)) + testFnNames.sort( + key=functools.cmp_to_key( + self.sortTestMethodsUsing)) return testFnNames def discover(self, start_dir, pattern='test*.py', top_level_dir=None): @@ -175,7 +179,8 @@ class TestLoader(unittest.TestLoader): """ set_implicit_top = False if top_level_dir is None and self._top_level_dir is not None: - # make top_level_dir optional if called from load_tests in a package + # make top_level_dir optional if called from load_tests in a + # package top_level_dir = self._top_level_dir elif top_level_dir is None: set_implicit_top = True @@ -183,7 +188,7 @@ class TestLoader(unittest.TestLoader): top_level_dir = os.path.abspath(top_level_dir) - if not top_level_dir in sys.path: + if top_level_dir not in sys.path: # all test modules must be importable from the top level directory # should we *unconditionally* put the start directory in first # in sys.path to minimise likelihood of conflicts between installed @@ -195,7 +200,8 @@ class TestLoader(unittest.TestLoader): if os.path.isdir(os.path.abspath(start_dir)): start_dir = os.path.abspath(start_dir) if start_dir != top_level_dir: - is_not_importable = not os.path.isfile(os.path.join(start_dir, '__init__.py')) + is_not_importable = not os.path.isfile( + os.path.join(start_dir, '__init__.py')) else: # support for discovery from dotted module names try: @@ -205,13 +211,17 @@ class TestLoader(unittest.TestLoader): else: the_module = sys.modules[start_dir] top_part = start_dir.split('.')[0] - start_dir = os.path.abspath(os.path.dirname((the_module.__file__))) + start_dir = os.path.abspath( + os.path.dirname((the_module.__file__))) if set_implicit_top: - self._top_level_dir = os.path.abspath(os.path.dirname(os.path.dirname(sys.modules[top_part].__file__))) + self._top_level_dir = os.path.abspath(os.path.dirname( + os.path.dirname(sys.modules[top_part].__file__))) sys.path.remove(top_level_dir) if is_not_importable: - raise ImportError('Start directory is not importable: %r' % start_dir) + raise ImportError( + 'Start directory is not importable: %r' % + start_dir) tests = list(self._find_tests(start_dir, pattern)) return self.suiteClass(tests) @@ -233,7 +243,7 @@ class TestLoader(unittest.TestLoader): def _match_path(self, path, full_path, pattern): # override this method to use alternative matching strategy return fnmatch(path, pattern) - + def _find_tests(self, start_dir, pattern): """Used by discovery. Yields test suites it loads.""" paths = os.listdir(start_dir) @@ -253,16 +263,20 @@ class TestLoader(unittest.TestLoader): except: yield _make_failed_import_test(name, self.suiteClass) else: - mod_file = os.path.abspath(getattr(module, '__file__', full_path)) + mod_file = os.path.abspath( + getattr(module, '__file__', full_path)) realpath = os.path.splitext(mod_file)[0] fullpath_noext = os.path.splitext(full_path)[0] if realpath.lower() != fullpath_noext.lower(): module_dir = os.path.dirname(realpath) - mod_name = os.path.splitext(os.path.basename(full_path))[0] + mod_name = os.path.splitext( + os.path.basename(full_path))[0] expected_dir = os.path.dirname(full_path) - msg = ("%r module incorrectly imported from %r. Expected %r. " - "Is this module globally installed?") - raise ImportError(msg % (mod_name, module_dir, expected_dir)) + msg = ( + "%r module incorrectly imported from %r. Expected %r. " + "Is this module globally installed?") + raise ImportError(msg % + (mod_name, module_dir, expected_dir)) yield self.loadTestsFromModule(module) elif os.path.isdir(full_path): if not os.path.isfile(os.path.join(full_path, '__init__.py')): @@ -271,11 +285,13 @@ class TestLoader(unittest.TestLoader): load_tests = None tests = None if fnmatch(path, pattern): - # only check load_tests if the package directory itself matches the filter + # only check load_tests if the package directory itself + # matches the filter name = self._get_name_from_path(full_path) package = self._get_module_from_name(name) load_tests = getattr(package, 'load_tests', None) - tests = self.loadTestsFromModule(package, use_load_tests=False) + tests = self.loadTestsFromModule( + package, use_load_tests=False) if load_tests is None: if tests is not None: @@ -302,13 +318,22 @@ def _makeLoader(prefix, sortUsing, suiteClass=None): loader.suiteClass = suiteClass return loader + def getTestCaseNames(testCaseClass, prefix, sortUsing=cmp_): return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass) + def makeSuite(testCaseClass, prefix='test', sortUsing=cmp_, suiteClass=suite.TestSuite): - return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(testCaseClass) + return _makeLoader( + prefix, + sortUsing, + suiteClass).loadTestsFromTestCase(testCaseClass) + def findTestCases(module, prefix='test', sortUsing=cmp_, suiteClass=suite.TestSuite): - return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(module) + return _makeLoader( + prefix, + sortUsing, + suiteClass).loadTestsFromModule(module) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/main.py b/lldb/third_party/Python/module/unittest2/unittest2/main.py index d74b01f9ac2..76e3e7323a8 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/main.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/main.py @@ -13,8 +13,8 @@ except ImportError: __unittest = True -FAILFAST = " -f, --failfast Stop on first failure\n" -CATCHBREAK = " -c, --catch Catch control-C and display results\n" +FAILFAST = " -f, --failfast Stop on first failure\n" +CATCHBREAK = " -c, --catch Catch control-C and display results\n" BUFFEROUTPUT = " -b, --buffer Buffer stdout and stderr during test runs\n" USAGE_AS_MAIN = """\ @@ -69,7 +69,7 @@ class TestProgram(object): for making test modules conveniently executable. """ USAGE = USAGE_FROM_MODULE - + # defaults for testing failfast = catchbreak = buffer = progName = None @@ -103,11 +103,11 @@ class TestProgram(object): print(msg) usage = {'progName': self.progName, 'catchbreak': '', 'failfast': '', 'buffer': ''} - if self.failfast != False: + if self.failfast: usage['failfast'] = FAILFAST - if self.catchbreak != False and installHandler is not None: + if self.catchbreak and installHandler is not None: usage['catchbreak'] = CATCHBREAK - if self.buffer != False: + if self.buffer: usage['buffer'] = BUFFEROUTPUT print(self.USAGE % usage) sys.exit(2) @@ -122,21 +122,21 @@ class TestProgram(object): try: options, args = getopt.getopt(argv[1:], 'hHvqfcb', long_opts) for opt, value in options: - if opt in ('-h','-H','--help'): + if opt in ('-h', '-H', '--help'): self.usageExit() - if opt in ('-q','--quiet'): + if opt in ('-q', '--quiet'): self.verbosity = 0 - if opt in ('-v','--verbose'): + if opt in ('-v', '--verbose'): self.verbosity = 2 - if opt in ('-f','--failfast'): + if opt in ('-f', '--failfast'): if self.failfast is None: self.failfast = True # Should this raise an exception if -f is not valid? - if opt in ('-c','--catch'): + if opt in ('-c', '--catch'): if self.catchbreak is None and installHandler is not None: self.catchbreak = True # Should this raise an exception if -c is not valid? - if opt in ('-b','--buffer'): + if opt in ('-b', '--buffer'): if self.buffer is None: self.buffer = True # Should this raise an exception if -b is not valid? @@ -169,24 +169,40 @@ class TestProgram(object): parser.prog = self.progName parser.add_option('-v', '--verbose', dest='verbose', default=False, help='Verbose output', action='store_true') - if self.failfast != False: - parser.add_option('-f', '--failfast', dest='failfast', default=False, - help='Stop on first fail or error', - action='store_true') - if self.catchbreak != False and installHandler is not None: - parser.add_option('-c', '--catch', dest='catchbreak', default=False, - help='Catch ctrl-C and display results so far', - action='store_true') - if self.buffer != False: + if self.failfast: + parser.add_option( + '-f', + '--failfast', + dest='failfast', + default=False, + help='Stop on first fail or error', + action='store_true') + if self.catchbreak and installHandler is not None: + parser.add_option( + '-c', + '--catch', + dest='catchbreak', + default=False, + help='Catch ctrl-C and display results so far', + action='store_true') + if self.buffer: parser.add_option('-b', '--buffer', dest='buffer', default=False, - help='Buffer stdout and stderr during tests', + help='Buffer stdout and stderr during tests', action='store_true') parser.add_option('-s', '--start-directory', dest='start', default='.', help="Directory to start discovery ('.' default)") - parser.add_option('-p', '--pattern', dest='pattern', default='test*.py', - help="Pattern to match tests ('test*.py' default)") - parser.add_option('-t', '--top-level-directory', dest='top', default=None, - help='Top level directory of project (defaults to start directory)') + parser.add_option( + '-p', + '--pattern', + dest='pattern', + default='test*.py', + help="Pattern to match tests ('test*.py' default)") + parser.add_option( + '-t', + '--top-level-directory', + dest='top', + default=None, + help='Top level directory of project (defaults to start directory)') options, args = parser.parse_args(argv) if len(args) > 3: @@ -194,7 +210,7 @@ class TestProgram(object): for name, value in zip(('start', 'pattern', 'top'), args): setattr(options, name, value) - + # only set options from the parsing here # if they weren't set explicitly in the constructor if self.failfast is None: @@ -203,7 +219,7 @@ class TestProgram(object): self.catchbreak = options.catchbreak if self.buffer is None: self.buffer = options.buffer - + if options.verbose: self.verbosity = 2 @@ -236,7 +252,7 @@ class TestProgram(object): main = TestProgram + def main_(): TestProgram.USAGE = USAGE_AS_MAIN main(module=None) - diff --git a/lldb/third_party/Python/module/unittest2/unittest2/result.py b/lldb/third_party/Python/module/unittest2/unittest2/result.py index 2e4994d1d82..9d76429fb4a 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/result.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/result.py @@ -13,6 +13,7 @@ from unittest2.compatibility import wraps __unittest = True + def failfast(method): @wraps(method) def inner(self, *args, **kw): @@ -25,6 +26,7 @@ def failfast(method): STDOUT_LINE = '\nStdout:\n%s' STDERR_LINE = '\nStderr:\n%s' + class TestResult(unittest.TestResult): """Holder for test result information. @@ -38,7 +40,7 @@ class TestResult(unittest.TestResult): """ _previousTestClass = None _moduleSetUpFailed = False - + def __init__(self): self.failfast = False self.failures = [] @@ -56,7 +58,7 @@ class TestResult(unittest.TestResult): self._original_stdout = sys.stdout self._original_stderr = sys.stderr self._mirrorOutput = False - + def startTest(self, test): "Called when the given test is about to be run" self.testsRun += 1 @@ -88,7 +90,7 @@ class TestResult(unittest.TestResult): if not error.endswith('\n'): error += '\n' self._original_stderr.write(STDERR_LINE % error) - + sys.stdout = self._original_stdout sys.stderr = self._original_stderr self._stdout_buffer.seek(0) @@ -96,7 +98,6 @@ class TestResult(unittest.TestResult): self._stderr_buffer.seek(0) self._stderr_buffer.truncate() self._mirrorOutput = False - def stopTestRun(self): """Called once after all tests are executed. @@ -165,10 +166,10 @@ class TestResult(unittest.TestResult): msgLines = traceback.format_exception(exctype, value, tb, length) else: msgLines = traceback.format_exception(exctype, value, tb) - + if self.buffer: output = sys.stdout.getvalue() - error = sys.stderr.getvalue() + error = sys.stderr.getvalue() if output: if not output.endswith('\n'): output += '\n' diff --git a/lldb/third_party/Python/module/unittest2/unittest2/runner.py b/lldb/third_party/Python/module/unittest2/unittest2/runner.py index db0f89d26ec..93fc104a586 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/runner.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/runner.py @@ -12,24 +12,25 @@ try: except ImportError: def registerResult(_): pass - + __unittest = True class _WritelnDecorator(object): """Used to decorate file-like objects with a handy 'writeln' method""" - def __init__(self,stream): + + def __init__(self, stream): self.stream = stream def __getattr__(self, attr): if attr in ('stream', '__getstate__'): raise AttributeError(attr) - return getattr(self.stream,attr) + return getattr(self.stream, attr) def writeln(self, arg=None): if arg: self.write(arg) - self.write('\n') # text-mode streams translate to \r\n if needed + self.write('\n') # text-mode streams translate to \r\n if needed class TextTestResult(result.TestResult): @@ -49,8 +50,9 @@ class TextTestResult(result.TestResult): self.progressbar = None if self.dots: - self.stream.writeln(".=success F=fail E=error s=skipped x=expected-fail u=unexpected-success"); - self.stream.writeln(""); + self.stream.writeln( + ".=success F=fail E=error s=skipped x=expected-fail u=unexpected-success") + self.stream.writeln("") self.stream.flush() def getDescription(self, test): @@ -67,7 +69,7 @@ class TextTestResult(result.TestResult): self.stream.write(" ... ") self.stream.flush() - def newTestResult(self,test,result_short,result_long): + def newTestResult(self, test, result_short, result_long): if self.showAll: self.stream.writeln(result_long) elif self.progressbar: @@ -81,29 +83,29 @@ class TextTestResult(result.TestResult): def addSuccess(self, test): super(TextTestResult, self).addSuccess(test) if self.progressbar: - self.newTestResult(test,"ok","ok") + self.newTestResult(test, "ok", "ok") else: - self.newTestResult(test,".","ok") + self.newTestResult(test, ".", "ok") def addError(self, test, err): super(TextTestResult, self).addError(test, err) - self.newTestResult(test,"E","ERROR") + self.newTestResult(test, "E", "ERROR") def addFailure(self, test, err): super(TextTestResult, self).addFailure(test, err) - self.newTestResult(test,"F","FAILURE") + self.newTestResult(test, "F", "FAILURE") def addSkip(self, test, reason): super(TextTestResult, self).addSkip(test, reason) - self.newTestResult(test,"s","skipped %r" % (reason,)) + self.newTestResult(test, "s", "skipped %r" % (reason,)) def addExpectedFailure(self, test, err, bugnumber): super(TextTestResult, self).addExpectedFailure(test, err, bugnumber) - self.newTestResult(test,"x","expected failure") + self.newTestResult(test, "x", "expected failure") def addUnexpectedSuccess(self, test, bugnumber): super(TextTestResult, self).addUnexpectedSuccess(test, bugnumber) - self.newTestResult(test,"u","unexpected success") + self.newTestResult(test, "u", "unexpected success") def printErrors(self): if self.progressbar: @@ -117,7 +119,8 @@ class TextTestResult(result.TestResult): def printErrorList(self, flavour, errors): for test, err in errors: self.stream.writeln(self.separator1) - self.stream.writeln("%s: %s" % (flavour, self.getDescription(test))) + self.stream.writeln("%s: %s" % + (flavour, self.getDescription(test))) self.stream.writeln(self.separator2) self.stream.writeln("%s" % err) @@ -135,7 +138,7 @@ class TextTestRunner(unittest.TextTestRunner): resultclass = TextTestResult def __init__(self, stream=sys.stderr, descriptions=True, verbosity=1, - failfast=False, buffer=False, resultclass=None): + failfast=False, buffer=False, resultclass=None): self.stream = _WritelnDecorator(stream) self.descriptions = descriptions self.verbosity = verbosity @@ -153,7 +156,7 @@ class TextTestRunner(unittest.TextTestRunner): result.failfast = self.failfast result.buffer = self.buffer registerResult(result) - + startTime = time.time() startTestRun = getattr(result, 'startTestRun', None) if startTestRun is not None: @@ -174,7 +177,7 @@ class TextTestRunner(unittest.TextTestRunner): self.stream.writeln("Ran %d test%s in %.3fs" % (run, run != 1 and "s" or "", timeTaken)) self.stream.writeln() - + expectedFails = unexpectedSuccesses = skipped = passed = failed = errored = 0 try: results = map(len, (result.expectedFailures, diff --git a/lldb/third_party/Python/module/unittest2/unittest2/signals.py b/lldb/third_party/Python/module/unittest2/unittest2/signals.py index e40328dea7a..dc0dc3daf3b 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/signals.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/signals.py @@ -7,6 +7,7 @@ __unittest = True class _InterruptHandler(object): + def __init__(self, default_handler): self.called = False self.default_handler = default_handler @@ -17,7 +18,7 @@ class _InterruptHandler(object): # if we aren't the installed handler, then delegate immediately # to the default handler self.default_handler(signum, frame) - + if self.called: self.default_handler(signum, frame) self.called = True @@ -25,13 +26,18 @@ class _InterruptHandler(object): result.stop() _results = weakref.WeakKeyDictionary() + + def registerResult(result): _results[result] = 1 + def removeResult(result): return bool(_results.pop(result, None)) _interrupt_handler = None + + def installHandler(): global _interrupt_handler if _interrupt_handler is None: diff --git a/lldb/third_party/Python/module/unittest2/unittest2/suite.py b/lldb/third_party/Python/module/unittest2/unittest2/suite.py index 9fda66aa09e..6b50680ec09 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/suite.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/suite.py @@ -11,6 +11,7 @@ __unittest = True class BaseTestSuite(unittest.TestSuite): """A simple test suite that doesn't provide class or module shared fixtures. """ + def __init__(self, tests=()): self._tests = [] self.addTests(tests) @@ -79,7 +80,6 @@ class TestSuite(BaseTestSuite): in the order in which they were added, aggregating the results. When subclassing, do not forget to call the base class constructor. """ - def run(self, result): self._wrapped_run(result) @@ -100,24 +100,24 @@ class TestSuite(BaseTestSuite): for test in self: if result.shouldStop: break - + if _isnotsuite(test): self._tearDownPreviousClass(test, result) self._handleModuleFixture(test, result) self._handleClassSetUp(test, result) result._previousTestClass = test.__class__ - - if (getattr(test.__class__, '_classSetupFailed', False) or - getattr(result, '_moduleSetUpFailed', False)): + + if (getattr(test.__class__, '_classSetupFailed', False) or + getattr(result, '_moduleSetUpFailed', False)): continue - + if hasattr(test, '_wrapped_run'): test._wrapped_run(result, debug) elif not debug: test(result) else: test.debug() - + def _handleClassSetUp(self, test, result): previousClass = getattr(result, '_previousTestClass', None) currentClass = test.__class__ @@ -127,14 +127,14 @@ class TestSuite(BaseTestSuite): return if getattr(currentClass, "__unittest_skip__", False): return - + try: currentClass._classSetupFailed = False except TypeError: # test may actually be a function # so its class will be a builtin-type pass - + setUpClass = getattr(currentClass, 'setUpClass', None) if setUpClass is not None: try: @@ -146,24 +146,22 @@ class TestSuite(BaseTestSuite): className = util.strclass(currentClass) errorName = 'setUpClass (%s)' % className self._addClassOrModuleLevelException(result, e, errorName) - + def _get_previous_module(self, result): previousModule = None previousClass = getattr(result, '_previousTestClass', None) if previousClass is not None: previousModule = previousClass.__module__ return previousModule - - + def _handleModuleFixture(self, test, result): previousModule = self._get_previous_module(result) currentModule = test.__class__.__module__ if currentModule == previousModule: return - + self._handleModuleTearDown(result) - result._moduleSetUpFailed = False try: module = sys.modules[currentModule] @@ -187,14 +185,14 @@ class TestSuite(BaseTestSuite): addSkip(error, str(exception)) else: result.addError(error, sys.exc_info()) - + def _handleModuleTearDown(self, result): previousModule = self._get_previous_module(result) if previousModule is None: return if result._moduleSetUpFailed: return - + try: module = sys.modules[previousModule] except KeyError: @@ -209,7 +207,7 @@ class TestSuite(BaseTestSuite): raise errorName = 'tearDownModule (%s)' % previousModule self._addClassOrModuleLevelException(result, e, errorName) - + def _tearDownPreviousClass(self, test, result): previousClass = getattr(result, '_previousTestClass', None) currentClass = test.__class__ @@ -221,7 +219,7 @@ class TestSuite(BaseTestSuite): return if getattr(previousClass, "__unittest_skip__", False): return - + tearDownClass = getattr(previousClass, 'tearDownClass', None) if tearDownClass is not None: try: @@ -272,6 +270,7 @@ class _ErrorHolder(object): def countTestCases(self): return 0 + def _isnotsuite(test): "A crude way to tell apart testcases and suites with duck-typing" try: 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) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/util.py b/lldb/third_party/Python/module/unittest2/unittest2/util.py index c45d008cc88..d059861600a 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/util.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/util.py @@ -4,6 +4,8 @@ __unittest = True _MAX_LENGTH = 80 + + def safe_repr(obj, short=False): try: result = repr(obj) @@ -13,15 +15,18 @@ def safe_repr(obj, short=False): return result return result[:_MAX_LENGTH] + ' [truncated]...' + def safe_str(obj): try: return str(obj) except Exception: return object.__str__(obj) + def strclass(cls): return "%s.%s" % (cls.__module__, cls.__name__) + def sorted_list_difference(expected, actual): """Finds elements in only one or the other of two, sorted input lists. @@ -62,6 +67,7 @@ def sorted_list_difference(expected, actual): break return missing, unexpected + def unorderable_list_difference(expected, actual, ignore_duplicate=False): """Same behavior as sorted_list_difference but for lists of unorderable items (like dicts). |
