Fix trailing whitespace in scripts and misc. files

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

 """TestSuite"""
 
 import sys
 import unittest
 from unittest2 import case, util
 
 __unittest = True
 
 
 class BaseTestSuite(unittest.TestSuite):
@@ skipping 60 matching lines @@
 
 class TestSuite(BaseTestSuite):
     """A test suite is a composite test consisting of a number of TestCases.
 
     For use, create an instance of TestSuite, then add test case instances.
     When all tests have been added, the suite can be passed to a test
     runner, such as TextTestRunner. It will run the individual test cases
     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)
         self._tearDownPreviousClass(None, result)
         self._handleModuleTearDown(result)
         return result
 
     def debug(self):
         """Run the tests without collecting errors in a TestResult"""
         debug = _DebugResult()
         self._wrapped_run(debug, True)
         self._tearDownPreviousClass(None, debug)
         self._handleModuleTearDown(debug)
 
     ################################
     # private methods
     def _wrapped_run(self, result, debug=False):
         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 
+
+                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__
         if currentClass == previousClass:
             return
         if result._moduleSetUpFailed:
             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:
                 setUpClass()
             except Exception, e:
                 if isinstance(result, _DebugResult):
                     raise
                 currentClass._classSetupFailed = True
                 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]
         except KeyError:
             return
         setUpModule = getattr(module, 'setUpModule', None)
         if setUpModule is not None:
             try:
                 setUpModule()
             except Exception, e:
                 if isinstance(result, _DebugResult):
                     raise
                 result._moduleSetUpFailed = True
                 errorName = 'setUpModule (%s)' % currentModule
                 self._addClassOrModuleLevelException(result, e, errorName)
 
     def _addClassOrModuleLevelException(self, result, exception, errorName):
         error = _ErrorHolder(errorName)
         addSkip = getattr(result, 'addSkip', None)
         if addSkip is not None and isinstance(exception, case.SkipTest):
             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:
             return
 
         tearDownModule = getattr(module, 'tearDownModule', None)
         if tearDownModule is not None:
             try:
                 tearDownModule()
             except Exception, e:
                 if isinstance(result, _DebugResult):
                     raise
                 errorName = 'tearDownModule (%s)' % previousModule
                 self._addClassOrModuleLevelException(result, e, errorName)
-    
+
     def _tearDownPreviousClass(self, test, result):
         previousClass = getattr(result, '_previousTestClass', None)
         currentClass = test.__class__
         if currentClass == previousClass:
             return
         if getattr(previousClass, '_classSetupFailed', False):
             return
         if getattr(result, '_moduleSetUpFailed', False):
             return
         if getattr(previousClass, "__unittest_skip__", False):
             return
-        
+
         tearDownClass = getattr(previousClass, 'tearDownClass', None)
         if tearDownClass is not None:
             try:
                 tearDownClass()
             except Exception, e:
                 if isinstance(result, _DebugResult):
                     raise
                 className = util.strclass(previousClass)
                 errorName = 'tearDownClass (%s)' % className
                 self._addClassOrModuleLevelException(result, e, errorName)
@@ skipping 44 matching lines @@
     except TypeError:
         return True
     return False
 
 
 class _DebugResult(object):
     "Used by the TestSuite to hold previous class when running in debug."
     _previousTestClass = None
     _moduleSetUpFailed = False
     shouldStop = False