Whitespace normalization.

Lib/SocketServer.py

@@ -328,8 +328,8 @@ class TCPServer(BaseServer):
         self.socket = socket.socket(self.address_family,
                                     self.socket_type)
         if bind_and_activate:
-          self.server_bind()
-          self.server_activate()
+            self.server_bind()
+            self.server_activate()
 
     def server_bind(self):
         """Called by constructor to bind the socket.

Lib/genericpath.py

@@ -84,7 +84,7 @@ def commonprefix(m):
 # Generic implementation of splitext, to be parametrized with
 # the separators
 def _splitext(p, sep, altsep, extsep):
-    """Split the extension from a pathname.  
+    """Split the extension from a pathname.
 
     Extension is everything from the last dot to the end, ignoring
     leading dots.  Returns "(root, ext)"; ext may be empty."""

Lib/smtplib.py

@@ -766,7 +766,7 @@ class LMTP(SMTP):
     authentication, but your mileage might vary."""
 
     ehlo_msg = "lhlo"
-    
+
     def __init__(self, host = '', port = LMTP_PORT, local_hostname = None):
         """Initialize a new instance."""
         SMTP.__init__(self, host, port, local_hostname)

Lib/subprocess.py

@@ -596,7 +596,7 @@ class Popen(object):
         # either have to redirect all three or none. If the subprocess
         # user has only redirected one or two handles, we are
         # automatically creating PIPEs for the rest. We should close
-        # these after the process is started. See bug #1124861. 
+        # these after the process is started. See bug #1124861.
         if mswindows:
             if stdin is None and p2cwrite is not None:
                 os.close(p2cwrite)

Lib/test/test_curses.py

@@ -245,7 +245,7 @@ def test_resize_term(stdscr):
     if hasattr(curses, 'resizeterm'):
         lines, cols = curses.LINES, curses.COLS
         curses.resizeterm(lines - 1, cols + 1)
-        
+
         if curses.LINES != lines - 1 or curses.COLS != cols + 1:
             raise RuntimeError, "Expected resizeterm to update LINES and COLS"
 

Lib/test/test_descr.py

@@ -1466,7 +1466,7 @@ def errors():
 
     >>> class A(object):
     ...     pass
-    
+
     >>> class B(A, type):
     ...     pass
     Traceback (most recent call last):
@@ -1494,7 +1494,7 @@ def errors():
     ...     pass
 
     Also check that assignment to bases is safe.
-    
+
     >>> B.__bases__ = A1, A2
     Traceback (most recent call last):
     TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

Lib/test/test_dict.py

@@ -461,12 +461,12 @@ class DictTest(unittest.TestCase):
             self.assertEqual(e.args, ((1,),))
         else:
             self.fail("missing KeyError")
-        
+
     def test_bad_key(self):
         # Dictionary lookups should fail if __cmp__() raises an exception.
         class CustomException(Exception):
             pass
-        
+
         class BadDictKey:
             def __hash__(self):
                 return hash(self.__class__)
@@ -475,7 +475,7 @@ class DictTest(unittest.TestCase):
                 if isinstance(other, self.__class__):
                     raise CustomException
                 return other
-    
+
         d = {}
         x1 = BadDictKey()
         x2 = BadDictKey()
@@ -502,7 +502,7 @@ class DictTest(unittest.TestCase):
         # a mix of inserts and deletes hitting exactly the right hash codes in
         # exactly the right order, and I can't think of a randomized approach
         # that would be *likely* to hit a failing case in reasonable time.
-        
+
         d = {}
         for i in range(5):
             d[i] = i
@@ -514,7 +514,7 @@ class DictTest(unittest.TestCase):
     def test_resize2(self):
         # Another dict resizing bug (SF bug #1456209).
         # This caused Segmentation faults or Illegal instructions.
-        
+
         class X(object):
             def __hash__(self):
                 return 5

Lib/test/test_import.py

@@ -192,11 +192,11 @@ class ImportTest(unittest.TestCase):
             remove_files(TESTFN)
             if TESTFN in sys.modules:
                 del sys.modules[TESTFN]
-                
+
     def test_infinite_reload(self):
         # Bug #742342 reports that Python segfaults (infinite recursion in C)
         #  when faced with self-recursive reload()ing.
-        
+
         sys.path.insert(0, os.path.dirname(__file__))
         try:
             import infinite_reload

Lib/test/test_itertools.py

@@ -211,20 +211,20 @@ class TestBasicOps(unittest.TestCase):
             self.assertEqual(list(izip_longest(*args, **{})), target)
             target = [tuple((e is None and 'X' or e) for e in t) for t in target]   # Replace None fills with 'X'
             self.assertEqual(list(izip_longest(*args, **dict(fillvalue='X'))), target)
-        
+
         self.assertEqual(take(3,izip_longest('abcdef', count())), zip('abcdef', range(3))) # take 3 from infinite input
 
         self.assertEqual(list(izip_longest()), zip())
         self.assertEqual(list(izip_longest([])), zip([]))
         self.assertEqual(list(izip_longest('abcdef')), zip('abcdef'))
-    
+
         self.assertEqual(list(izip_longest('abc', 'defg', **{})), map(None, 'abc', 'defg')) # empty keyword dict
         self.assertRaises(TypeError, izip_longest, 3)
         self.assertRaises(TypeError, izip_longest, range(3), 3)
 
         for stmt in [
             "izip_longest('abc', fv=1)",
-            "izip_longest('abc', fillvalue=1, bogus_keyword=None)",            
+            "izip_longest('abc', fillvalue=1, bogus_keyword=None)",
         ]:
             try:
                 eval(stmt, globals(), locals())
@@ -232,7 +232,7 @@ class TestBasicOps(unittest.TestCase):
                 pass
             else:
                 self.fail('Did not raise Type in:  ' + stmt)
-        
+
         # Check tuple re-use (implementation detail)
         self.assertEqual([tuple(list(pair)) for pair in izip_longest('abc', 'def')],
                          zip('abc', 'def'))

Lib/test/test_posixpath.py

@@ -24,7 +24,7 @@ class PosixPathTest(unittest.TestCase):
         for suffix in ["", "1", "2"]:
             test_support.unlink(test_support.TESTFN + suffix)
             safe_rmdir(test_support.TESTFN + suffix)
-            
+
     def assertIs(self, a, b):
         self.assert_(a is b)
 
@@ -161,7 +161,7 @@ class PosixPathTest(unittest.TestCase):
             if not f.closed:
                 f.close()
 
-    def test_islink(self):    
+    def test_islink(self):
         self.assertIs(posixpath.islink(test_support.TESTFN + "1"), False)
         f = open(test_support.TESTFN + "1", "wb")
         try:

Lib/test/test_pty.py

@@ -41,19 +41,19 @@ def normalize_output(data):
 # because pty code is not too portable.
 class PtyTest(unittest.TestCase):
     def setUp(self):
-        # isatty() and close() can hang on some platforms.  Set an alarm 
+        # isatty() and close() can hang on some platforms.  Set an alarm
         # before running the test to make sure we don't hang forever.
         self.old_alarm = signal.signal(signal.SIGALRM, self.handle_sig)
         signal.alarm(10)
-    
+
     def tearDown(self):
         # remove alarm, restore old alarm handler
         signal.alarm(0)
         signal.signal(signal.SIGALRM, self.old_alarm)
-    
+
     def handle_sig(self, sig, frame):
         self.fail("isatty hung")
-    
+
     def test_basic(self):
         try:
             debug("Calling master_open()")
@@ -68,19 +68,19 @@ class PtyTest(unittest.TestCase):
             raise TestSkipped, "Pseudo-terminals (seemingly) not functional."
 
         self.assertTrue(os.isatty(slave_fd), 'slave_fd is not a tty')
-    
+
         debug("Writing to slave_fd")
         os.write(slave_fd, TEST_STRING_1)
         s1 = os.read(master_fd, 1024)
-        self.assertEquals('I wish to buy a fish license.\n', 
+        self.assertEquals('I wish to buy a fish license.\n',
                           normalize_output(s1))
-    
+
         debug("Writing chunked output")
         os.write(slave_fd, TEST_STRING_2[:5])
         os.write(slave_fd, TEST_STRING_2[5:])
         s2 = os.read(master_fd, 1024)
         self.assertEquals('For my pet fish, Eric.\n', normalize_output(s2))
-    
+
         os.close(slave_fd)
         os.close(master_fd)
 
@@ -93,7 +93,7 @@ class PtyTest(unittest.TestCase):
             if not os.isatty(1):
                 debug("Child's fd 1 is not a tty?!")
                 os._exit(3)
-        
+
             # After pty.fork(), the child should already be a session leader.
             # (on those systems that have that concept.)
             debug("In child, calling os.setsid()")
@@ -125,7 +125,7 @@ class PtyTest(unittest.TestCase):
             ##if False and lines != ['In child, calling os.setsid()',
             ##             'Good: OSError was raised.', '']:
             ##    raise TestFailed("Unexpected output from child: %r" % line)
-        
+
             (pid, status) = os.waitpid(pid, 0)
             res = status >> 8
             debug("Child (%d) exited with status %d (%d)." % (pid, res, status))
@@ -137,7 +137,7 @@ class PtyTest(unittest.TestCase):
                 self.fail("Child spawned by pty.fork() did not have a tty as stdout")
             elif res != 4:
                 self.fail("pty.fork() failed for unknown reasons.")
-        
+
             ##debug("Reading from master_fd now that the child has exited")
             ##try:
             ##    s1 = os.read(master_fd, 1024)
@@ -145,9 +145,9 @@ class PtyTest(unittest.TestCase):
             ##    pass
             ##else:
             ##    raise TestFailed("Read from master_fd did not raise exception")
-        
+
         os.close(master_fd)
-        
+
         # pty.fork() passed.
 
 def test_main(verbose=None):

Lib/test/test_sax.py

@@ -252,7 +252,7 @@ def test_1463026_3():
     gen.endDocument()
 
     return result.getvalue() == start+'<my:a xmlns:my="qux" b="c"></my:a>'
-    
+
 # ===== Xmlfilterbase
 
 def test_filter_basic():

Lib/test/test_set.py

@@ -285,10 +285,10 @@ class TestJointOps(unittest.TestCase):
         s = self.thetype(d)
         self.assertEqual(sum(elem.hash_count for elem in d), n)
         s.difference(d)
-        self.assertEqual(sum(elem.hash_count for elem in d), n)    
+        self.assertEqual(sum(elem.hash_count for elem in d), n)
         if hasattr(s, 'symmetric_difference_update'):
             s.symmetric_difference_update(d)
-        self.assertEqual(sum(elem.hash_count for elem in d), n)      
+        self.assertEqual(sum(elem.hash_count for elem in d), n)
 
 class TestSet(TestJointOps):
     thetype = set

Lib/test/test_threadedtempfile.py

@@ -49,14 +49,14 @@ class ThreadedTempFileTest(unittest.TestCase):
     def test_main(self):
         threads = []
         thread_info = threading_setup()
-    
+
         for i in range(NUM_THREADS):
             t = TempFileGreedy()
             threads.append(t)
             t.start()
-        
+
         startEvent.set()
-    
+
         ok = 0
         errors = []
         for t in threads:
@@ -66,8 +66,8 @@ class ThreadedTempFileTest(unittest.TestCase):
                 errors.append(str(t.getName()) + str(t.errors.getvalue()))
 
         threading_cleanup(*thread_info)
-        
-        msg = "Errors: errors %d ok %d\n%s" % (len(errors), ok, 
+
+        msg = "Errors: errors %d ok %d\n%s" % (len(errors), ok,
             '\n'.join(errors))
         self.assertEquals(errors, [], msg)
         self.assertEquals(ok, NUM_THREADS * FILES_PER_THREAD)

Lib/test/test_unittest.py

@@ -21,34 +21,34 @@ class LoggingResult(unittest.TestResult):
     def startTest(self, test):
         self._events.append('startTest')
         super(LoggingResult, self).startTest(test)
-        
+
     def stopTest(self, test):
         self._events.append('stopTest')
         super(LoggingResult, self).stopTest(test)
-        
+
     def addFailure(self, *args):
         self._events.append('addFailure')
         super(LoggingResult, self).addFailure(*args)
-        
+
     def addError(self, *args):
         self._events.append('addError')
         super(LoggingResult, self).addError(*args)
 
 class TestEquality(object):
-    # Check for a valid __eq__ implementation            
+    # Check for a valid __eq__ implementation
     def test_eq(self):
         for obj_1, obj_2 in self.eq_pairs:
             self.assertEqual(obj_1, obj_2)
             self.assertEqual(obj_2, obj_1)
-            
-    # Check for a valid __ne__ implementation            
+
+    # Check for a valid __ne__ implementation
     def test_ne(self):
         for obj_1, obj_2 in self.ne_pairs:
             self.failIfEqual(obj_1, obj_2)
             self.failIfEqual(obj_2, obj_1)
-            
+
 class TestHashing(object):
-    # Check for a valid __hash__ implementation            
+    # Check for a valid __hash__ implementation
     def test_hash(self):
         for obj_1, obj_2 in self.eq_pairs:
             try:
@@ -59,7 +59,7 @@ class TestHashing(object):
                 self.fail("%s and %s do not hash equal" % (obj_1, obj_2))
             except Exception, e:
                 self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
-                
+
         for obj_1, obj_2 in self.ne_pairs:
             try:
                 assert hash(obj_1) != hash(obj_2)
@@ -69,7 +69,7 @@ class TestHashing(object):
                 self.fail("%s and %s hash equal, but shouldn't" % (obj_1, obj_2))
             except Exception, e:
                 self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
-                
+
 
 ################################################################
 ### /Support code
@@ -86,25 +86,25 @@ class Test_TestLoader(TestCase):
             def test_1(self): pass
             def test_2(self): pass
             def foo_bar(self): pass
-            
+
         tests = unittest.TestSuite([Foo('test_1'), Foo('test_2')])
-        
+
         loader = unittest.TestLoader()
         self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
-    
+
     # "Return a suite of all tests cases contained in the TestCase-derived
     # class testCaseClass"
     #
-    # Make sure it does the right thing even if no tests were found    
+    # Make sure it does the right thing even if no tests were found
     def test_loadTestsFromTestCase__no_matches(self):
         class Foo(unittest.TestCase):
             def foo_bar(self): pass
-            
+
         empty_suite = unittest.TestSuite()
-        
+
         loader = unittest.TestLoader()
         self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite)
-            
+
     # "Return a suite of all tests cases contained in the TestCase-derived
     # class testCaseClass"
     #
@@ -117,7 +117,7 @@ class Test_TestLoader(TestCase):
     def test_loadTestsFromTestCase__TestSuite_subclass(self):
         class NotATestCase(unittest.TestSuite):
             pass
-        
+
         loader = unittest.TestLoader()
         try:
             loader.loadTestsFromTestCase(NotATestCase)
@@ -125,7 +125,7 @@ class Test_TestLoader(TestCase):
             pass
         else:
             self.fail('Should raise TypeError')
-    
+
     # "Return a suite of all tests cases contained in the TestCase-derived
     # class testCaseClass"
     #
@@ -136,18 +136,18 @@ class Test_TestLoader(TestCase):
         class Foo(unittest.TestCase):
             def runTest(self):
                 pass
-                
+
         loader = unittest.TestLoader()
         # This has to be false for the test to succeed
         self.failIf('runTest'.startswith(loader.testMethodPrefix))
-        
+
         suite = loader.loadTestsFromTestCase(Foo)
         self.failUnless(isinstance(suite, loader.suiteClass))
         self.assertEqual(list(suite), [Foo('runTest')])
 
     ################################################################
     ### /Tests for TestLoader.loadTestsFromTestCase
-    
+
     ### Tests for TestLoader.loadTestsFromModule
     ################################################################
 
@@ -159,42 +159,42 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromModule(m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         expected = [loader.suiteClass([MyTestCase('test')])]
         self.assertEqual(list(suite), expected)
-    
+
     # "This method searches `module` for classes derived from TestCase"
-    #    
+    #
     # What happens if no tests are found (no TestCase instances)?
     def test_loadTestsFromModule__no_TestCase_instances(self):
         import new
         m = new.module('m')
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromModule(m)
         self.failUnless(isinstance(suite, loader.suiteClass))
         self.assertEqual(list(suite), [])
-    
+
     # "This method searches `module` for classes derived from TestCase"
     #
-    # What happens if no tests are found (TestCases instances, but no tests)?    
+    # What happens if no tests are found (TestCases instances, but no tests)?
     def test_loadTestsFromModule__no_TestCase_tests(self):
         import new
         m = new.module('m')
         class MyTestCase(unittest.TestCase):
             pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromModule(m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         self.assertEqual(list(suite), [loader.suiteClass()])
-    
+
     # "This method searches `module` for classes derived from TestCase"s
     #
     # What happens if loadTestsFromModule() is given something other
@@ -209,22 +209,22 @@ class Test_TestLoader(TestCase):
         class MyTestCase(unittest.TestCase):
             def test(self):
                 pass
-    
+
         class NotAModule(object):
             test_2 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromModule(NotAModule)
-       
+
         reference = [unittest.TestSuite([MyTestCase('test')])]
         self.assertEqual(list(suite), reference)
-            
+
     ################################################################
     ### /Tests for TestLoader.loadTestsFromModule()
-    
+
     ### Tests for TestLoader.loadTestsFromName()
     ################################################################
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
@@ -233,23 +233,23 @@ class Test_TestLoader(TestCase):
     # Is ValueError raised in response to an empty name?
     def test_loadTestsFromName__empty_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromName('')
         except ValueError, e:
             self.assertEqual(str(e), "Empty module name")
         else:
             self.fail("TestLoader.loadTestsFromName failed to raise ValueError")
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
     # TestCase or TestSuite instance."
     #
-    # What happens when the name contains invalid characters?        
+    # What happens when the name contains invalid characters?
     def test_loadTestsFromName__malformed_name(self):
         loader = unittest.TestLoader()
-        
+
         # XXX Should this raise ValueError or ImportError?
         try:
             loader.loadTestsFromName('abc () //')
@@ -259,37 +259,37 @@ class Test_TestLoader(TestCase):
             pass
         else:
             self.fail("TestLoader.loadTestsFromName failed to raise ValueError")
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to a
     # module"
     #
-    # What happens when a module by that name can't be found?   
+    # What happens when a module by that name can't be found?
     def test_loadTestsFromName__unknown_module_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromName('sdasfasfasdf')
         except ImportError, e:
             self.assertEqual(str(e), "No module named sdasfasfasdf")
         else:
             self.fail("TestLoader.loadTestsFromName failed to raise ImportError")
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
     # TestCase or TestSuite instance."
     #
-    # What happens when the module is found, but the attribute can't?        
+    # What happens when the module is found, but the attribute can't?
     def test_loadTestsFromName__unknown_attr_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromName('unittest.sdasfasfasdf')
         except AttributeError, e:
             self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'")
         else:
             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
     # within a test case class, or a callable object which returns a
@@ -299,14 +299,14 @@ class Test_TestLoader(TestCase):
     # found?
     def test_loadTestsFromName__relative_unknown_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromName('sdasfasfasdf', unittest)
         except AttributeError, e:
             self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'")
         else:
             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
     # within a test case class, or a callable object which returns a
@@ -320,14 +320,14 @@ class Test_TestLoader(TestCase):
     # XXX Should probably raise a ValueError instead of an AttributeError
     def test_loadTestsFromName__relative_empty_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromName('', unittest)
         except AttributeError, e:
             pass
         else:
             self.fail("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
     # within a test case class, or a callable object which returns a
@@ -339,7 +339,7 @@ class Test_TestLoader(TestCase):
     # `module`?
     def test_loadTestsFromName__relative_malformed_name(self):
         loader = unittest.TestLoader()
-        
+
         # XXX Should this raise AttributeError or ValueError?
         try:
             loader.loadTestsFromName('abc () //', unittest)
@@ -363,16 +363,16 @@ class Test_TestLoader(TestCase):
         class MyTestCase(unittest.TestCase):
             def test(self):
                 pass
-    
+
         class NotAModule(object):
             test_2 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromName('test_2', NotAModule)
-        
+
         reference = [MyTestCase('test')]
         self.assertEqual(list(suite), reference)
-            
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
@@ -384,7 +384,7 @@ class Test_TestLoader(TestCase):
         import new
         m = new.module('m')
         m.testcase_1 = object()
-        
+
         loader = unittest.TestLoader()
         try:
             loader.loadTestsFromName('testcase_1', m)
@@ -402,12 +402,12 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromName('testcase_1', m)
         self.failUnless(isinstance(suite, loader.suiteClass))
         self.assertEqual(list(suite), [MyTestCase('test')])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
@@ -419,13 +419,13 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testsuite = unittest.TestSuite([MyTestCase('test')])
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromName('testsuite', m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         self.assertEqual(list(suite), [MyTestCase('test')])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to
     # ... a test method within a test case class"
     def test_loadTestsFromName__relative_testmethod(self):
@@ -435,13 +435,13 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromName('testcase_1.test', m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         self.assertEqual(list(suite), [MyTestCase('test')])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
@@ -457,7 +457,7 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         try:
             loader.loadTestsFromName('testcase_1.testfoo', m)
@@ -476,12 +476,12 @@ class Test_TestLoader(TestCase):
         def return_TestSuite():
             return unittest.TestSuite([testcase_1, testcase_2])
         m.return_TestSuite = return_TestSuite
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromName('return_TestSuite', m)
         self.failUnless(isinstance(suite, loader.suiteClass))
         self.assertEqual(list(suite), [testcase_1, testcase_2])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to
     # ... a callable object which returns a TestCase ... instance"
     def test_loadTestsFromName__callable__TestCase_instance(self):
@@ -491,12 +491,12 @@ class Test_TestLoader(TestCase):
         def return_TestCase():
             return testcase_1
         m.return_TestCase = return_TestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromName('return_TestCase', m)
         self.failUnless(isinstance(suite, loader.suiteClass))
         self.assertEqual(list(suite), [testcase_1])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to
     # ... a callable object which returns a TestCase or TestSuite instance"
     #
@@ -507,7 +507,7 @@ class Test_TestLoader(TestCase):
         def return_wrong():
             return 6
         m.return_wrong = return_wrong
-        
+
         loader = unittest.TestLoader()
         try:
             suite = loader.loadTestsFromName('return_wrong', m)
@@ -515,9 +515,9 @@ class Test_TestLoader(TestCase):
             pass
         else:
             self.fail("TestLoader.loadTestsFromName failed to raise TypeError")
-    
+
     # "The specifier can refer to modules and packages which have not been
-    # imported; they will be imported as a side-effect"        
+    # imported; they will be imported as a side-effect"
     def test_loadTestsFromName__module_not_loaded(self):
         # We're going to try to load this module as a side-effect, so it
         # better not be loaded before we try.
@@ -525,11 +525,11 @@ class Test_TestLoader(TestCase):
         # Why pick audioop? Google shows it isn't used very often, so there's
         # a good chance that it won't be imported when this test is run
         module_name = 'audioop'
-        
+
         import sys
         if module_name in sys.modules:
             del sys.modules[module_name]
-        
+
         loader = unittest.TestLoader()
         try:
             suite = loader.loadTestsFromName(module_name)
@@ -547,18 +547,18 @@ class Test_TestLoader(TestCase):
 
     ### Tests for TestLoader.loadTestsFromNames()
     ################################################################
-    
+
     # "Similar to loadTestsFromName(), but takes a sequence of names rather
     # than a single name."
     #
     # What happens if that sequence of names is empty?
     def test_loadTestsFromNames__empty_name_list(self):
         loader = unittest.TestLoader()
-        
+
         suite = loader.loadTestsFromNames([])
         self.failUnless(isinstance(suite, loader.suiteClass))
         self.assertEqual(list(suite), [])
-        
+
     # "Similar to loadTestsFromName(), but takes a sequence of names rather
     # than a single name."
     # ...
@@ -569,7 +569,7 @@ class Test_TestLoader(TestCase):
     # XXX Should this raise a ValueError or just return an empty TestSuite?
     def test_loadTestsFromNames__relative_empty_name_list(self):
         loader = unittest.TestLoader()
-        
+
         suite = loader.loadTestsFromNames([], unittest)
         self.failUnless(isinstance(suite, loader.suiteClass))
         self.assertEqual(list(suite), [])
@@ -582,23 +582,23 @@ class Test_TestLoader(TestCase):
     # Is ValueError raised in response to an empty name?
     def test_loadTestsFromNames__empty_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromNames([''])
         except ValueError, e:
             self.assertEqual(str(e), "Empty module name")
         else:
             self.fail("TestLoader.loadTestsFromNames failed to raise ValueError")
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
     # TestCase or TestSuite instance."
     #
-    # What happens when presented with an impossible module name?        
+    # What happens when presented with an impossible module name?
     def test_loadTestsFromNames__malformed_name(self):
         loader = unittest.TestLoader()
-        
+
         # XXX Should this raise ValueError or ImportError?
         try:
             loader.loadTestsFromNames(['abc () //'])
@@ -608,39 +608,39 @@ class Test_TestLoader(TestCase):
             pass
         else:
             self.fail("TestLoader.loadTestsFromNames failed to raise ValueError")
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
     # TestCase or TestSuite instance."
     #
-    # What happens when no module can be found for the given name?    
+    # What happens when no module can be found for the given name?
     def test_loadTestsFromNames__unknown_module_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromNames(['sdasfasfasdf'])
         except ImportError, e:
             self.assertEqual(str(e), "No module named sdasfasfasdf")
         else:
             self.fail("TestLoader.loadTestsFromNames failed to raise ImportError")
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
     # TestCase or TestSuite instance."
     #
-    # What happens when the module can be found, but not the attribute?        
+    # What happens when the module can be found, but not the attribute?
     def test_loadTestsFromNames__unknown_attr_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromNames(['unittest.sdasfasfasdf', 'unittest'])
         except AttributeError, e:
             self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'")
         else:
             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
     # within a test case class, or a callable object which returns a
@@ -652,14 +652,14 @@ class Test_TestLoader(TestCase):
     # argument?
     def test_loadTestsFromNames__unknown_name_relative_1(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromNames(['sdasfasfasdf'], unittest)
         except AttributeError, e:
             self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'")
         else:
             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
     # within a test case class, or a callable object which returns a
@@ -668,10 +668,10 @@ class Test_TestLoader(TestCase):
     # "The method optionally resolves name relative to the given module"
     #
     # Do unknown attributes (relative to a provided module) still raise an
-    # exception even in the presence of valid attribute names?        
+    # exception even in the presence of valid attribute names?
     def test_loadTestsFromNames__unknown_name_relative_2(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest)
         except AttributeError, e:
@@ -692,14 +692,14 @@ class Test_TestLoader(TestCase):
     # more appropriate
     def test_loadTestsFromNames__relative_empty_name(self):
         loader = unittest.TestLoader()
-        
+
         try:
             loader.loadTestsFromNames([''], unittest)
         except AttributeError:
             pass
         else:
             self.fail("Failed to raise ValueError")
-    
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
@@ -707,10 +707,10 @@ class Test_TestLoader(TestCase):
     # ...
     # "The method optionally resolves name relative to the given module"
     #
-    # What happens when presented with an impossible attribute name?   
+    # What happens when presented with an impossible attribute name?
     def test_loadTestsFromNames__relative_malformed_name(self):
         loader = unittest.TestLoader()
-        
+
         # XXX Should this raise AttributeError or ValueError?
         try:
             loader.loadTestsFromNames(['abc () //'], unittest)
@@ -732,16 +732,16 @@ class Test_TestLoader(TestCase):
         class MyTestCase(unittest.TestCase):
             def test(self):
                 pass
-    
+
         class NotAModule(object):
             test_2 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromNames(['test_2'], NotAModule)
-        
+
         reference = [unittest.TestSuite([MyTestCase('test')])]
         self.assertEqual(list(suite), reference)
-            
+
     # "The specifier name is a ``dotted name'' that may resolve either to
     # a module, a test case class, a TestSuite instance, a test method
     # within a test case class, or a callable object which returns a
@@ -753,7 +753,7 @@ class Test_TestLoader(TestCase):
         import new
         m = new.module('m')
         m.testcase_1 = object()
-        
+
         loader = unittest.TestLoader()
         try:
             loader.loadTestsFromNames(['testcase_1'], m)
@@ -771,14 +771,14 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromNames(['testcase_1'], m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         expected = loader.suiteClass([MyTestCase('test')])
         self.assertEqual(list(suite), [expected])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to
     # ... a TestSuite instance"
     def test_loadTestsFromNames__relative_TestSuite(self):
@@ -788,13 +788,13 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testsuite = unittest.TestSuite([MyTestCase('test')])
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromNames(['testsuite'], m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         self.assertEqual(list(suite), [m.testsuite])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to ... a
     # test method within a test case class"
     def test_loadTestsFromNames__relative_testmethod(self):
@@ -804,19 +804,19 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromNames(['testcase_1.test'], m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         ref_suite = unittest.TestSuite([MyTestCase('test')])
         self.assertEqual(list(suite), [ref_suite])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to ... a
     # test method within a test case class"
     #
     # Does the method gracefully handle names that initially look like they
-    # resolve to "a test method within a test case class" but don't?    
+    # resolve to "a test method within a test case class" but don't?
     def test_loadTestsFromNames__relative_invalid_testmethod(self):
         import new
         m = new.module('m')
@@ -824,7 +824,7 @@ class Test_TestLoader(TestCase):
             def test(self):
                 pass
         m.testcase_1 = MyTestCase
-        
+
         loader = unittest.TestLoader()
         try:
             loader.loadTestsFromNames(['testcase_1.testfoo'], m)
@@ -843,14 +843,14 @@ class Test_TestLoader(TestCase):
         def return_TestSuite():
             return unittest.TestSuite([testcase_1, testcase_2])
         m.return_TestSuite = return_TestSuite
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromNames(['return_TestSuite'], m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         expected = unittest.TestSuite([testcase_1, testcase_2])
         self.assertEqual(list(suite), [expected])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to
     # ... a callable object which returns a TestCase ... instance"
     def test_loadTestsFromNames__callable__TestCase_instance(self):
@@ -860,39 +860,39 @@ class Test_TestLoader(TestCase):
         def return_TestCase():
             return testcase_1
         m.return_TestCase = return_TestCase
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromNames(['return_TestCase'], m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         ref_suite = unittest.TestSuite([testcase_1])
         self.assertEqual(list(suite), [ref_suite])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to
     # ... a callable object which returns a TestCase or TestSuite instance"
     #
-    # Are staticmethods handled correctly?    
+    # Are staticmethods handled correctly?
     def test_loadTestsFromNames__callable__call_staticmethod(self):
         import new
         m = new.module('m')
         class Test1(unittest.TestCase):
             def test(self):
                 pass
-        
+
         testcase_1 = Test1('test')
         class Foo(unittest.TestCase):
             @staticmethod
             def foo():
                 return testcase_1
         m.Foo = Foo
-        
+
         loader = unittest.TestLoader()
         suite = loader.loadTestsFromNames(['Foo.foo'], m)
         self.failUnless(isinstance(suite, loader.suiteClass))
-        
+
         ref_suite = unittest.TestSuite([testcase_1])
         self.assertEqual(list(suite), [ref_suite])
-    
+
     # "The specifier name is a ``dotted name'' that may resolve ... to
     # ... a callable object which returns a TestCase or TestSuite instance"
     #
@@ -903,7 +903,7 @@ class Test_TestLoader(TestCase):
         def return_wrong():
             return 6
         m.return_wrong = return_wrong
-        
+
         loader = unittest.TestLoader()
         try:
             suite = loader.loadTestsFromNames(['return_wrong'], m)
@@ -911,9 +911,9 @@ class Test_TestLoader(TestCase):
             pass
         else:
             self.fail("TestLoader.loadTestsFromNames failed to raise TypeError")
-            
+
     # "The specifier can refer to modules and packages which have not been
-    # imported; they will be imported as a side-effect"        
+    # imported; they will be imported as a side-effect"
     def test_loadTestsFromNames__module_not_loaded(self):
         # We're going to try to load this module as a side-effect, so it
         # better not be loaded before we try.
@@ -921,11 +921,11 @@ class Test_TestLoader(TestCase):
         # Why pick audioop? Google shows it isn't used very often, so there's
         # a good chance that it won't be imported when this test is run
         module_name = 'audioop'
-        
+
         import sys
         if module_name in sys.modules:
             del sys.modules[module_name]
-        
+
         loader = unittest.TestLoader()
         try:
             suite = loader.loadTestsFromNames([module_name])
@@ -937,38 +937,38 @@ class Test_TestLoader(TestCase):
             self.failUnless(module_name in sys.modules)
         finally:
             del sys.modules[module_name]
-            
+
     ################################################################
     ### /Tests for TestLoader.loadTestsFromNames()
 
     ### Tests for TestLoader.getTestCaseNames()
     ################################################################
-    
+
     # "Return a sorted sequence of method names found within testCaseClass"
     #
     # Test.foobar is defined to make sure getTestCaseNames() respects
-    # loader.testMethodPrefix  
+    # loader.testMethodPrefix
     def test_getTestCaseNames(self):
         class Test(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
             def foobar(self): pass
-            
+
         loader = unittest.TestLoader()
-        
+
         self.assertEqual(loader.getTestCaseNames(Test), ['test_1', 'test_2'])
-    
+
     # "Return a sorted sequence of method names found within testCaseClass"
     #
-    # Does getTestCaseNames() behave appropriately if no tests are found?    
+    # Does getTestCaseNames() behave appropriately if no tests are found?
     def test_getTestCaseNames__no_tests(self):
         class Test(unittest.TestCase):
             def foobar(self): pass
-            
+
         loader = unittest.TestLoader()
-        
+
         self.assertEqual(loader.getTestCaseNames(Test), [])
-    
+
     # "Return a sorted sequence of method names found within testCaseClass"
     #
     # Are not-TestCases handled gracefully?
@@ -981,42 +981,42 @@ class Test_TestLoader(TestCase):
         class BadCase(int):
             def test_foo(self):
                 pass
-    
+
         loader = unittest.TestLoader()
         names = loader.getTestCaseNames(BadCase)
-        
+
         self.assertEqual(names, ['test_foo'])
-            
+
     # "Return a sorted sequence of method names found within testCaseClass"
     #
     # Make sure inherited names are handled.
     #
     # TestP.foobar is defined to make sure getTestCaseNames() respects
-    # loader.testMethodPrefix  
+    # loader.testMethodPrefix
     def test_getTestCaseNames__inheritance(self):
         class TestP(unittest.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 = unittest.TestLoader()
-        
+
         names = ['test_1', 'test_2', 'test_3']
         self.assertEqual(loader.getTestCaseNames(TestC), names)
-    
-    ################################################################        
+
+    ################################################################
     ### /Tests for TestLoader.getTestCaseNames()
 
     ### Tests for TestLoader.testMethodPrefix
     ################################################################
-    
+
     # "String giving the prefix of method names which will be interpreted as
     # test methods"
-    # 
+    #
     # Implicit in the documentation is that testMethodPrefix is respected by
     # all loadTestsFrom* methods.
     def test_testMethodPrefix__loadTestsFromTestCase(self):
@@ -1024,20 +1024,20 @@ class Test_TestLoader(TestCase):
             def test_1(self): pass
             def test_2(self): pass
             def foo_bar(self): pass
-            
+
         tests_1 = unittest.TestSuite([Foo('foo_bar')])
         tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')])
-        
+
         loader = unittest.TestLoader()
         loader.testMethodPrefix = 'foo'
         self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_1)
 
         loader.testMethodPrefix = 'test'
         self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_2)
-        
+
     # "String giving the prefix of method names which will be interpreted as
     # test methods"
-    # 
+    #
     # Implicit in the documentation is that testMethodPrefix is respected by
     # all loadTestsFrom* methods.
     def test_testMethodPrefix__loadTestsFromModule(self):
@@ -1048,20 +1048,20 @@ class Test_TestLoader(TestCase):
             def test_2(self): pass
             def foo_bar(self): pass
         m.Foo = Foo
-            
+
         tests_1 = [unittest.TestSuite([Foo('foo_bar')])]
         tests_2 = [unittest.TestSuite([Foo('test_1'), Foo('test_2')])]
-        
+
         loader = unittest.TestLoader()
         loader.testMethodPrefix = 'foo'
         self.assertEqual(list(loader.loadTestsFromModule(m)), tests_1)
 
         loader.testMethodPrefix = 'test'
         self.assertEqual(list(loader.loadTestsFromModule(m)), tests_2)
-        
+
     # "String giving the prefix of method names which will be interpreted as
     # test methods"
-    # 
+    #
     # Implicit in the documentation is that testMethodPrefix is respected by
     # all loadTestsFrom* methods.
     def test_testMethodPrefix__loadTestsFromName(self):
@@ -1072,20 +1072,20 @@ class Test_TestLoader(TestCase):
             def test_2(self): pass
             def foo_bar(self): pass
         m.Foo = Foo
-            
+
         tests_1 = unittest.TestSuite([Foo('foo_bar')])
         tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')])
-        
+
         loader = unittest.TestLoader()
         loader.testMethodPrefix = 'foo'
         self.assertEqual(loader.loadTestsFromName('Foo', m), tests_1)
 
         loader.testMethodPrefix = 'test'
         self.assertEqual(loader.loadTestsFromName('Foo', m), tests_2)
-        
+
     # "String giving the prefix of method names which will be interpreted as
     # test methods"
-    # 
+    #
     # Implicit in the documentation is that testMethodPrefix is respected by
     # all loadTestsFrom* methods.
     def test_testMethodPrefix__loadTestsFromNames(self):
@@ -1096,102 +1096,102 @@ class Test_TestLoader(TestCase):
             def test_2(self): pass
             def foo_bar(self): pass
         m.Foo = Foo
-            
+
         tests_1 = unittest.TestSuite([unittest.TestSuite([Foo('foo_bar')])])
         tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')])
         tests_2 = unittest.TestSuite([tests_2])
-        
+
         loader = unittest.TestLoader()
         loader.testMethodPrefix = 'foo'
         self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_1)
 
         loader.testMethodPrefix = 'test'
         self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_2)
-            
+
     # "The default value is 'test'"
     def test_testMethodPrefix__default_value(self):
         loader = unittest.TestLoader()
         self.failUnless(loader.testMethodPrefix == 'test')
-        
+
     ################################################################
     ### /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):
         def reversed_cmp(x, y):
             return -cmp(x, y)
-                
+
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
-            
+
         loader = unittest.TestLoader()
         loader.sortTestMethodsUsing = reversed_cmp
-        
+
         tests = loader.suiteClass([Foo('test_2'), Foo('test_1')])
         self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
-        
+
     # "Function to be used to compare method names when sorting them in
     # getTestCaseNames() and all the loadTestsFromX() methods"
     def test_sortTestMethodsUsing__loadTestsFromModule(self):
         def reversed_cmp(x, y):
             return -cmp(x, y)
-        
+
         import new
-        m = new.module('m')        
+        m = new.module('m')
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
         m.Foo = Foo
-            
+
         loader = unittest.TestLoader()
         loader.sortTestMethodsUsing = reversed_cmp
-        
+
         tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])]
         self.assertEqual(list(loader.loadTestsFromModule(m)), tests)
-        
+
     # "Function to be used to compare method names when sorting them in
     # getTestCaseNames() and all the loadTestsFromX() methods"
     def test_sortTestMethodsUsing__loadTestsFromName(self):
         def reversed_cmp(x, y):
             return -cmp(x, y)
-                
+
         import new
-        m = new.module('m')        
+        m = new.module('m')
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
         m.Foo = Foo
-            
+
         loader = unittest.TestLoader()
         loader.sortTestMethodsUsing = reversed_cmp
-        
+
         tests = loader.suiteClass([Foo('test_2'), Foo('test_1')])
         self.assertEqual(loader.loadTestsFromName('Foo', m), tests)
-        
+
     # "Function to be used to compare method names when sorting them in
     # getTestCaseNames() and all the loadTestsFromX() methods"
     def test_sortTestMethodsUsing__loadTestsFromNames(self):
         def reversed_cmp(x, y):
             return -cmp(x, y)
-                
+
         import new
-        m = new.module('m')        
+        m = new.module('m')
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
         m.Foo = Foo
-            
+
         loader = unittest.TestLoader()
         loader.sortTestMethodsUsing = reversed_cmp
-        
+
         tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])]
         self.assertEqual(list(loader.loadTestsFromNames(['Foo'], m)), tests)
-    
+
     # "Function to be used to compare method names when sorting them in
     # getTestCaseNames()"
     #
@@ -1199,22 +1199,22 @@ class Test_TestLoader(TestCase):
     def test_sortTestMethodsUsing__getTestCaseNames(self):
         def reversed_cmp(x, y):
             return -cmp(x, y)
-                
+
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
-            
+
         loader = unittest.TestLoader()
         loader.sortTestMethodsUsing = reversed_cmp
-        
+
         test_names = ['test_2', 'test_1']
         self.assertEqual(loader.getTestCaseNames(Foo), test_names)
-        
+
     # "The default value is the built-in cmp() function"
     def test_sortTestMethodsUsing__default_value(self):
         loader = unittest.TestLoader()
         self.failUnless(loader.sortTestMethodsUsing is cmp)
-        
+
     # "it can be set to None to disable the sort."
     #
     # XXX How is this different from reassigning cmp? Are the tests returned
@@ -1223,34 +1223,34 @@ class Test_TestLoader(TestCase):
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
-            
+
         loader = unittest.TestLoader()
         loader.sortTestMethodsUsing = None
-        
+
         test_names = ['test_2', 'test_1']
         self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names))
-    
+
     ################################################################
     ### /Tests for TestLoader.sortTestMethodsUsing
-    
+
     ### Tests for TestLoader.suiteClass
     ################################################################
-    
+
     # "Callable object that constructs a test suite from a list of tests."
     def test_suiteClass__loadTestsFromTestCase(self):
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
             def foo_bar(self): pass
-            
+
         tests = [Foo('test_1'), Foo('test_2')]
 
         loader = unittest.TestLoader()
         loader.suiteClass = list
         self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
-    
+
     # It is implicit in the documentation for TestLoader.suiteClass that
-    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure    
+    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure
     def test_suiteClass__loadTestsFromModule(self):
         import new
         m = new.module('m')
@@ -1259,15 +1259,15 @@ class Test_TestLoader(TestCase):
             def test_2(self): pass
             def foo_bar(self): pass
         m.Foo = Foo
-            
+
         tests = [[Foo('test_1'), Foo('test_2')]]
 
         loader = unittest.TestLoader()
         loader.suiteClass = list
         self.assertEqual(loader.loadTestsFromModule(m), tests)
-    
+
     # It is implicit in the documentation for TestLoader.suiteClass that
-    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure    
+    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure
     def test_suiteClass__loadTestsFromName(self):
         import new
         m = new.module('m')
@@ -1276,15 +1276,15 @@ class Test_TestLoader(TestCase):
             def test_2(self): pass
             def foo_bar(self): pass
         m.Foo = Foo
-            
+
         tests = [Foo('test_1'), Foo('test_2')]
 
         loader = unittest.TestLoader()
         loader.suiteClass = list
         self.assertEqual(loader.loadTestsFromName('Foo', m), tests)
-    
+
     # It is implicit in the documentation for TestLoader.suiteClass that
-    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure    
+    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure
     def test_suiteClass__loadTestsFromNames(self):
         import new
         m = new.module('m')
@@ -1293,18 +1293,18 @@ class Test_TestLoader(TestCase):
             def test_2(self): pass
             def foo_bar(self): pass
         m.Foo = Foo
-            
+
         tests = [[Foo('test_1'), Foo('test_2')]]
 
         loader = unittest.TestLoader()
         loader.suiteClass = list
         self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests)
-        
+
     # "The default value is the TestSuite class"
     def test_suiteClass__default_value(self):
         loader = unittest.TestLoader()
         self.failUnless(loader.suiteClass is unittest.TestSuite)
-    
+
     ################################################################
     ### /Tests for TestLoader.suiteClass
 
@@ -1319,7 +1319,7 @@ class Foo(unittest.TestCase):
 
 def _mk_TestSuite(*names):
     return unittest.TestSuite(Foo(n) for n in names)
-    
+
 ################################################################
 ### /Support code for Test_TestSuite
 
@@ -1332,13 +1332,13 @@ class Test_TestSuite(TestCase, TestEquality):
     eq_pairs = [(unittest.TestSuite(), unittest.TestSuite())
                ,(unittest.TestSuite(), unittest.TestSuite([]))
                ,(_mk_TestSuite('test_1'), _mk_TestSuite('test_1'))]
-    
-    # Used by TestEquality.test_ne           
+
+    # Used by TestEquality.test_ne
     ne_pairs = [(unittest.TestSuite(), _mk_TestSuite('test_1'))
                ,(unittest.TestSuite([]), _mk_TestSuite('test_1'))
                ,(_mk_TestSuite('test_1', 'test_2'), _mk_TestSuite('test_1', 'test_3'))
                ,(_mk_TestSuite('test_1'), _mk_TestSuite('test_2'))]
-    
+
     ################################################################
     ### /Set up attributes needed by inherited tests
 
@@ -1350,41 +1350,41 @@ class Test_TestSuite(TestCase, TestEquality):
     # The tests iterable should be optional
     def test_init__tests_optional(self):
         suite = unittest.TestSuite()
-        
+
         self.assertEqual(suite.countTestCases(), 0)
-    
+
     # "class TestSuite([tests])"
     # ...
     # "If tests is given, it must be an iterable of individual test cases
     # or other test suites that will be used to build the suite initially"
     #
     # TestSuite should deal with empty tests iterables by allowing the
-    # creation of an empty suite    
+    # creation of an empty suite
     def test_init__empty_tests(self):
         suite = unittest.TestSuite([])
-        
+
         self.assertEqual(suite.countTestCases(), 0)
-        
+
     # "class TestSuite([tests])"
     # ...
     # "If tests is given, it must be an iterable of individual test cases
     # or other test suites that will be used to build the suite initially"
     #
-    # TestSuite should allow any iterable to provide tests    
+    # TestSuite should allow any iterable to provide tests
     def test_init__tests_from_any_iterable(self):
         def tests():
             yield unittest.FunctionTestCase(lambda: None)
             yield unittest.FunctionTestCase(lambda: None)
-    
+
         suite_1 = unittest.TestSuite(tests())
         self.assertEqual(suite_1.countTestCases(), 2)
-        
+
         suite_2 = unittest.TestSuite(suite_1)
         self.assertEqual(suite_2.countTestCases(), 2)
-        
+
         suite_3 = unittest.TestSuite(set(suite_1))
         self.assertEqual(suite_3.countTestCases(), 2)
-        
+
     # "class TestSuite([tests])"
     # ...
     # "If tests is given, it must be an iterable of individual test cases
@@ -1397,10 +1397,10 @@ class Test_TestSuite(TestCase, TestEquality):
             ftc = unittest.FunctionTestCase(lambda: None)
             yield unittest.TestSuite([ftc])
             yield unittest.FunctionTestCase(lambda: None)
-    
+
         suite = unittest.TestSuite(tests())
         self.assertEqual(suite.countTestCases(), 2)
-        
+
     ################################################################
     ### /Tests for TestSuite.__init__
 
@@ -1409,19 +1409,19 @@ class Test_TestSuite(TestCase, TestEquality):
         test1 = unittest.FunctionTestCase(lambda: None)
         test2 = unittest.FunctionTestCase(lambda: None)
         suite = unittest.TestSuite((test1, test2))
-        
+
         self.assertEqual(list(suite), [test1, test2])
-    
+
     # "Return the number of tests represented by the this test object.
     # ...this method is also implemented by the TestSuite class, which can
     # return larger [greater than 1] values"
     #
-    # Presumably an empty TestSuite returns 0?   
+    # Presumably an empty TestSuite returns 0?
     def test_countTestCases_zero_simple(self):
         suite = unittest.TestSuite()
-        
+
         self.assertEqual(suite.countTestCases(), 0)
-    
+
     # "Return the number of tests represented by the this test object.
     # ...this method is also implemented by the TestSuite class, which can
     # return larger [greater than 1] values"
@@ -1434,9 +1434,9 @@ class Test_TestSuite(TestCase, TestEquality):
                 pass
 
         suite = unittest.TestSuite([unittest.TestSuite()])
-        
+
         self.assertEqual(suite.countTestCases(), 0)
-    
+
     # "Return the number of tests represented by the this test object.
     # ...this method is also implemented by the TestSuite class, which can
     # return larger [greater than 1] values"
@@ -1444,9 +1444,9 @@ class Test_TestSuite(TestCase, TestEquality):
         test1 = unittest.FunctionTestCase(lambda: None)
         test2 = unittest.FunctionTestCase(lambda: None)
         suite = unittest.TestSuite((test1, test2))
-        
+
         self.assertEqual(suite.countTestCases(), 2)
-    
+
     # "Return the number of tests represented by the this test object.
     # ...this method is also implemented by the TestSuite class, which can
     # return larger [greater than 1] values"
@@ -1456,14 +1456,14 @@ class Test_TestSuite(TestCase, TestEquality):
         class Test1(unittest.TestCase):
             def test1(self): pass
             def test2(self): pass
-    
+
         test2 = unittest.FunctionTestCase(lambda: None)
         test3 = unittest.FunctionTestCase(lambda: None)
         child = unittest.TestSuite((Test1('test2'), test2))
         parent = unittest.TestSuite((test3, child, Test1('test1')))
-        
+
         self.assertEqual(parent.countTestCases(), 4)
-    
+
     # "Run the tests associated with this suite, collecting the result into
     # the test result object passed as result."
     #
@@ -1471,109 +1471,109 @@ class Test_TestSuite(TestCase, TestEquality):
     def test_run__empty_suite(self):
         events = []
         result = LoggingResult(events)
-    
+
         suite = unittest.TestSuite()
-        
+
         suite.run(result)
-        
+
         self.assertEqual(events, [])
-    
+
     # "Note that unlike TestCase.run(), TestSuite.run() requires the
     # "result object to be passed in."
     def test_run__requires_result(self):
         suite = unittest.TestSuite()
-        
+
         try:
             suite.run()
         except TypeError:
             pass
         else:
             self.fail("Failed to raise TypeError")
-    
+
     # "Run the tests associated with this suite, collecting the result into
-    # the test result object passed as result."        
+    # the test result object passed as result."
     def test_run(self):
         events = []
         result = LoggingResult(events)
-        
+
         class LoggingCase(unittest.TestCase):
             def run(self, result):
                 events.append('run %s' % self._testMethodName)
-                
+
             def test1(self): pass
             def test2(self): pass
-        
-        tests = [LoggingCase('test1'), LoggingCase('test2')]    
-        
+
+        tests = [LoggingCase('test1'), LoggingCase('test2')]
+
         unittest.TestSuite(tests).run(result)
-        
+
         self.assertEqual(events, ['run test1', 'run test2'])
-    
-    # "Add a TestCase ... to the suite"    
+
+    # "Add a TestCase ... to the suite"
     def test_addTest__TestCase(self):
         class Foo(unittest.TestCase):
             def test(self): pass
-    
+
         test = Foo('test')
         suite = unittest.TestSuite()
-        
+
         suite.addTest(test)
-        
+
         self.assertEqual(suite.countTestCases(), 1)
         self.assertEqual(list(suite), [test])
-        
-    # "Add a ... TestSuite to the suite"    
+
+    # "Add a ... TestSuite to the suite"
     def test_addTest__TestSuite(self):
         class Foo(unittest.TestCase):
             def test(self): pass
-    
+
         suite_2 = unittest.TestSuite([Foo('test')])
-        
+
         suite = unittest.TestSuite()
         suite.addTest(suite_2)
-        
+
         self.assertEqual(suite.countTestCases(), 1)
         self.assertEqual(list(suite), [suite_2])
-   
+
     # "Add all the tests from an iterable of TestCase and TestSuite
     # instances to this test suite."
-    # 
+    #
     # "This is equivalent to iterating over tests, calling addTest() for
-    # each element"        
+    # each element"
     def test_addTests(self):
         class Foo(unittest.TestCase):
             def test_1(self): pass
             def test_2(self): pass
-            
+
         test_1 = Foo('test_1')
         test_2 = Foo('test_2')
         inner_suite = unittest.TestSuite([test_2])
-            
+
         def gen():
             yield test_1
             yield test_2
             yield inner_suite
-            
+
         suite_1 = unittest.TestSuite()
         suite_1.addTests(gen())
-        
+
         self.assertEqual(list(suite_1), list(gen()))
-        
+
         # "This is equivalent to iterating over tests, calling addTest() for
-        # each element" 
+        # each element"
         suite_2 = unittest.TestSuite()
         for t in gen():
             suite_2.addTest(t)
-            
+
         self.assertEqual(suite_1, suite_2)
-    
+
     # "Add all the tests from an iterable of TestCase and TestSuite
     # instances to this test suite."
     #
-    # What happens if it doesn't get an iterable?    
+    # What happens if it doesn't get an iterable?
     def test_addTest__noniterable(self):
         suite = unittest.TestSuite()
-        
+
         try:
             suite.addTests(5)
         except TypeError:
@@ -1593,17 +1593,17 @@ class Test_TestSuite(TestCase, TestEquality):
     def test_addTests__string(self):
         suite = unittest.TestSuite()
         self.assertRaises(TypeError, suite.addTests, "foo")
-            
-        
+
+
 class Test_FunctionTestCase(TestCase):
-    
+
     # "Return the number of tests represented by the this test object. For
-    # TestCase instances, this will always be 1"    
+    # TestCase instances, this will always be 1"
     def test_countTestCases(self):
         test = unittest.FunctionTestCase(lambda: None)
-            
+
         self.assertEqual(test.countTestCases(), 1)
-    
+
     # "When a setUp() method is defined, the test runner will run that method
     # prior to each test. Likewise, if a tearDown() method is defined, the
     # test runner will invoke that method after each test. In the example,
@@ -1614,7 +1614,7 @@ class Test_FunctionTestCase(TestCase):
     def test_run_call_order__error_in_setUp(self):
         events = []
         result = LoggingResult(events)
-    
+
         def setUp():
             events.append('setUp')
             raise RuntimeError('raised by setUp')
@@ -1624,11 +1624,11 @@ class Test_FunctionTestCase(TestCase):
 
         def tearDown():
             events.append('tearDown')
-        
-        expected = ['startTest', 'setUp', 'addError', 'stopTest']  
+
+        expected = ['startTest', 'setUp', 'addError', 'stopTest']
         unittest.FunctionTestCase(test, setUp, tearDown).run(result)
         self.assertEqual(events, expected)
-        
+
     # "When a setUp() method is defined, the test runner will run that method
     # prior to each test. Likewise, if a tearDown() method is defined, the
     # test runner will invoke that method after each test. In the example,
@@ -1639,7 +1639,7 @@ class Test_FunctionTestCase(TestCase):
     def test_run_call_order__error_in_test(self):
         events = []
         result = LoggingResult(events)
-    
+
         def setUp():
             events.append('setUp')
 
@@ -1649,12 +1649,12 @@ class Test_FunctionTestCase(TestCase):
 
         def tearDown():
             events.append('tearDown')
-        
+
         expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
                     'stopTest']
         unittest.FunctionTestCase(test, setUp, tearDown).run(result)
         self.assertEqual(events, expected)
-        
+
     # "When a setUp() method is defined, the test runner will run that method
     # prior to each test. Likewise, if a tearDown() method is defined, the
     # test runner will invoke that method after each test. In the example,
@@ -1665,7 +1665,7 @@ class Test_FunctionTestCase(TestCase):
     def test_run_call_order__failure_in_test(self):
         events = []
         result = LoggingResult(events)
-    
+
         def setUp():
             events.append('setUp')
 
@@ -1675,12 +1675,12 @@ class Test_FunctionTestCase(TestCase):
 
         def tearDown():
             events.append('tearDown')
-        
+
         expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
                     'stopTest']
         unittest.FunctionTestCase(test, setUp, tearDown).run(result)
         self.assertEqual(events, expected)
-        
+
     # "When a setUp() method is defined, the test runner will run that method
     # prior to each test. Likewise, if a tearDown() method is defined, the
     # test runner will invoke that method after each test. In the example,
@@ -1691,7 +1691,7 @@ class Test_FunctionTestCase(TestCase):
     def test_run_call_order__error_in_tearDown(self):
         events = []
         result = LoggingResult(events)
-    
+
         def setUp():
             events.append('setUp')
 
@@ -1701,12 +1701,12 @@ class Test_FunctionTestCase(TestCase):
         def tearDown():
             events.append('tearDown')
             raise RuntimeError('raised by tearDown')
-          
+
         expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
                     'stopTest']
         unittest.FunctionTestCase(test, setUp, tearDown).run(result)
         self.assertEqual(events, expected)
-        
+
     # "Return a string identifying the specific test case."
     #
     # Because of the vague nature of the docs, I'm not going to lock this
@@ -1715,26 +1715,26 @@ class Test_FunctionTestCase(TestCase):
     # just say "string")
     def test_id(self):
         test = unittest.FunctionTestCase(lambda: None)
-                
+
         self.failUnless(isinstance(test.id(), basestring))
-    
+
     # "Returns a one-line description of the test, or None if no description
     # has been provided. The default implementation of this method returns
-    # the first line of the test method's docstring, if available, or None."    
+    # the first line of the test method's docstring, if available, or None."
     def test_shortDescription__no_docstring(self):
         test = unittest.FunctionTestCase(lambda: None)
-                
+
         self.assertEqual(test.shortDescription(), None)
-        
+
     # "Returns a one-line description of the test, or None if no description
     # has been provided. The default implementation of this method returns
-    # the first line of the test method's docstring, if available, or None."    
+    # the first line of the test method's docstring, if available, or None."
     def test_shortDescription__singleline_docstring(self):
         desc = "this tests foo"
         test = unittest.FunctionTestCase(lambda: None, description=desc)
-                
+
         self.assertEqual(test.shortDescription(), "this tests foo")
-    
+
 class Test_TestResult(TestCase):
     # Note: there are not separate tests for TestResult.wasSuccessful(),
     # TestResult.errors, TestResult.failures, TestResult.testsRun or
@@ -1744,75 +1744,75 @@ class Test_TestResult(TestCase):
     # Accordingly, tests for the aforenamed attributes are incorporated
     # in with the tests for the defining methods.
     ################################################################
-    
+
     def test_init(self):
         result = unittest.TestResult()
-        
+
         self.failUnless(result.wasSuccessful())
         self.assertEqual(len(result.errors), 0)
         self.assertEqual(len(result.failures), 0)
         self.assertEqual(result.testsRun, 0)
         self.assertEqual(result.shouldStop, False)
-    
+
     # "This method can be called to signal that the set of tests being
     # run should be aborted by setting the TestResult's shouldStop
-    # attribute to True."    
+    # attribute to True."
     def test_stop(self):
         result = unittest.TestResult()
-        
+
         result.stop()
-        
+
         self.assertEqual(result.shouldStop, True)
-    
+
     # "Called when the test case test is about to be run. The default
     # implementation simply increments the instance's testsRun counter."
     def test_startTest(self):
         class Foo(unittest.TestCase):
             def test_1(self):
                 pass
-                
+
         test = Foo('test_1')
-    
+
         result = unittest.TestResult()
-        
+
         result.startTest(test)
-        
+
         self.failUnless(result.wasSuccessful())
         self.assertEqual(len(result.errors), 0)
         self.assertEqual(len(result.failures), 0)
         self.assertEqual(result.testsRun, 1)
         self.assertEqual(result.shouldStop, False)
-        
+
         result.stopTest(test)
-        
+
     # "Called after the test case test has been executed, regardless of
     # the outcome. The default implementation does nothing."
     def test_stopTest(self):
         class Foo(unittest.TestCase):
             def test_1(self):
                 pass
-                
+
         test = Foo('test_1')
-    
+
         result = unittest.TestResult()
-        
+
         result.startTest(test)
-        
+
         self.failUnless(result.wasSuccessful())
         self.assertEqual(len(result.errors), 0)
         self.assertEqual(len(result.failures), 0)
         self.assertEqual(result.testsRun, 1)
         self.assertEqual(result.shouldStop, False)
-        
+
         result.stopTest(test)
-        
+
         # Same tests as above; make sure nothing has changed
         self.failUnless(result.wasSuccessful())
         self.assertEqual(len(result.errors), 0)
         self.assertEqual(len(result.failures), 0)
         self.assertEqual(result.testsRun, 1)
         self.assertEqual(result.shouldStop, False)
-    
+
     # "addSuccess(test)"
     # ...
     # "Called when the test case test succeeds"
@@ -1836,21 +1836,21 @@ class Test_TestResult(TestCase):
         class Foo(unittest.TestCase):
             def test_1(self):
                 pass
-                
+
         test = Foo('test_1')
-    
+
         result = unittest.TestResult()
-        
+
         result.startTest(test)
         result.addSuccess(test)
         result.stopTest(test)
-        
+
         self.failUnless(result.wasSuccessful())
         self.assertEqual(len(result.errors), 0)
         self.assertEqual(len(result.failures), 0)
         self.assertEqual(result.testsRun, 1)
         self.assertEqual(result.shouldStop, False)
-        
+
     # "addFailure(test, err)"
     # ...
     # "Called when the test case test signals a failure. err is a tuple of
@@ -1873,33 +1873,33 @@ class Test_TestResult(TestCase):
     # of sys.exc_info() results."
     def test_addFailure(self):
         import sys
-    
+
         class Foo(unittest.TestCase):
             def test_1(self):
                 pass
-                
+
         test = Foo('test_1')
         try:
             test.fail("foo")
         except:
             exc_info_tuple = sys.exc_info()
-    
+
         result = unittest.TestResult()
-        
+
         result.startTest(test)
         result.addFailure(test, exc_info_tuple)
         result.stopTest(test)
-        
+
         self.failIf(result.wasSuccessful())
         self.assertEqual(len(result.errors), 0)
         self.assertEqual(len(result.failures), 1)
         self.assertEqual(result.testsRun, 1)
         self.assertEqual(result.shouldStop, False)
-        
+
         test_case, formatted_exc = result.failures[0]
         self.failUnless(test_case is test)
         self.failUnless(isinstance(formatted_exc, str))
-    
+
     # "addError(test, err)"
     # ...
     # "Called when the test case test raises an unexpected exception err
@@ -1923,29 +1923,29 @@ class Test_TestResult(TestCase):
     # of sys.exc_info() results."
     def test_addError(self):
         import sys
-    
+
         class Foo(unittest.TestCase):
             def test_1(self):
                 pass
-                
+
         test = Foo('test_1')
         try:
             raise TypeError()
         except:
             exc_info_tuple = sys.exc_info()
-    
+
         result = unittest.TestResult()
-        
+
         result.startTest(test)
         result.addError(test, exc_info_tuple)
         result.stopTest(test)
-        
+
         self.failIf(result.wasSuccessful())
         self.assertEqual(len(result.errors), 1)
         self.assertEqual(len(result.failures), 0)
         self.assertEqual(result.testsRun, 1)
         self.assertEqual(result.shouldStop, False)
-        
+
         test_case, formatted_exc = result.errors[0]
         self.failUnless(test_case is test)
         self.failUnless(isinstance(formatted_exc, str))
@@ -1956,10 +1956,10 @@ class Test_TestResult(TestCase):
 class Foo(unittest.TestCase):
     def runTest(self): pass
     def test1(self): pass
-    
+
 class Bar(Foo):
     def test2(self): pass
-    
+
 ################################################################
 ### /Support code for Test_TestCase
 
@@ -1970,15 +1970,15 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
 
     # Used by TestHashing.test_hash and TestEquality.test_eq
     eq_pairs = [(Foo('test1'), Foo('test1'))]
-    
+
     # Used by TestEquality.test_ne
     ne_pairs = [(Foo('test1'), Foo('runTest'))
                ,(Foo('test1'), Bar('test1'))
                ,(Foo('test1'), Bar('test2'))]
-    
+
     ################################################################
     ### /Set up attributes used by inherited tests
-    
+
 
     # "class TestCase([methodName])"
     # ...
@@ -1993,44 +1993,44 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
         class Test(unittest.TestCase):
             def runTest(self): raise MyException()
             def test(self): pass
-                
+
         self.assertEqual(Test().id()[-13:], '.Test.runTest')
-    
+
     # "class TestCase([methodName])"
     # ...
     # "Each instance of TestCase will run a single test method: the
-    # method named methodName."    
+    # method named methodName."
     def test_init__test_name__valid(self):
         class Test(unittest.TestCase):
             def runTest(self): raise MyException()
             def test(self): pass
-                
+
         self.assertEqual(Test('test').id()[-10:], '.Test.test')
-    
+
     # "class TestCase([methodName])"
     # ...
     # "Each instance of TestCase will run a single test method: the
-    # method named methodName."    
+    # method named methodName."
     def test_init__test_name__invalid(self):
         class Test(unittest.TestCase):
             def runTest(self): raise MyException()
             def test(self): pass
-                
+
         try:
             Test('testfoo')
         except ValueError:
             pass
         else:
             self.fail("Failed to raise ValueError")
-        
+
     # "Return the number of tests represented by the this test object. For
-    # TestCase instances, this will always be 1"    
+    # TestCase instances, this will always be 1"
     def test_countTestCases(self):
         class Foo(unittest.TestCase):
             def test(self): pass
-            
+
         self.assertEqual(Foo('test').countTestCases(), 1)
-        
+
     # "Return the default type of test result object to be used to run this
     # test. For TestCase instances, this will always be
     # unittest.TestResult;  subclasses of TestCase should
@@ -2039,7 +2039,7 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
         class Foo(unittest.TestCase):
             def runTest(self):
                 pass
-        
+
         result = Foo().defaultTestResult()
         self.assertEqual(type(result), unittest.TestResult)
 
@@ -2053,22 +2053,22 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
     def test_run_call_order__error_in_setUp(self):
         events = []
         result = LoggingResult(events)
-    
+
         class Foo(unittest.TestCase):
             def setUp(self):
                 events.append('setUp')
                 raise RuntimeError('raised by Foo.setUp')
-                
+
             def test(self):
                 events.append('test')
-                
+
             def tearDown(self):
                 events.append('tearDown')
-          
+
         Foo('test').run(result)
         expected = ['startTest', 'setUp', 'addError', 'stopTest']
         self.assertEqual(events, expected)
-        
+
     # "When a setUp() method is defined, the test runner will run that method
     # prior to each test. Likewise, if a tearDown() method is defined, the
     # test runner will invoke that method after each test. In the example,
@@ -2079,23 +2079,23 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
     def test_run_call_order__error_in_test(self):
         events = []
         result = LoggingResult(events)
-    
+
         class Foo(unittest.TestCase):
             def setUp(self):
                 events.append('setUp')
-                
+
             def test(self):
                 events.append('test')
                 raise RuntimeError('raised by Foo.test')
-                
+
             def tearDown(self):
                 events.append('tearDown')
-        
+
         expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
                     'stopTest']
         Foo('test').run(result)
         self.assertEqual(events, expected)
-        
+
     # "When a setUp() method is defined, the test runner will run that method
     # prior to each test. Likewise, if a tearDown() method is defined, the
     # test runner will invoke that method after each test. In the example,
@@ -2106,23 +2106,23 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
     def test_run_call_order__failure_in_test(self):
         events = []
         result = LoggingResult(events)
-    
+
         class Foo(unittest.TestCase):
             def setUp(self):
                 events.append('setUp')
-                
+
             def test(self):
                 events.append('test')
                 self.fail('raised by Foo.test')
-                
+
             def tearDown(self):
                 events.append('tearDown')
-        
+
         expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
                     'stopTest']
         Foo('test').run(result)
         self.assertEqual(events, expected)
-        
+
     # "When a setUp() method is defined, the test runner will run that method
     # prior to each test. Likewise, if a tearDown() method is defined, the
     # test runner will invoke that method after each test. In the example,
@@ -2133,23 +2133,23 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
     def test_run_call_order__error_in_tearDown(self):
         events = []
         result = LoggingResult(events)
-    
+
         class Foo(unittest.TestCase):
             def setUp(self):
                 events.append('setUp')
-                
+
             def test(self):
                 events.append('test')
-                
+
             def tearDown(self):
                 events.append('tearDown')
                 raise RuntimeError('raised by Foo.tearDown')
-          
+
         Foo('test').run(result)
         expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
                     'stopTest']
         self.assertEqual(events, expected)
-    
+
     # "This class attribute gives the exception raised by the test() method.
     # If a test framework needs to use a specialized exception, possibly to
     # carry additional information, it must subclass this exception in
@@ -2159,9 +2159,9 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
         class Foo(unittest.TestCase):
             def test(self):
                 pass
-    
+
         self.failUnless(Foo('test').failureException is AssertionError)
-    
+
     # "This class attribute gives the exception raised by the test() method.
     # If a test framework needs to use a specialized exception, possibly to
     # carry additional information, it must subclass this exception in
@@ -2171,20 +2171,20 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
     def test_failureException__subclassing__explicit_raise(self):
         events = []
         result = LoggingResult(events)
-    
+
         class Foo(unittest.TestCase):
             def test(self):
                 raise RuntimeError()
-                
+
             failureException = RuntimeError
-            
+
         self.failUnless(Foo('test').failureException is RuntimeError)
-        
-        
+
+
         Foo('test').run(result)
         expected = ['startTest', 'addFailure', 'stopTest']
         self.assertEqual(events, expected)
-        
+
     # "This class attribute gives the exception raised by the test() method.
     # If a test framework needs to use a specialized exception, possibly to
     # carry additional information, it must subclass this exception in
@@ -2194,38 +2194,38 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
     def test_failureException__subclassing__implicit_raise(self):
         events = []
         result = LoggingResult(events)
-    
+
         class Foo(unittest.TestCase):
             def test(self):
                 self.fail("foo")
-                
+
             failureException = RuntimeError
-            
+
         self.failUnless(Foo('test').failureException is RuntimeError)
-        
-        
+
+
         Foo('test').run(result)
         expected = ['startTest', 'addFailure', 'stopTest']
         self.assertEqual(events, expected)
-    
-    # "The default implementation does nothing."    
+
+    # "The default implementation does nothing."
     def test_setUp(self):
         class Foo(unittest.TestCase):
             def runTest(self):
                 pass
-    
+
         # ... and nothing should happen
         Foo().setUp()
-        
-    # "The default implementation does nothing."    
+
+    # "The default implementation does nothing."
     def test_tearDown(self):
         class Foo(unittest.TestCase):
             def runTest(self):
                 pass
-    
+
         # ... and nothing should happen
         Foo().tearDown()
-        
+
     # "Return a string identifying the specific test case."
     #
     # Because of the vague nature of the docs, I'm not going to lock this
@@ -2236,57 +2236,57 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
         class Foo(unittest.TestCase):
             def runTest(self):
                 pass
-                
+
         self.failUnless(isinstance(Foo().id(), basestring))
-    
+
     # "Returns a one-line description of the test, or None if no description
     # has been provided. The default implementation of this method returns
-    # the first line of the test method's docstring, if available, or None."    
+    # the first line of the test method's docstring, if available, or None."
     def test_shortDescription__no_docstring(self):
         class Foo(unittest.TestCase):
             def runTest(self):
                 pass
-                
+
         self.assertEqual(Foo().shortDescription(), None)
-        
+
     # "Returns a one-line description of the test, or None if no description
     # has been provided. The default implementation of this method returns
-    # the first line of the test method's docstring, if available, or None."    
+    # the first line of the test method's docstring, if available, or None."
     def test_shortDescription__singleline_docstring(self):
         class Foo(unittest.TestCase):
             def runTest(self):
                 "this tests foo"
                 pass
-                
+
         self.assertEqual(Foo().shortDescription(), "this tests foo")
-        
+
     # "Returns a one-line description of the test, or None if no description
     # has been provided. The default implementation of this method returns
-    # the first line of the test method's docstring, if available, or None."    
+    # the first line of the test method's docstring, if available, or None."
     def test_shortDescription__multiline_docstring(self):
         class Foo(unittest.TestCase):
             def runTest(self):
                 """this tests foo
                 blah, bar and baz are also tested"""
                 pass
-                
+
         self.assertEqual(Foo().shortDescription(), "this tests foo")
-    
+
     # "If result is omitted or None, a temporary result object is created
-    # and used, but is not made available to the caller"    
+    # and used, but is not made available to the caller"
     def test_run__uses_defaultTestResult(self):
         events = []
-    
+
         class Foo(unittest.TestCase):
             def test(self):
                 events.append('test')
-                
+
             def defaultTestResult(self):
                 return LoggingResult(events)
-        
-        # Make run() find a result object on its own        
+
+        # Make run() find a result object on its own
         Foo('test').run()
-        
+
         expected = ['startTest', 'test', 'stopTest']
         self.assertEqual(events, expected)
 
@@ -2299,4 +2299,4 @@ def test_main():
         Test_TestSuite, Test_TestResult, Test_FunctionTestCase)
 
 if __name__ == "__main__":
-    test_main() 
+    test_main()

Lib/test/test_zipfile.py

@@ -117,12 +117,12 @@ class TestsWithSourceFile(unittest.TestCase):
             if not read_data:
                 break
             zipdata2.append(read_data)
-                    
+
         self.assertEqual(''.join(zipdata1), self.data)
         self.assertEqual(''.join(zipdata2), self.data)
         zipfp.close()
-            
-    def testOpenStored(self):            
+
+    def testOpenStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipOpenTest(f, zipfile.ZIP_STORED)
 
@@ -141,11 +141,11 @@ class TestsWithSourceFile(unittest.TestCase):
 
         self.assertEqual(''.join(zipdata1), self.data)
         zipfp.close()
-    
-    def testRandomOpenStored(self):            
+
+    def testRandomOpenStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipRandomOpenTest(f, zipfile.ZIP_STORED)
-            
+
     def zipReadlineTest(self, f, compression):
         self.makeTestArchive(f, compression)
 
@@ -178,16 +178,16 @@ class TestsWithSourceFile(unittest.TestCase):
             self.assertEqual(zipline, line + '\n')
 
         zipfp.close()
-    
-    def testReadlineStored(self):            
+
+    def testReadlineStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipReadlineTest(f, zipfile.ZIP_STORED)
 
-    def testReadlinesStored(self):            
+    def testReadlinesStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipReadlinesTest(f, zipfile.ZIP_STORED)
 
-    def testIterlinesStored(self):            
+    def testIterlinesStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipIterlinesTest(f, zipfile.ZIP_STORED)
 
@@ -204,18 +204,18 @@ class TestsWithSourceFile(unittest.TestCase):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.zipRandomOpenTest(f, zipfile.ZIP_DEFLATED)
 
-        def testReadlineDeflated(self):            
+        def testReadlineDeflated(self):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.zipReadlineTest(f, zipfile.ZIP_DEFLATED)
 
-        def testReadlinesDeflated(self):            
+        def testReadlinesDeflated(self):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.zipReadlinesTest(f, zipfile.ZIP_DEFLATED)
 
-        def testIterlinesDeflated(self):            
+        def testIterlinesDeflated(self):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.zipIterlinesTest(f, zipfile.ZIP_DEFLATED)
-                
+
         def testLowCompression(self):
             # Checks for cases where compressed data is larger than original
             # Create the ZIP archive
@@ -437,10 +437,10 @@ class OtherTests(unittest.TestCase):
     def testCreateNonExistentFileForAppend(self):
         if os.path.exists(TESTFN):
             os.unlink(TESTFN)
-            
+
         filename = 'testfile.txt'
         content = 'hello, world. this is some content.'
-        
+
         try:
             zf = zipfile.ZipFile(TESTFN, 'a')
             zf.writestr(filename, content)
@@ -453,9 +453,9 @@ class OtherTests(unittest.TestCase):
         zf = zipfile.ZipFile(TESTFN, 'r')
         self.assertEqual(zf.read(filename), content)
         zf.close()
-        
+
         os.unlink(TESTFN)
-        
+
     def testCloseErroneousFile(self):
         # This test checks that the ZipFile constructor closes the file object
         # it opens if there's an error in the file.  If it doesn't, the traceback
@@ -472,24 +472,24 @@ class OtherTests(unittest.TestCase):
             os.unlink(TESTFN)
 
     def testIsZipErroneousFile(self):
-        # This test checks that the is_zipfile function correctly identifies 
+        # This test checks that the is_zipfile function correctly identifies
         # a file that is not a zip file
         fp = open(TESTFN, "w")
         fp.write("this is not a legal zip file\n")
         fp.close()
-        chk = zipfile.is_zipfile(TESTFN) 
+        chk = zipfile.is_zipfile(TESTFN)
         os.unlink(TESTFN)
-        self.assert_(chk is False)       
+        self.assert_(chk is False)
 
     def testIsZipValidFile(self):
-        # This test checks that the is_zipfile function correctly identifies 
+        # This test checks that the is_zipfile function correctly identifies
         # a file that is a zip file
         zipf = zipfile.ZipFile(TESTFN, mode="w")
         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
         zipf.close()
-        chk = zipfile.is_zipfile(TESTFN) 
+        chk = zipfile.is_zipfile(TESTFN)
         os.unlink(TESTFN)
-        self.assert_(chk is True)       
+        self.assert_(chk is True)
 
     def testNonExistentFileRaisesIOError(self):
         # make sure we don't raise an AttributeError when a partially-constructed
@@ -552,7 +552,7 @@ class DecryptionTests(unittest.TestCase):
     def testBadPassword(self):
         self.zip.setpassword("perl")
         self.assertRaises(RuntimeError, self.zip.read, "test.txt")
-            
+
     def testGoodPassword(self):
         self.zip.setpassword("python")
         self.assertEquals(self.zip.read("test.txt"), self.plain)
@@ -589,7 +589,7 @@ class TestsWithRandomBinaryFiles(unittest.TestCase):
     def testStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipTest(f, zipfile.ZIP_STORED)
-            
+
     def zipOpenTest(self, f, compression):
         self.makeTestArchive(f, compression)
 
@@ -610,17 +610,17 @@ class TestsWithRandomBinaryFiles(unittest.TestCase):
             if not read_data:
                 break
             zipdata2.append(read_data)
-                    
-        testdata1 = ''.join(zipdata1)               
+
+        testdata1 = ''.join(zipdata1)
         self.assertEqual(len(testdata1), len(self.data))
         self.assertEqual(testdata1, self.data)
 
-        testdata2 = ''.join(zipdata2)               
+        testdata2 = ''.join(zipdata2)
         self.assertEqual(len(testdata1), len(self.data))
         self.assertEqual(testdata1, self.data)
         zipfp.close()
-            
-    def testOpenStored(self):            
+
+    def testOpenStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipOpenTest(f, zipfile.ZIP_STORED)
 
@@ -641,8 +641,8 @@ class TestsWithRandomBinaryFiles(unittest.TestCase):
         self.assertEqual(len(testdata), len(self.data))
         self.assertEqual(testdata, self.data)
         zipfp.close()
-    
-    def testRandomOpenStored(self):            
+
+    def testRandomOpenStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.zipRandomOpenTest(f, zipfile.ZIP_STORED)
 
@@ -653,7 +653,7 @@ class TestsWithMultipleOpens(unittest.TestCase):
         zipfp.writestr('ones', '1'*FIXEDTEST_SIZE)
         zipfp.writestr('twos', '2'*FIXEDTEST_SIZE)
         zipfp.close()
-                
+
     def testSameFile(self):
         # Verify that (when the ZipFile is in control of creating file objects)
         # multiple open() calls can be made without interfering with each other.
@@ -694,10 +694,10 @@ class TestsWithMultipleOpens(unittest.TestCase):
         self.assertEqual(data1, '1'*FIXEDTEST_SIZE)
         self.assertEqual(data2, '2'*FIXEDTEST_SIZE)
         zipf.close()
-       
+
     def tearDown(self):
         os.remove(TESTFN2)
-        
+
 
 class UniversalNewlineTests(unittest.TestCase):
     def setUp(self):
@@ -726,7 +726,7 @@ class UniversalNewlineTests(unittest.TestCase):
             self.assertEqual(self.arcdata[sep], zipdata)
 
         zipfp.close()
-        
+
     def readlineTest(self, f, compression):
         self.makeTestArchive(f, compression)
 
@@ -763,36 +763,36 @@ class UniversalNewlineTests(unittest.TestCase):
 
         zipfp.close()
 
-    def testReadStored(self):         
+    def testReadStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.readTest(f, zipfile.ZIP_STORED)
-    
-    def testReadlineStored(self):         
+
+    def testReadlineStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.readlineTest(f, zipfile.ZIP_STORED)
 
-    def testReadlinesStored(self):            
+    def testReadlinesStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.readlinesTest(f, zipfile.ZIP_STORED)
 
-    def testIterlinesStored(self):            
+    def testIterlinesStored(self):
         for f in (TESTFN2, TemporaryFile(), StringIO()):
             self.iterlinesTest(f, zipfile.ZIP_STORED)
-       
+
     if zlib:
-        def testReadDeflated(self):            
+        def testReadDeflated(self):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.readTest(f, zipfile.ZIP_DEFLATED)
 
-        def testReadlineDeflated(self):            
+        def testReadlineDeflated(self):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.readlineTest(f, zipfile.ZIP_DEFLATED)
 
-        def testReadlinesDeflated(self):            
+        def testReadlinesDeflated(self):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.readlinesTest(f, zipfile.ZIP_DEFLATED)
 
-        def testIterlinesDeflated(self):            
+        def testIterlinesDeflated(self):
             for f in (TESTFN2, TemporaryFile(), StringIO()):
                 self.iterlinesTest(f, zipfile.ZIP_DEFLATED)
 
@@ -802,8 +802,8 @@ class UniversalNewlineTests(unittest.TestCase):
 
 
 def test_main():
-    run_unittest(TestsWithSourceFile, TestZip64InSmallFiles, OtherTests, 
-                 PyZipFileTests, DecryptionTests, TestsWithMultipleOpens, 
+    run_unittest(TestsWithSourceFile, TestZip64InSmallFiles, OtherTests,
+                 PyZipFileTests, DecryptionTests, TestsWithMultipleOpens,
                  UniversalNewlineTests, TestsWithRandomBinaryFiles)
 
     #run_unittest(TestZip64InSmallFiles)

Lib/urllib2.py

@@ -30,7 +30,7 @@ handler, the argument will be installed instead of the default.
 install_opener -- Installs a new opener as the default opener.
 
 objects of interest:
-OpenerDirector -- 
+OpenerDirector --
 
 Request -- An object that encapsulates the state of a request.  The
 state can be as simple as the URL.  It can also include extra HTTP

Lib/zipfile.py

@@ -357,9 +357,9 @@ class _ZipDecrypter:
 
 class ZipExtFile:
     """File-like object for reading an archive member.
-       Is returned by ZipFile.open(). 
+       Is returned by ZipFile.open().
     """
-    
+
     def __init__(self, fileobj, zipinfo, decrypt=None):
         self.fileobj = fileobj
         self.decrypter = decrypt
@@ -374,7 +374,7 @@ class ZipExtFile:
 
         self.compress_type = zipinfo.compress_type
         self.compress_size = zipinfo.compress_size
-        
+
         self.closed  = False
         self.mode    = "r"
         self.name = zipinfo.filename
@@ -386,7 +386,7 @@ class ZipExtFile:
 
     def set_univ_newlines(self, univ_newlines):
         self.univ_newlines = univ_newlines
-        
+
         # pick line separator char(s) based on universal newlines flag
         self.nlSeps = ("\n", )
         if self.univ_newlines:
@@ -394,7 +394,7 @@ class ZipExtFile:
 
     def __iter__(self):
         return self
-        
+
     def next(self):
         nextline = self.readline()
         if not nextline:
@@ -414,17 +414,17 @@ class ZipExtFile:
             if (self.lastdiscard, self.linebuffer[0]) == ('\r','\n'):
                 self.linebuffer = self.linebuffer[1:]
 
-            for sep in self.nlSeps:                
+            for sep in self.nlSeps:
                 nl = self.linebuffer.find(sep)
                 if nl >= 0:
                     nllen = len(sep)
                     return nl, nllen
 
         return nl, nllen
-        
+
     def readline(self, size = -1):
         """Read a line with approx. size. If size is negative,
-           read a whole line. 
+           read a whole line.
         """
         if size < 0:
             size = sys.maxint
@@ -433,7 +433,7 @@ class ZipExtFile:
 
         # check for a newline already in buffer
         nl, nllen = self._checkfornewline()
-        
+
         if nl >= 0:
             # the next line was already in the buffer
             nl = min(nl, size)
@@ -449,7 +449,7 @@ class ZipExtFile:
 
                 # check for a newline in buffer
                 nl, nllen = self._checkfornewline()
-                
+
             # we either ran out of bytes in the file, or
             # met the specified size limit without finding a newline,
             # so return current buffer
@@ -528,8 +528,8 @@ class ZipExtFile:
                     newdata = self.dc.decompress(newdata)
                     self.rawbuffer = self.dc.unconsumed_tail
                     if self.eof and len(self.rawbuffer) == 0:
-                        # we're out of raw bytes (both from the file and 
-                        # the local buffer); flush just to make sure the 
+                        # we're out of raw bytes (both from the file and
+                        # the local buffer); flush just to make sure the
                         # decompressor is done
                         newdata += self.dc.flush()
                         # prevent decompressor from being used again
@@ -547,7 +547,7 @@ class ZipExtFile:
             self.readbuffer = self.readbuffer[size:]
 
         return bytes
-  
+
 
 class ZipFile:
     """ Class with methods to open, read, write, close, list zip files.
@@ -738,7 +738,7 @@ class ZipFile:
             raise RuntimeError, \
                   "Attempt to read ZIP archive that was already closed"
 
-        # Only open a new file for instances where we were not 
+        # Only open a new file for instances where we were not
         # given a file object in the constructor
         if self._filePassed:
             zef_file = self.fp