Fix trailing whitespace in scripts and misc. files

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

 """Test result object"""
 
 import sys
 import traceback
 import unittest
 
 from StringIO import StringIO
 
 from unittest2 import util
 from unittest2.compatibility import wraps
@@ skipping 18 matching lines @@
     Test results are automatically managed by the TestCase and TestSuite
     classes, and do not need to be explicitly manipulated by writers of tests.
 
     Each instance holds the total number of tests run, and collections of
     failures and errors that occurred among those test runs. The collections
     contain tuples of (testcase, exceptioninfo), where exceptioninfo is the
     formatted traceback of the error that occurred.
     """
     _previousTestClass = None
     _moduleSetUpFailed = False
-    
+
     def __init__(self):
         self.failfast = False
         self.failures = []
         self.errors = []
         self.testsRun = 0
         self.skipped = []
         self.expectedFailures = []
         self.unexpectedSuccesses = []
         self.shouldStop = False
         self.buffer = False
         self._stdout_buffer = None
         self._stderr_buffer = None
         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
         self._mirrorOutput = False
         if self.buffer:
             if self._stderr_buffer is None:
                 self._stderr_buffer = StringIO()
                 self._stdout_buffer = StringIO()
             sys.stdout = self._stdout_buffer
             sys.stderr = self._stderr_buffer
@@ skipping 11 matching lines @@
                 output = sys.stdout.getvalue()
                 error = sys.stderr.getvalue()
                 if output:
                     if not output.endswith('\n'):
                         output += '\n'
                     self._original_stdout.write(STDOUT_LINE % output)
                 if error:
                     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)
             self._stdout_buffer.truncate()
             self._stderr_buffer.seek(0)
             self._stderr_buffer.truncate()
         self._mirrorOutput = False
-        
+
 
     def stopTestRun(self):
         """Called once after all tests are executed.
 
         See stopTest for a method called after each test.
         """
 
     @failfast
     def addError(self, test, err):
         """Called when an error has occurred. 'err' is a tuple of values as
@@ skipping 40 matching lines @@
         exctype, value, tb = err
         # Skip test runner traceback levels
         while tb and self._is_relevant_tb_level(tb):
             tb = tb.tb_next
         if exctype is test.failureException:
             # Skip assert*() traceback levels
             length = self._count_relevant_tb_levels(tb)
             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'
                 msgLines.append(STDOUT_LINE % output)
             if error:
                 if not error.endswith('\n'):
                     error += '\n'
                 msgLines.append(STDERR_LINE % error)
         return ''.join(msgLines)
 
     def _is_relevant_tb_level(self, tb):
         return '__unittest' in tb.tb_frame.f_globals
 
     def _count_relevant_tb_levels(self, tb):
         length = 0
         while tb and not self._is_relevant_tb_level(tb):
             length += 1
             tb = tb.tb_next
         return length
 
     def __repr__(self):
         return "<%s run=%i errors=%i failures=%i>" % \
                (util.strclass(self.__class__), self.testsRun, len(self.errors),
                 len(self.failures))