Fix trailing whitespace in scripts and misc. files

Tools/Scripts/webkitpy/thirdparty/unittest2/case.py

 """Test case implementation"""
 
 import sys
 import difflib
 import pprint
 import re
 import unittest
 import warnings
 
 from unittest2 import result
@@ skipping 41 matching lines @@
 def skip(reason):
     """
     Unconditionally skip a test.
     """
     def decorator(test_item):
         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.
     """
     if condition:
@@ skipping 49 matching lines @@
         expected_regexp = self.expected_regexp
         if isinstance(expected_regexp, basestring):
             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)))
         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, basestring):
             return getattr(self.testcase, value)
         return value
-    
+
     def get(self, key, default=None):
         if key in self._store:
             return self[key]
         return default
 
 
 class TestCase(unittest.TestCase):
     """A class whose instances are single test cases.
 
     By default, the test code itself should be placed in a method named
@@ skipping 25 matching lines @@
     # 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
 
     # 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'):
         """Create an instance of the class that will use the named test
            method when executed. Raises a ValueError if the instance does
            not have a method with the specified name.
         """
         self._testMethodName = methodName
         self._resultForDoCleanups = None
         try:
@@ skipping 33 matching lines @@
     def addCleanup(self, function, *args, **kwargs):
         """Add a function, with arguments, to be called when the test is
         completed. Functions added are called on a LIFO basis and are
         called after tearDown on test failure or success.
 
         Cleanup items are called even if setUp fails (unlike tearDown)."""
         self._cleanups.append((function, args, kwargs))
 
     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."
 
     @classmethod
     def tearDownClass(cls):
         "Hook method for deconstructing the class fixture after running all tests in the class."
 
     def tearDown(self):
         "Hook method for deconstructing the test fixture after testing it."
@@ skipping 29 matching lines @@
 
     def __hash__(self):
         return hash((type(self), self._testMethodName))
 
     def __str__(self):
         return "%s (%s)" % (self._testMethodName, strclass(self.__class__))
 
     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", 
+            warnings.warn("Use of a TestResult without an addSkip method is deprecated",
                           DeprecationWarning, 2)
             result.addSuccess(self)
 
     def run(self, result=None):
         orig_result = result
         if result is None:
             result = self.defaultTestResult()
             startTestRun = getattr(result, 'startTestRun', None)
             if startTestRun is not None:
                 startTestRun()
 
         self._resultForDoCleanups = result
         result.startTest(self)
-        
+
         testMethod = getattr(self, self._testMethodName)
-        
-        if (getattr(self.__class__, "__unittest_skip__", False) or 
+
+        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__', ''))
                 self._addSkip(result, skip_why)
             finally:
                 result.stopTest(self)
             return
         try:
             success = False
             try:
                 self.setUp()
             except SkipTest, e:
                 self._addSkip(result, str(e))
             except Exception:
                 result.addError(self, sys.exc_info())
             else:
                 try:
                     testMethod()
                 except self.failureException:
                     result.addFailure(self, sys.exc_info())
                 except _ExpectedFailure, e:
                     addExpectedFailure = getattr(result, 'addExpectedFailure', None)
                     if addExpectedFailure is not None:
                         addExpectedFailure(self, e.exc_info)
-                    else: 
-                        warnings.warn("Use of a TestResult without an addExpectedFailure method is deprecated", 
+                    else:
+                        warnings.warn("Use of a TestResult without an addExpectedFailure method is deprecated",
                                       DeprecationWarning)
                         result.addSuccess(self)
                 except _UnexpectedSuccess:
                     addUnexpectedSuccess = getattr(result, 'addUnexpectedSuccess', None)
                     if addUnexpectedSuccess is not None:
                         addUnexpectedSuccess(self)
                     else:
-                        warnings.warn("Use of a TestResult without an addUnexpectedSuccess method is deprecated", 
+                        warnings.warn("Use of a TestResult without an addUnexpectedSuccess method is deprecated",
                                       DeprecationWarning)
                         result.addFailure(self, sys.exc_info())
                 except SkipTest, e:
                     self._addSkip(result, str(e))
                 except Exception:
                     result.addError(self, sys.exc_info())
                 else:
                     success = True
 
                 try:
@@ skipping 101 matching lines @@
                    do_something()
                the_exception = cm.exception
                self.assertEqual(the_exception.error_code, 3)
         """
         if callableObj is None:
             return _AssertRaisesContext(excClass, self)
         try:
             callableObj(*args, **kwargs)
         except excClass:
             return
-        
+
         if hasattr(excClass,'__name__'):
             excName = excClass.__name__
         else:
             excName = str(excClass)
         raise self.failureException, "%s not raised" % excName
 
     def _getAssertEqualityFunc(self, first, second):
         """Get a detailed comparison function for the types of the two args.
 
         Returns: A callable accepting (first, second, msg=None) that will
@@ skipping 29 matching lines @@
            operator.
         """
         assertion_func = self._getAssertEqualityFunc(first, second)
         assertion_func(first, second, msg=msg)
 
     def assertNotEqual(self, first, second, msg=None):
         """Fail if the two objects are equal as determined by the '=='
            operator.
         """
         if not first != second:
-            msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first), 
+            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):
         """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
            between the two objects is more than the given delta.
 
            Note that decimal places (from zero) are usually not the same
            as significant digits (measured from the most signficant digit).
 
            If the two objects compare equal then they will automatically
            compare almost equal.
         """
         if first == second:
             # shortcut
             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:
                 return
-        
-            standardMsg = '%s != %s within %r places' % (safe_repr(first), 
-                                                          safe_repr(second), 
+
+            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):
         """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
            between the two objects is less than the given delta.
 
            Note that decimal places (from zero) are usually not the same
            as significant digits (measured from the most signficant digit).
 
            Objects that are equal automatically fail.
         """
         if delta is not None and places is not None:
             raise TypeError("specify delta or places not both")
         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:
                 return
-            standardMsg = '%s == %s within %r places' % (safe_repr(first), 
+            standardMsg = '%s == %s within %r places' % (safe_repr(first),
                                                          safe_repr(second),
                                                          places)
 
         msg = self._formatMessage(msg, standardMsg)
         raise self.failureException(msg)
 
     # Synonyms for assertion methods
 
     # The plurals are undocumented.  Keep them that way to discourage use.
     # Do not add more.  Do not remove.
@@ skipping 196 matching lines @@
             lines.append('Items in the second set but not the first:')
             for item in difference2:
                 lines.append(repr(item))
 
         standardMsg = '\n'.join(lines)
         self.fail(self._formatMessage(msg, standardMsg))
 
     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), 
+            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), 
+            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):
         """Just like self.assertTrue(a is b), but with a nicer default message."""
         if expr1 is not expr2:
             standardMsg = '%s is not %s' % (safe_repr(expr1), safe_repr(expr2))
             self.fail(self._formatMessage(msg, standardMsg))
 
     def assertIsNot(self, expr1, expr2, msg=None):
@@ skipping 16 matching lines @@
 
     def assertDictContainsSubset(self, expected, actual, msg=None):
         """Checks whether actual is a superset of expected."""
         missing = []
         mismatched = []
         for key, value in expected.iteritems():
             if key not in actual:
                 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):
             return
 
         standardMsg = ''
         if missing:
-            standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in 
+            standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in
                                                     missing)
         if mismatched:
             if standardMsg:
                 standardMsg += '; '
             standardMsg += 'Mismatched values: %s' % ','.join(mismatched)
 
         self.fail(self._formatMessage(msg, standardMsg))
 
     def assertItemsEqual(self, expected_seq, actual_seq, msg=None):
         """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.
             - [0, 0, 1] and [0, 1] compare unequal.
         """
         try:
             expected = sorted(expected_seq)
             actual = sorted(actual_seq)
         except TypeError:
             # Unsortable items (example: set(), complex(), ...)
             expected = list(expected_seq)
             actual = list(actual_seq)
             missing, unexpected = unorderable_list_difference(
                 expected, actual, ignore_duplicate=False
             )
         else:
             return self.assertSequenceEqual(expected, actual, msg=msg)
 
         errors = []
         if missing:
-            errors.append('Expected, but missing:\n    %s' % 
+            errors.append('Expected, but missing:\n    %s' %
                            safe_repr(missing))
         if unexpected:
-            errors.append('Unexpected, but present:\n    %s' % 
+            errors.append('Unexpected, but present:\n    %s' %
                            safe_repr(unexpected))
         if errors:
             standardMsg = '\n'.join(errors)
             self.fail(self._formatMessage(msg, standardMsg))
 
     def assertMultiLineEqual(self, first, second, msg=None):
         """Assert that two multi-line strings are equal."""
         self.assert_(isinstance(first, basestring), (
                 'First argument is not a string'))
         self.assert_(isinstance(second, basestring), (
@@ skipping 71 matching lines @@
             return _AssertRaisesContext(expected_exception, self, expected_regexp)
         try:
             callable_obj(*args, **kwargs)
         except expected_exception, exc_value:
             if isinstance(expected_regexp, basestring):
                 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)))
         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, basestring):
             expected_regexp = re.compile(expected_regexp)
         if not expected_regexp.search(text):
             msg = msg or "Regexp didn't match"
@@ skipping 65 matching lines @@
 
     def __repr__(self):
         return "<%s testFunc=%s>" % (strclass(self.__class__),
                                      self._testFunc)
 
     def shortDescription(self):
         if self._description is not None:
             return self._description
         doc = self._testFunc.__doc__
         return doc and doc.split("\n")[0].strip() or None