diff options
| -rw-r--r-- | Lib/SocketServer.py | 4 | ||||
| -rw-r--r-- | Lib/genericpath.py | 2 | ||||
| -rwxr-xr-x | Lib/smtplib.py | 2 | ||||
| -rw-r--r-- | Lib/subprocess.py | 2 | ||||
| -rw-r--r-- | Lib/test/test_curses.py | 2 | ||||
| -rw-r--r-- | Lib/test/test_descr.py | 4 | ||||
| -rw-r--r-- | Lib/test/test_dict.py | 10 | ||||
| -rw-r--r-- | Lib/test/test_import.py | 4 | ||||
| -rw-r--r-- | Lib/test/test_itertools.py | 8 | ||||
| -rw-r--r-- | Lib/test/test_posixpath.py | 4 | ||||
| -rw-r--r-- | Lib/test/test_pty.py | 26 | ||||
| -rw-r--r-- | Lib/test/test_sax.py | 2 | ||||
| -rw-r--r-- | Lib/test/test_set.py | 4 | ||||
| -rw-r--r-- | Lib/test/test_threadedtempfile.py | 10 | ||||
| -rw-r--r-- | Lib/test/test_unittest.py | 832 | ||||
| -rw-r--r-- | Lib/test/test_zipfile.py | 98 | ||||
| -rw-r--r-- | Lib/urllib2.py | 2 | ||||
| -rw-r--r-- | Lib/zipfile.py | 28 |
18 files changed, 522 insertions, 522 deletions
diff --git a/Lib/SocketServer.py b/Lib/SocketServer.py index f0f471a..5506aa5 100644 --- a/Lib/SocketServer.py +++ b/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. diff --git a/Lib/genericpath.py b/Lib/genericpath.py index 6d11ec0..e2bc7da 100644 --- a/Lib/genericpath.py +++ b/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.""" diff --git a/Lib/smtplib.py b/Lib/smtplib.py index 850c06a..4618671 100755 --- a/Lib/smtplib.py +++ b/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) diff --git a/Lib/subprocess.py b/Lib/subprocess.py index 0cb7ae6..80a60b9 100644 --- a/Lib/subprocess.py +++ b/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) diff --git a/Lib/test/test_curses.py b/Lib/test/test_curses.py index ff7b39d..b67dbe3 100644 --- a/Lib/test/test_curses.py +++ b/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" diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index 1c0b366..7e2313d 100644 --- a/Lib/test/test_descr.py +++ b/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 diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py index e15ac0b..7f0aabb 100644 --- a/Lib/test/test_dict.py +++ b/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 diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py index cc932a2..a061a40 100644 --- a/Lib/test/test_import.py +++ b/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 diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index 93fdab7..a8f625c 100644 --- a/Lib/test/test_itertools.py +++ b/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')) diff --git a/Lib/test/test_posixpath.py b/Lib/test/test_posixpath.py index 8ac5853..5632dcc 100644 --- a/Lib/test/test_posixpath.py +++ b/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: diff --git a/Lib/test/test_pty.py b/Lib/test/test_pty.py index f0a0a60..bfa624f 100644 --- a/Lib/test/test_pty.py +++ b/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): diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py index 2191f32..bb5e549 100644 --- a/Lib/test/test_sax.py +++ b/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(): diff --git a/Lib/test/test_set.py b/Lib/test/test_set.py index cd96581..28924d4 100644 --- a/Lib/test/test_set.py +++ b/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 diff --git a/Lib/test/test_threadedtempfile.py b/Lib/test/test_threadedtempfile.py index 5730323..753f388 100644 --- a/Lib/test/test_threadedtempfile.py +++ b/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) 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() diff --git a/Lib/test/test_zipfile.py b/Lib/test/test_zipfile.py index e0b255c..7957bab 100644 --- a/Lib/test/test_zipfile.py +++ b/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) diff --git a/Lib/urllib2.py b/Lib/urllib2.py index b0afac2..ba33030 100644 --- a/Lib/urllib2.py +++ b/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 diff --git a/Lib/zipfile.py b/Lib/zipfile.py index 8ac9cac..67d2c5d 100644 --- a/Lib/zipfile.py +++ b/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 |