Whitespace normalization.

1 files changed, 416 insertions, 416 deletions

diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py
index ac52e72..7e60548 100644
--- a/Lib/test/test_unittest.py
+++ b/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()