Whitespace normalization.
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 @@
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 @@
# 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 @@
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 @@
# 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 @@
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 @@
>>> class A(object):
... pass
-
+
>>> class B(A, type):
... pass
Traceback (most recent call last):
@@ -1494,7 +1494,7 @@
... 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 @@
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 @@
if isinstance(other, self.__class__):
raise CustomException
return other
-
+
d = {}
x1 = BadDictKey()
x2 = BadDictKey()
@@ -502,7 +502,7 @@
# 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
# 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 @@
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 @@
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 @@
##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 @@
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 @@
## 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
def test_loadTestsFromTestCase__TestSuite_subclass(self):
class NotATestCase(unittest.TestSuite):
pass
-
+
loader = unittest.TestLoader()
try:
loader.loadTestsFromTestCase(NotATestCase)
@@ -125,7 +125,7 @@
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 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 @@
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 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 @@
# 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 @@
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 @@
# 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 @@
# 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 @@
# `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 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 @@
import new
m = new.module('m')
m.testcase_1 = object()
-
+
loader = unittest.TestLoader()
try:
loader.loadTestsFromName('testcase_1', m)
@@ -402,12 +402,12 @@
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 @@
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 @@
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 @@
def test(self):
pass
m.testcase_1 = MyTestCase
-
+
loader = unittest.TestLoader()
try:
loader.loadTestsFromName('testcase_1.testfoo', m)
@@ -476,12 +476,12 @@
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 @@
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 @@
def return_wrong():
return 6
m.return_wrong = return_wrong
-
+
loader = unittest.TestLoader()
try:
suite = loader.loadTestsFromName('return_wrong', m)
@@ -515,9 +515,9 @@
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 @@
# 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 @@
### 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 @@
# 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 @@
# 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 @@
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 @@
# 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 @@
# "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 @@
# 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 @@
# ...
# "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 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 @@
import new
m = new.module('m')
m.testcase_1 = object()
-
+
loader = unittest.TestLoader()
try:
loader.loadTestsFromNames(['testcase_1'], m)
@@ -771,14 +771,14 @@
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 @@
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 @@
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 @@
def test(self):
pass
m.testcase_1 = MyTestCase
-
+
loader = unittest.TestLoader()
try:
loader.loadTestsFromNames(['testcase_1.testfoo'], m)
@@ -843,14 +843,14 @@
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 @@
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 @@
def return_wrong():
return 6
m.return_wrong = return_wrong
-
+
loader = unittest.TestLoader()
try:
suite = loader.loadTestsFromNames(['return_wrong'], m)
@@ -911,9 +911,9 @@
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 @@
# 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 @@
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 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 @@
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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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 @@
def _mk_TestSuite(*names):
return unittest.TestSuite(Foo(n) for n in names)
-
+
################################################################
### /Support code for Test_TestSuite
@@ -1332,13 +1332,13 @@
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 @@
# 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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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 @@
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 @@
def test_run_call_order__error_in_test(self):
events = []
result = LoggingResult(events)
-
+
def setUp():
events.append('setUp')
@@ -1649,12 +1649,12 @@
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 @@
def test_run_call_order__failure_in_test(self):
events = []
result = LoggingResult(events)
-
+
def setUp():
events.append('setUp')
@@ -1675,12 +1675,12 @@
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 @@
def test_run_call_order__error_in_tearDown(self):
events = []
result = LoggingResult(events)
-
+
def setUp():
events.append('setUp')
@@ -1701,12 +1701,12 @@
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 @@
# 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 @@
# 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 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 @@
# 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 @@
# 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 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 @@
# 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(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 Foo(unittest.TestCase):
def runTest(self):
pass
-
+
result = Foo().defaultTestResult()
self.assertEqual(type(result), unittest.TestResult)
@@ -2053,22 +2053,22 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
self.assertEqual(self.arcdata[sep], zipdata)
zipfp.close()
-
+
def readlineTest(self, f, compression):
self.makeTestArchive(f, compression)
@@ -763,36 +763,36 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
def __iter__(self):
return self
-
+
def next(self):
nextline = self.readline()
if not nextline:
@@ -414,17 +414,17 @@
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 @@
# 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 @@
# 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 @@
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 @@
self.readbuffer = self.readbuffer[size:]
return bytes
-
+
class ZipFile:
""" Class with methods to open, read, write, close, list zip files.
@@ -738,7 +738,7 @@
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