diff options
author | Benjamin Peterson <benjamin@python.org> | 2009-06-30 22:57:08 (GMT) |
---|---|---|
committer | Benjamin Peterson <benjamin@python.org> | 2009-06-30 22:57:08 (GMT) |
commit | 5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e (patch) | |
tree | 41f38aca16748628d53906337f06fdf087f52314 /Lib/test/test_mailbox.py | |
parent | be96cf608fa656d7e53144cf85082ed5661e8c13 (diff) | |
download | cpython-5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e.zip cpython-5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e.tar.gz cpython-5c8da86f3a515ce1a6d5f27fd15e3c5f4d8e931e.tar.bz2 |
convert usage of fail* to assert*
Diffstat (limited to 'Lib/test/test_mailbox.py')
-rw-r--r-- | Lib/test/test_mailbox.py | 700 |
1 files changed, 350 insertions, 350 deletions
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py index 6342676..26758a3 100644 --- a/Lib/test/test_mailbox.py +++ b/Lib/test/test_mailbox.py @@ -22,17 +22,17 @@ class TestBase(unittest.TestCase): def _check_sample(self, msg): # Inspect a mailbox.Message representation of the sample message - self.assert_(isinstance(msg, email.message.Message)) - self.assert_(isinstance(msg, mailbox.Message)) + self.assertTrue(isinstance(msg, email.message.Message)) + self.assertTrue(isinstance(msg, mailbox.Message)) for key, value in _sample_headers.iteritems(): - self.assert_(value in msg.get_all(key)) - self.assert_(msg.is_multipart()) - self.assert_(len(msg.get_payload()) == len(_sample_payloads)) + self.assertTrue(value in msg.get_all(key)) + self.assertTrue(msg.is_multipart()) + self.assertTrue(len(msg.get_payload()) == len(_sample_payloads)) for i, payload in enumerate(_sample_payloads): part = msg.get_payload(i) - self.assert_(isinstance(part, email.message.Message)) - self.assert_(not isinstance(part, mailbox.Message)) - self.assert_(part.get_payload() == payload) + self.assertTrue(isinstance(part, email.message.Message)) + self.assertTrue(not isinstance(part, mailbox.Message)) + self.assertTrue(part.get_payload() == payload) def _delete_recursively(self, target): # Delete a file or delete a directory recursively @@ -65,16 +65,16 @@ class TestMailbox(TestBase): # Add copies of a sample message keys = [] keys.append(self._box.add(self._template % 0)) - self.assert_(len(self._box) == 1) + self.assertTrue(len(self._box) == 1) keys.append(self._box.add(mailbox.Message(_sample_message))) - self.assert_(len(self._box) == 2) + self.assertTrue(len(self._box) == 2) keys.append(self._box.add(email.message_from_string(_sample_message))) - self.assert_(len(self._box) == 3) + self.assertTrue(len(self._box) == 3) keys.append(self._box.add(StringIO.StringIO(_sample_message))) - self.assert_(len(self._box) == 4) + self.assertTrue(len(self._box) == 4) keys.append(self._box.add(_sample_message)) - self.assert_(len(self._box) == 5) - self.assert_(self._box.get_string(keys[0]) == self._template % 0) + self.assertTrue(len(self._box) == 5) + self.assertTrue(self._box.get_string(keys[0]) == self._template % 0) for i in (1, 2, 3, 4): self._check_sample(self._box[keys[i]]) @@ -90,23 +90,23 @@ class TestMailbox(TestBase): # (Used by test_remove() and test_delitem().) key0 = self._box.add(self._template % 0) key1 = self._box.add(self._template % 1) - self.assert_(len(self._box) == 2) + self.assertTrue(len(self._box) == 2) method(key0) l = len(self._box) - self.assert_(l == 1, "actual l: %s" % l) + self.assertTrue(l == 1, "actual l: %s" % l) self.assertRaises(KeyError, lambda: self._box[key0]) self.assertRaises(KeyError, lambda: method(key0)) - self.assert_(self._box.get_string(key1) == self._template % 1) + self.assertTrue(self._box.get_string(key1) == self._template % 1) key2 = self._box.add(self._template % 2) - self.assert_(len(self._box) == 2) + self.assertTrue(len(self._box) == 2) method(key2) l = len(self._box) - self.assert_(l == 1, "actual l: %s" % l) + self.assertTrue(l == 1, "actual l: %s" % l) self.assertRaises(KeyError, lambda: self._box[key2]) self.assertRaises(KeyError, lambda: method(key2)) - self.assert_(self._box.get_string(key1) == self._template % 1) + self.assertTrue(self._box.get_string(key1) == self._template % 1) method(key1) - self.assert_(len(self._box) == 0) + self.assertTrue(len(self._box) == 0) self.assertRaises(KeyError, lambda: self._box[key1]) self.assertRaises(KeyError, lambda: method(key1)) @@ -114,35 +114,35 @@ class TestMailbox(TestBase): # Discard messages key0 = self._box.add(self._template % 0) key1 = self._box.add(self._template % 1) - self.assert_(len(self._box) == 2) + self.assertTrue(len(self._box) == 2) self._box.discard(key0) - self.assert_(len(self._box) == 1) + self.assertTrue(len(self._box) == 1) self.assertRaises(KeyError, lambda: self._box[key0]) self._box.discard(key0) - self.assert_(len(self._box) == 1) + self.assertTrue(len(self._box) == 1) self.assertRaises(KeyError, lambda: self._box[key0]) def test_get(self): # Retrieve messages using get() key0 = self._box.add(self._template % 0) msg = self._box.get(key0) - self.assert_(msg['from'] == 'foo') - self.assert_(msg.get_payload() == '0') - self.assert_(self._box.get('foo') is None) - self.assert_(self._box.get('foo', False) is False) + self.assertTrue(msg['from'] == 'foo') + self.assertTrue(msg.get_payload() == '0') + self.assertTrue(self._box.get('foo') is None) + self.assertTrue(self._box.get('foo', False) is False) self._box.close() self._box = self._factory(self._path, factory=rfc822.Message) key1 = self._box.add(self._template % 1) msg = self._box.get(key1) - self.assert_(msg['from'] == 'foo') - self.assert_(msg.fp.read() == '1') + self.assertTrue(msg['from'] == 'foo') + self.assertTrue(msg.fp.read() == '1') def test_getitem(self): # Retrieve message using __getitem__() key0 = self._box.add(self._template % 0) msg = self._box[key0] - self.assert_(msg['from'] == 'foo') - self.assert_(msg.get_payload() == '0') + self.assertTrue(msg['from'] == 'foo') + self.assertTrue(msg.get_payload() == '0') self.assertRaises(KeyError, lambda: self._box['foo']) self._box.discard(key0) self.assertRaises(KeyError, lambda: self._box[key0]) @@ -152,25 +152,25 @@ class TestMailbox(TestBase): key0 = self._box.add(self._template % 0) key1 = self._box.add(_sample_message) msg0 = self._box.get_message(key0) - self.assert_(isinstance(msg0, mailbox.Message)) - self.assert_(msg0['from'] == 'foo') - self.assert_(msg0.get_payload() == '0') + self.assertTrue(isinstance(msg0, mailbox.Message)) + self.assertTrue(msg0['from'] == 'foo') + self.assertTrue(msg0.get_payload() == '0') self._check_sample(self._box.get_message(key1)) def test_get_string(self): # Get string representations of messages key0 = self._box.add(self._template % 0) key1 = self._box.add(_sample_message) - self.assert_(self._box.get_string(key0) == self._template % 0) - self.assert_(self._box.get_string(key1) == _sample_message) + self.assertTrue(self._box.get_string(key0) == self._template % 0) + self.assertTrue(self._box.get_string(key1) == _sample_message) def test_get_file(self): # Get file representations of messages key0 = self._box.add(self._template % 0) key1 = self._box.add(_sample_message) - self.assert_(self._box.get_file(key0).read().replace(os.linesep, '\n') + self.assertTrue(self._box.get_file(key0).read().replace(os.linesep, '\n') == self._template % 0) - self.assert_(self._box.get_file(key1).read().replace(os.linesep, '\n') + self.assertTrue(self._box.get_file(key1).read().replace(os.linesep, '\n') == _sample_message) def test_iterkeys(self): @@ -221,15 +221,15 @@ class TestMailbox(TestBase): returned_keys.append(key) returned_values.append(value) if do_keys: - self.assert_(len(keys) == len(returned_keys)) - self.assert_(set(keys) == set(returned_keys)) + self.assertTrue(len(keys) == len(returned_keys)) + self.assertTrue(set(keys) == set(returned_keys)) if do_values: count = 0 for value in returned_values: - self.assert_(value['from'] == 'foo') - self.assert_(int(value.get_payload()) < repetitions) + self.assertTrue(value['from'] == 'foo') + self.assertTrue(int(value.get_payload()) < repetitions) count += 1 - self.assert_(len(values) == count) + self.assertTrue(len(values) == count) def test_has_key(self): # Check existence of keys using has_key() @@ -241,61 +241,61 @@ class TestMailbox(TestBase): def _test_has_key_or_contains(self, method): # (Used by test_has_key() and test_contains().) - self.assert_(not method('foo')) + self.assertTrue(not method('foo')) key0 = self._box.add(self._template % 0) - self.assert_(method(key0)) - self.assert_(not method('foo')) + self.assertTrue(method(key0)) + self.assertTrue(not method('foo')) key1 = self._box.add(self._template % 1) - self.assert_(method(key1)) - self.assert_(method(key0)) - self.assert_(not method('foo')) + self.assertTrue(method(key1)) + self.assertTrue(method(key0)) + self.assertTrue(not method('foo')) self._box.remove(key0) - self.assert_(not method(key0)) - self.assert_(method(key1)) - self.assert_(not method('foo')) + self.assertTrue(not method(key0)) + self.assertTrue(method(key1)) + self.assertTrue(not method('foo')) self._box.remove(key1) - self.assert_(not method(key1)) - self.assert_(not method(key0)) - self.assert_(not method('foo')) + self.assertTrue(not method(key1)) + self.assertTrue(not method(key0)) + self.assertTrue(not method('foo')) def test_len(self, repetitions=10): # Get message count keys = [] for i in xrange(repetitions): - self.assert_(len(self._box) == i) + self.assertTrue(len(self._box) == i) keys.append(self._box.add(self._template % i)) - self.assert_(len(self._box) == i + 1) + self.assertTrue(len(self._box) == i + 1) for i in xrange(repetitions): - self.assert_(len(self._box) == repetitions - i) + self.assertTrue(len(self._box) == repetitions - i) self._box.remove(keys[i]) - self.assert_(len(self._box) == repetitions - i - 1) + self.assertTrue(len(self._box) == repetitions - i - 1) def test_set_item(self): # Modify messages using __setitem__() key0 = self._box.add(self._template % 'original 0') - self.assert_(self._box.get_string(key0) == \ + self.assertTrue(self._box.get_string(key0) == \ self._template % 'original 0') key1 = self._box.add(self._template % 'original 1') - self.assert_(self._box.get_string(key1) == \ + self.assertTrue(self._box.get_string(key1) == \ self._template % 'original 1') self._box[key0] = self._template % 'changed 0' - self.assert_(self._box.get_string(key0) == \ + self.assertTrue(self._box.get_string(key0) == \ self._template % 'changed 0') self._box[key1] = self._template % 'changed 1' - self.assert_(self._box.get_string(key1) == \ + self.assertTrue(self._box.get_string(key1) == \ self._template % 'changed 1') self._box[key0] = _sample_message self._check_sample(self._box[key0]) self._box[key1] = self._box[key0] self._check_sample(self._box[key1]) self._box[key0] = self._template % 'original 0' - self.assert_(self._box.get_string(key0) == + self.assertTrue(self._box.get_string(key0) == self._template % 'original 0') self._check_sample(self._box[key1]) self.assertRaises(KeyError, lambda: self._box.__setitem__('foo', 'bar')) self.assertRaises(KeyError, lambda: self._box['foo']) - self.assert_(len(self._box) == 2) + self.assertTrue(len(self._box) == 2) def test_clear(self, iterations=10): # Remove all messages using clear() @@ -303,29 +303,29 @@ class TestMailbox(TestBase): for i in xrange(iterations): self._box.add(self._template % i) for i, key in enumerate(keys): - self.assert_(self._box.get_string(key) == self._template % i) + self.assertTrue(self._box.get_string(key) == self._template % i) self._box.clear() - self.assert_(len(self._box) == 0) + self.assertTrue(len(self._box) == 0) for i, key in enumerate(keys): self.assertRaises(KeyError, lambda: self._box.get_string(key)) def test_pop(self): # Get and remove a message using pop() key0 = self._box.add(self._template % 0) - self.assert_(key0 in self._box) + self.assertTrue(key0 in self._box) key1 = self._box.add(self._template % 1) - self.assert_(key1 in self._box) - self.assert_(self._box.pop(key0).get_payload() == '0') - self.assert_(key0 not in self._box) - self.assert_(key1 in self._box) + self.assertTrue(key1 in self._box) + self.assertTrue(self._box.pop(key0).get_payload() == '0') + self.assertTrue(key0 not in self._box) + self.assertTrue(key1 in self._box) key2 = self._box.add(self._template % 2) - self.assert_(key2 in self._box) - self.assert_(self._box.pop(key2).get_payload() == '2') - self.assert_(key2 not in self._box) - self.assert_(key1 in self._box) - self.assert_(self._box.pop(key1).get_payload() == '1') - self.assert_(key1 not in self._box) - self.assert_(len(self._box) == 0) + self.assertTrue(key2 in self._box) + self.assertTrue(self._box.pop(key2).get_payload() == '2') + self.assertTrue(key2 not in self._box) + self.assertTrue(key1 in self._box) + self.assertTrue(self._box.pop(key1).get_payload() == '1') + self.assertTrue(key1 not in self._box) + self.assertTrue(len(self._box) == 0) def test_popitem(self, iterations=10): # Get and remove an arbitrary (key, message) using popitem() @@ -335,11 +335,11 @@ class TestMailbox(TestBase): seen = [] for i in xrange(10): key, msg = self._box.popitem() - self.assert_(key in keys) - self.assert_(key not in seen) + self.assertTrue(key in keys) + self.assertTrue(key not in seen) seen.append(key) - self.assert_(int(msg.get_payload()) == keys.index(key)) - self.assert_(len(self._box) == 0) + self.assertTrue(int(msg.get_payload()) == keys.index(key)) + self.assertTrue(len(self._box) == 0) for key in keys: self.assertRaises(KeyError, lambda: self._box[key]) @@ -350,31 +350,31 @@ class TestMailbox(TestBase): key2 = self._box.add(self._template % 'original 2') self._box.update({key0: self._template % 'changed 0', key2: _sample_message}) - self.assert_(len(self._box) == 3) - self.assert_(self._box.get_string(key0) == + self.assertTrue(len(self._box) == 3) + self.assertTrue(self._box.get_string(key0) == self._template % 'changed 0') - self.assert_(self._box.get_string(key1) == + self.assertTrue(self._box.get_string(key1) == self._template % 'original 1') self._check_sample(self._box[key2]) self._box.update([(key2, self._template % 'changed 2'), (key1, self._template % 'changed 1'), (key0, self._template % 'original 0')]) - self.assert_(len(self._box) == 3) - self.assert_(self._box.get_string(key0) == + self.assertTrue(len(self._box) == 3) + self.assertTrue(self._box.get_string(key0) == self._template % 'original 0') - self.assert_(self._box.get_string(key1) == + self.assertTrue(self._box.get_string(key1) == self._template % 'changed 1') - self.assert_(self._box.get_string(key2) == + self.assertTrue(self._box.get_string(key2) == self._template % 'changed 2') self.assertRaises(KeyError, lambda: self._box.update({'foo': 'bar', key0: self._template % "changed 0"})) - self.assert_(len(self._box) == 3) - self.assert_(self._box.get_string(key0) == + self.assertTrue(len(self._box) == 3) + self.assertTrue(self._box.get_string(key0) == self._template % "changed 0") - self.assert_(self._box.get_string(key1) == + self.assertTrue(self._box.get_string(key1) == self._template % "changed 1") - self.assert_(self._box.get_string(key2) == + self.assertTrue(self._box.get_string(key2) == self._template % "changed 2") def test_flush(self): @@ -383,11 +383,11 @@ class TestMailbox(TestBase): def test_lock_unlock(self): # Lock and unlock the mailbox - self.assert_(not os.path.exists(self._get_lock_path())) + self.assertTrue(not os.path.exists(self._get_lock_path())) self._box.lock() - self.assert_(os.path.exists(self._get_lock_path())) + self.assertTrue(os.path.exists(self._get_lock_path())) self._box.unlock() - self.assert_(not os.path.exists(self._get_lock_path())) + self.assertTrue(not os.path.exists(self._get_lock_path())) def test_close(self): # Close mailbox and flush changes to disk @@ -403,9 +403,9 @@ class TestMailbox(TestBase): self._box.close() self._box = self._factory(self._path) keys = self._box.keys() - self.assert_(len(keys) == 3) + self.assertTrue(len(keys) == 3) for key in keys: - self.assert_(self._box.get_string(key) in contents) + self.assertTrue(self._box.get_string(key) in contents) def test_dump_message(self): # Write message representations to disk @@ -413,7 +413,7 @@ class TestMailbox(TestBase): _sample_message, StringIO.StringIO(_sample_message)): output = StringIO.StringIO() self._box._dump_message(input, output) - self.assert_(output.getvalue() == + self.assertTrue(output.getvalue() == _sample_message.replace('\n', os.linesep)) output = StringIO.StringIO() self.assertRaises(TypeError, @@ -474,7 +474,7 @@ class TestMaildir(TestMailbox): msg.set_subdir('cur') msg.set_info('foo') key = self._box.add(msg) - self.assert_(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' % + self.assertTrue(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' % (key, self._box.colon)))) def test_get_MM(self): @@ -484,9 +484,9 @@ class TestMaildir(TestMailbox): msg.set_flags('RF') key = self._box.add(msg) msg_returned = self._box.get_message(key) - self.assert_(isinstance(msg_returned, mailbox.MaildirMessage)) - self.assert_(msg_returned.get_subdir() == 'cur') - self.assert_(msg_returned.get_flags() == 'FR') + self.assertTrue(isinstance(msg_returned, mailbox.MaildirMessage)) + self.assertTrue(msg_returned.get_subdir() == 'cur') + self.assertTrue(msg_returned.get_flags() == 'FR') def test_set_MM(self): # Set with a MaildirMessage instance @@ -494,22 +494,22 @@ class TestMaildir(TestMailbox): msg0.set_flags('TP') key = self._box.add(msg0) msg_returned = self._box.get_message(key) - self.assert_(msg_returned.get_subdir() == 'new') - self.assert_(msg_returned.get_flags() == 'PT') + self.assertTrue(msg_returned.get_subdir() == 'new') + self.assertTrue(msg_returned.get_flags() == 'PT') msg1 = mailbox.MaildirMessage(self._template % 1) self._box[key] = msg1 msg_returned = self._box.get_message(key) - self.assert_(msg_returned.get_subdir() == 'new') - self.assert_(msg_returned.get_flags() == '') - self.assert_(msg_returned.get_payload() == '1') + self.assertTrue(msg_returned.get_subdir() == 'new') + self.assertTrue(msg_returned.get_flags() == '') + self.assertTrue(msg_returned.get_payload() == '1') msg2 = mailbox.MaildirMessage(self._template % 2) msg2.set_info('2,S') self._box[key] = msg2 self._box[key] = self._template % 3 msg_returned = self._box.get_message(key) - self.assert_(msg_returned.get_subdir() == 'new') - self.assert_(msg_returned.get_flags() == 'S') - self.assert_(msg_returned.get_payload() == '3') + self.assertTrue(msg_returned.get_subdir() == 'new') + self.assertTrue(msg_returned.get_flags() == 'S') + self.assertTrue(msg_returned.get_payload() == '3') def test_consistent_factory(self): # Add a message. @@ -524,7 +524,7 @@ class TestMaildir(TestMailbox): box = mailbox.Maildir(self._path, factory=FakeMessage) box.colon = self._box.colon msg2 = box.get_message(key) - self.assert_(isinstance(msg2, FakeMessage)) + self.assertTrue(isinstance(msg2, FakeMessage)) def test_initialize_new(self): # Initialize a non-existent mailbox @@ -552,15 +552,15 @@ class TestMaildir(TestMailbox): for subdir in '', 'tmp', 'new', 'cur': path = os.path.join(self._path, subdir) mode = os.stat(path)[stat.ST_MODE] - self.assert_(stat.S_ISDIR(mode), "Not a directory: '%s'" % path) + self.assertTrue(stat.S_ISDIR(mode), "Not a directory: '%s'" % path) def test_list_folders(self): # List folders self._box.add_folder('one') self._box.add_folder('two') self._box.add_folder('three') - self.assert_(len(self._box.list_folders()) == 3) - self.assert_(set(self._box.list_folders()) == + self.assertTrue(len(self._box.list_folders()) == 3) + self.assertTrue(set(self._box.list_folders()) == set(('one', 'two', 'three'))) def test_get_folder(self): @@ -568,29 +568,29 @@ class TestMaildir(TestMailbox): self._box.add_folder('foo.bar') folder0 = self._box.get_folder('foo.bar') folder0.add(self._template % 'bar') - self.assert_(os.path.isdir(os.path.join(self._path, '.foo.bar'))) + self.assertTrue(os.path.isdir(os.path.join(self._path, '.foo.bar'))) folder1 = self._box.get_folder('foo.bar') - self.assert_(folder1.get_string(folder1.keys()[0]) == \ + self.assertTrue(folder1.get_string(folder1.keys()[0]) == \ self._template % 'bar') def test_add_and_remove_folders(self): # Delete folders self._box.add_folder('one') self._box.add_folder('two') - self.assert_(len(self._box.list_folders()) == 2) - self.assert_(set(self._box.list_folders()) == set(('one', 'two'))) + self.assertTrue(len(self._box.list_folders()) == 2) + self.assertTrue(set(self._box.list_folders()) == set(('one', 'two'))) self._box.remove_folder('one') - self.assert_(len(self._box.list_folders()) == 1) - self.assert_(set(self._box.list_folders()) == set(('two',))) + self.assertTrue(len(self._box.list_folders()) == 1) + self.assertTrue(set(self._box.list_folders()) == set(('two',))) self._box.add_folder('three') - self.assert_(len(self._box.list_folders()) == 2) - self.assert_(set(self._box.list_folders()) == set(('two', 'three'))) + self.assertTrue(len(self._box.list_folders()) == 2) + self.assertTrue(set(self._box.list_folders()) == set(('two', 'three'))) self._box.remove_folder('three') - self.assert_(len(self._box.list_folders()) == 1) - self.assert_(set(self._box.list_folders()) == set(('two',))) + self.assertTrue(len(self._box.list_folders()) == 1) + self.assertTrue(set(self._box.list_folders()) == set(('two',))) self._box.remove_folder('two') - self.assert_(len(self._box.list_folders()) == 0) - self.assert_(self._box.list_folders() == []) + self.assertTrue(len(self._box.list_folders()) == 0) + self.assertTrue(self._box.list_folders() == []) def test_clean(self): # Remove old files from 'tmp' @@ -603,14 +603,14 @@ class TestMaildir(TestMailbox): f.write("@") f.close() self._box.clean() - self.assert_(os.path.exists(foo_path)) - self.assert_(os.path.exists(bar_path)) + self.assertTrue(os.path.exists(foo_path)) + self.assertTrue(os.path.exists(bar_path)) foo_stat = os.stat(foo_path) os.utime(foo_path, (time.time() - 129600 - 2, foo_stat.st_mtime)) self._box.clean() - self.assert_(not os.path.exists(foo_path)) - self.assert_(os.path.exists(bar_path)) + self.assertTrue(not os.path.exists(foo_path)) + self.assertTrue(os.path.exists(bar_path)) def test_create_tmp(self, repetitions=10): # Create files in tmp directory @@ -630,49 +630,49 @@ class TestMaildir(TestMailbox): "tmp")), "File in wrong location: '%s'" % head) match = pattern.match(tail) - self.assert_(match is not None, "Invalid file name: '%s'" % tail) + self.assertTrue(match is not None, "Invalid file name: '%s'" % tail) groups = match.groups() if previous_groups is not None: - self.assert_(int(groups[0] >= previous_groups[0]), + self.assertTrue(int(groups[0] >= previous_groups[0]), "Non-monotonic seconds: '%s' before '%s'" % (previous_groups[0], groups[0])) - self.assert_(int(groups[1] >= previous_groups[1]) or + self.assertTrue(int(groups[1] >= previous_groups[1]) or groups[0] != groups[1], "Non-monotonic milliseconds: '%s' before '%s'" % (previous_groups[1], groups[1])) - self.assert_(int(groups[2]) == pid, + self.assertTrue(int(groups[2]) == pid, "Process ID mismatch: '%s' should be '%s'" % (groups[2], pid)) - self.assert_(int(groups[3]) == int(previous_groups[3]) + 1, + self.assertTrue(int(groups[3]) == int(previous_groups[3]) + 1, "Non-sequential counter: '%s' before '%s'" % (previous_groups[3], groups[3])) - self.assert_(groups[4] == hostname, + self.assertTrue(groups[4] == hostname, "Host name mismatch: '%s' should be '%s'" % (groups[4], hostname)) previous_groups = groups tmp_file.write(_sample_message) tmp_file.seek(0) - self.assert_(tmp_file.read() == _sample_message) + self.assertTrue(tmp_file.read() == _sample_message) tmp_file.close() file_count = len(os.listdir(os.path.join(self._path, "tmp"))) - self.assert_(file_count == repetitions, + self.assertTrue(file_count == repetitions, "Wrong file count: '%s' should be '%s'" % (file_count, repetitions)) def test_refresh(self): # Update the table of contents - self.assert_(self._box._toc == {}) + self.assertTrue(self._box._toc == {}) key0 = self._box.add(self._template % 0) key1 = self._box.add(self._template % 1) - self.assert_(self._box._toc == {}) + self.assertTrue(self._box._toc == {}) self._box._refresh() - self.assert_(self._box._toc == {key0: os.path.join('new', key0), + self.assertTrue(self._box._toc == {key0: os.path.join('new', key0), key1: os.path.join('new', key1)}) key2 = self._box.add(self._template % 2) - self.assert_(self._box._toc == {key0: os.path.join('new', key0), + self.assertTrue(self._box._toc == {key0: os.path.join('new', key0), key1: os.path.join('new', key1)}) self._box._refresh() - self.assert_(self._box._toc == {key0: os.path.join('new', key0), + self.assertTrue(self._box._toc == {key0: os.path.join('new', key0), key1: os.path.join('new', key1), key2: os.path.join('new', key2)}) @@ -680,11 +680,11 @@ class TestMaildir(TestMailbox): # Look up message subpaths in the TOC self.assertRaises(KeyError, lambda: self._box._lookup('foo')) key0 = self._box.add(self._template % 0) - self.assert_(self._box._lookup(key0) == os.path.join('new', key0)) + self.assertTrue(self._box._lookup(key0) == os.path.join('new', key0)) os.remove(os.path.join(self._path, 'new', key0)) - self.assert_(self._box._toc == {key0: os.path.join('new', key0)}) + self.assertTrue(self._box._toc == {key0: os.path.join('new', key0)}) self.assertRaises(KeyError, lambda: self._box._lookup(key0)) - self.assert_(self._box._toc == {}) + self.assertTrue(self._box._toc == {}) def test_lock_unlock(self): # Lock and unlock the mailbox. For Maildir, this does nothing. @@ -698,10 +698,10 @@ class TestMaildir(TestMailbox): return None box = self._factory(self._path, factory=dummy_factory) folder = box.add_folder('folder1') - self.assert_(folder._factory is dummy_factory) + self.assertTrue(folder._factory is dummy_factory) folder1_alias = box.get_folder('folder1') - self.assert_(folder1_alias._factory is dummy_factory) + self.assertTrue(folder1_alias._factory is dummy_factory) def test_directory_in_folder (self): # Test that mailboxes still work if there's a stray extra directory @@ -728,7 +728,7 @@ class TestMaildir(TestMailbox): os.umask(orig_umask) path = os.path.join(self._path, self._box._lookup(key)) mode = os.stat(path).st_mode - self.assert_(mode & 0111 == 0) + self.assertTrue(mode & 0111 == 0) def test_folder_file_perms(self): # From bug #3228, we want to verify that the file created inside a Maildir @@ -790,8 +790,8 @@ class _TestMboxMMDF(TestMailbox): def test_add_from_string(self): # Add a string starting with 'From ' to the mailbox key = self._box.add('From foo@bar blah\nFrom: foo\n\n0') - self.assert_(self._box[key].get_from() == 'foo@bar blah') - self.assert_(self._box[key].get_payload() == '0') + self.assertTrue(self._box[key].get_from() == 'foo@bar blah') + self.assertTrue(self._box[key].get_payload() == '0') def test_add_mbox_or_mmdf_message(self): # Add an mboxMessage or MMDFMessage @@ -807,11 +807,11 @@ class _TestMboxMMDF(TestMailbox): self._box.close() mtime = os.path.getmtime(self._path) self._box = self._factory(self._path) - self.assert_(len(self._box) == 3) + self.assertTrue(len(self._box) == 3) for key in self._box.iterkeys(): - self.assert_(self._box.get_string(key) in values) + self.assertTrue(self._box.get_string(key) in values) self._box.close() - self.assert_(mtime == os.path.getmtime(self._path)) + self.assertTrue(mtime == os.path.getmtime(self._path)) def test_add_and_close(self): # Verifying that closing a mailbox doesn't change added items @@ -823,7 +823,7 @@ class _TestMboxMMDF(TestMailbox): self._box._file.seek(0) contents = self._box._file.read() self._box.close() - self.assert_(contents == open(self._path, 'rb').read()) + self.assertTrue(contents == open(self._path, 'rb').read()) self._box = self._factory(self._path) def test_lock_conflict(self): @@ -864,7 +864,7 @@ class _TestMboxMMDF(TestMailbox): self._box.lock() key2 = self._box.add(msg) self._box.flush() - self.assert_(self._box._locked) + self.assertTrue(self._box._locked) self._box.close() @@ -905,8 +905,8 @@ class TestMH(TestMailbox): self._box.add_folder('one') self._box.add_folder('two') self._box.add_folder('three') - self.assert_(len(self._box.list_folders()) == 3) - self.assert_(set(self._box.list_folders()) == + self.assertTrue(len(self._box.list_folders()) == 3) + self.assertTrue(set(self._box.list_folders()) == set(('one', 'two', 'three'))) def test_get_folder(self): @@ -918,54 +918,54 @@ class TestMH(TestMailbox): new_folder = self._box.add_folder('foo.bar') folder0 = self._box.get_folder('foo.bar') folder0.add(self._template % 'bar') - self.assert_(os.path.isdir(os.path.join(self._path, 'foo.bar'))) + self.assertTrue(os.path.isdir(os.path.join(self._path, 'foo.bar'))) folder1 = self._box.get_folder('foo.bar') - self.assert_(folder1.get_string(folder1.keys()[0]) == \ + self.assertTrue(folder1.get_string(folder1.keys()[0]) == \ self._template % 'bar') # Test for bug #1569790: verify that folders returned by .get_folder() # use the same factory function. - self.assert_(new_folder._factory is self._box._factory) - self.assert_(folder0._factory is self._box._factory) + self.assertTrue(new_folder._factory is self._box._factory) + self.assertTrue(folder0._factory is self._box._factory) def test_add_and_remove_folders(self): # Delete folders self._box.add_folder('one') self._box.add_folder('two') - self.assert_(len(self._box.list_folders()) == 2) - self.assert_(set(self._box.list_folders()) == set(('one', 'two'))) + self.assertTrue(len(self._box.list_folders()) == 2) + self.assertTrue(set(self._box.list_folders()) == set(('one', 'two'))) self._box.remove_folder('one') - self.assert_(len(self._box.list_folders()) == 1) - self.assert_(set(self._box.list_folders()) == set(('two',))) + self.assertTrue(len(self._box.list_folders()) == 1) + self.assertTrue(set(self._box.list_folders()) == set(('two',))) self._box.add_folder('three') - self.assert_(len(self._box.list_folders()) == 2) - self.assert_(set(self._box.list_folders()) == set(('two', 'three'))) + self.assertTrue(len(self._box.list_folders()) == 2) + self.assertTrue(set(self._box.list_folders()) == set(('two', 'three'))) self._box.remove_folder('three') - self.assert_(len(self._box.list_folders()) == 1) - self.assert_(set(self._box.list_folders()) == set(('two',))) + self.assertTrue(len(self._box.list_folders()) == 1) + self.assertTrue(set(self._box.list_folders()) == set(('two',))) self._box.remove_folder('two') - self.assert_(len(self._box.list_folders()) == 0) - self.assert_(self._box.list_folders() == []) + self.assertTrue(len(self._box.list_folders()) == 0) + self.assertTrue(self._box.list_folders() == []) def test_sequences(self): # Get and set sequences - self.assert_(self._box.get_sequences() == {}) + self.assertTrue(self._box.get_sequences() == {}) msg0 = mailbox.MHMessage(self._template % 0) msg0.add_sequence('foo') key0 = self._box.add(msg0) - self.assert_(self._box.get_sequences() == {'foo':[key0]}) + self.assertTrue(self._box.get_sequences() == {'foo':[key0]}) msg1 = mailbox.MHMessage(self._template % 1) msg1.set_sequences(['bar', 'replied', 'foo']) key1 = self._box.add(msg1) - self.assert_(self._box.get_sequences() == + self.assertTrue(self._box.get_sequences() == {'foo':[key0, key1], 'bar':[key1], 'replied':[key1]}) msg0.set_sequences(['flagged']) self._box[key0] = msg0 - self.assert_(self._box.get_sequences() == + self.assertTrue(self._box.get_sequences() == {'foo':[key1], 'bar':[key1], 'replied':[key1], 'flagged':[key0]}) self._box.remove(key1) - self.assert_(self._box.get_sequences() == {'flagged':[key0]}) + self.assertTrue(self._box.get_sequences() == {'flagged':[key0]}) def test_issue2625(self): msg0 = mailbox.MHMessage(self._template % 0) @@ -987,19 +987,19 @@ class TestMH(TestMailbox): key1 = self._box.add(msg1) key2 = self._box.add(msg2) key3 = self._box.add(msg3) - self.assert_(self._box.get_sequences() == + self.assertTrue(self._box.get_sequences() == {'foo':[key0,key1,key2,key3], 'unseen':[key0], 'flagged':[key2], 'bar':[key3], 'replied':[key3]}) self._box.remove(key2) - self.assert_(self._box.get_sequences() == + self.assertTrue(self._box.get_sequences() == {'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3], 'replied':[key3]}) self._box.pack() - self.assert_(self._box.keys() == [1, 2, 3]) + self.assertTrue(self._box.keys() == [1, 2, 3]) key0 = key0 key1 = key0 + 1 key2 = key1 + 1 - self.assert_(self._box.get_sequences() == + self.assertTrue(self._box.get_sequences() == {'foo':[1, 2, 3], 'unseen':[1], 'bar':[3], 'replied':[3]}) # Test case for packing while holding the mailbox locked. @@ -1013,7 +1013,7 @@ class TestMH(TestMailbox): self._box.lock() self._box.pack() self._box.unlock() - self.assert_(self._box.get_sequences() == + self.assertTrue(self._box.get_sequences() == {'foo':[1, 2, 3, 4, 5], 'unseen':[1], 'bar':[3], 'replied':[3]}) @@ -1033,21 +1033,21 @@ class TestBabyl(TestMailbox): def test_labels(self): # Get labels from the mailbox - self.assert_(self._box.get_labels() == []) + self.assertTrue(self._box.get_labels() == []) msg0 = mailbox.BabylMessage(self._template % 0) msg0.add_label('foo') key0 = self._box.add(msg0) - self.assert_(self._box.get_labels() == ['foo']) + self.assertTrue(self._box.get_labels() == ['foo']) msg1 = mailbox.BabylMessage(self._template % 1) msg1.set_labels(['bar', 'answered', 'foo']) key1 = self._box.add(msg1) - self.assert_(set(self._box.get_labels()) == set(['foo', 'bar'])) + self.assertTrue(set(self._box.get_labels()) == set(['foo', 'bar'])) msg0.set_labels(['blah', 'filed']) self._box[key0] = msg0 - self.assert_(set(self._box.get_labels()) == + self.assertTrue(set(self._box.get_labels()) == set(['foo', 'bar', 'blah'])) self._box.remove(key1) - self.assert_(set(self._box.get_labels()) == set(['blah'])) + self.assertTrue(set(self._box.get_labels()) == set(['blah'])) class TestMessage(TestBase): @@ -1087,12 +1087,12 @@ class TestMessage(TestBase): # Initialize without arguments msg = self._factory() self._post_initialize_hook(msg) - self.assert_(isinstance(msg, email.message.Message)) - self.assert_(isinstance(msg, mailbox.Message)) - self.assert_(isinstance(msg, self._factory)) - self.assert_(msg.keys() == []) - self.assert_(not msg.is_multipart()) - self.assert_(msg.get_payload() == None) + self.assertTrue(isinstance(msg, email.message.Message)) + self.assertTrue(isinstance(msg, mailbox.Message)) + self.assertTrue(isinstance(msg, self._factory)) + self.assertTrue(msg.keys() == []) + self.assertTrue(not msg.is_multipart()) + self.assertTrue(msg.get_payload() == None) def test_initialize_incorrectly(self): # Initialize with invalid argument @@ -1127,72 +1127,72 @@ class TestMaildirMessage(TestMessage): _factory = mailbox.MaildirMessage def _post_initialize_hook(self, msg): - self.assert_(msg._subdir == 'new') - self.assert_(msg._info == '') + self.assertTrue(msg._subdir == 'new') + self.assertTrue(msg._info == '') def test_subdir(self): # Use get_subdir() and set_subdir() msg = mailbox.MaildirMessage(_sample_message) - self.assert_(msg.get_subdir() == 'new') + self.assertTrue(msg.get_subdir() == 'new') msg.set_subdir('cur') - self.assert_(msg.get_subdir() == 'cur') + self.assertTrue(msg.get_subdir() == 'cur') msg.set_subdir('new') - self.assert_(msg.get_subdir() == 'new') + self.assertTrue(msg.get_subdir() == 'new') self.assertRaises(ValueError, lambda: msg.set_subdir('tmp')) - self.assert_(msg.get_subdir() == 'new') + self.assertTrue(msg.get_subdir() == 'new') msg.set_subdir('new') - self.assert_(msg.get_subdir() == 'new') + self.assertTrue(msg.get_subdir() == 'new') self._check_sample(msg) def test_flags(self): # Use get_flags(), set_flags(), add_flag(), remove_flag() msg = mailbox.MaildirMessage(_sample_message) - self.assert_(msg.get_flags() == '') - self.assert_(msg.get_subdir() == 'new') + self.assertTrue(msg.get_flags() == '') + self.assertTrue(msg.get_subdir() == 'new') msg.set_flags('F') - self.assert_(msg.get_subdir() == 'new') - self.assert_(msg.get_flags() == 'F') + self.assertTrue(msg.get_subdir() == 'new') + self.assertTrue(msg.get_flags() == 'F') msg.set_flags('SDTP') - self.assert_(msg.get_flags() == 'DPST') + self.assertTrue(msg.get_flags() == 'DPST') msg.add_flag('FT') - self.assert_(msg.get_flags() == 'DFPST') + self.assertTrue(msg.get_flags() == 'DFPST') msg.remove_flag('TDRP') - self.assert_(msg.get_flags() == 'FS') - self.assert_(msg.get_subdir() == 'new') + self.assertTrue(msg.get_flags() == 'FS') + self.assertTrue(msg.get_subdir() == 'new') self._check_sample(msg) def test_date(self): # Use get_date() and set_date() msg = mailbox.MaildirMessage(_sample_message) - self.assert_(abs(msg.get_date() - time.time()) < 60) + self.assertTrue(abs(msg.get_date() - time.time()) < 60) msg.set_date(0.0) - self.assert_(msg.get_date() == 0.0) + self.assertTrue(msg.get_date() == 0.0) def test_info(self): # Use get_info() and set_info() msg = mailbox.MaildirMessage(_sample_message) - self.assert_(msg.get_info() == '') + self.assertTrue(msg.get_info() == '') msg.set_info('1,foo=bar') - self.assert_(msg.get_info() == '1,foo=bar') + self.assertTrue(msg.get_info() == '1,foo=bar') self.assertRaises(TypeError, lambda: msg.set_info(None)) self._check_sample(msg) def test_info_and_flags(self): # Test interaction of info and flag methods msg = mailbox.MaildirMessage(_sample_message) - self.assert_(msg.get_info() == '') + self.assertTrue(msg.get_info() == '') msg.set_flags('SF') - self.assert_(msg.get_flags() == 'FS') - self.assert_(msg.get_info() == '2,FS') + self.assertTrue(msg.get_flags() == 'FS') + self.assertTrue(msg.get_info() == '2,FS') msg.set_info('1,') - self.assert_(msg.get_flags() == '') - self.assert_(msg.get_info() == '1,') + self.assertTrue(msg.get_flags() == '') + self.assertTrue(msg.get_info() == '1,') msg.remove_flag('RPT') - self.assert_(msg.get_flags() == '') - self.assert_(msg.get_info() == '1,') + self.assertTrue(msg.get_flags() == '') + self.assertTrue(msg.get_info() == '1,') msg.add_flag('D') - self.assert_(msg.get_flags() == 'D') - self.assert_(msg.get_info() == '2,D') + self.assertTrue(msg.get_flags() == 'D') + self.assertTrue(msg.get_info() == '2,D') self._check_sample(msg) @@ -1208,14 +1208,14 @@ class _TestMboxMMDFMessage(TestMessage): msg = mailbox.Message(_sample_message) msg.set_unixfrom('From foo@bar blah') msg = mailbox.mboxMessage(msg) - self.assert_(msg.get_from() == 'foo@bar blah', msg.get_from()) + self.assertTrue(msg.get_from() == 'foo@bar blah', msg.get_from()) def test_from(self): # Get and set "From " line msg = mailbox.mboxMessage(_sample_message) self._check_from(msg) msg.set_from('foo bar') - self.assert_(msg.get_from() == 'foo bar') + self.assertTrue(msg.get_from() == 'foo bar') msg.set_from('foo@bar', True) self._check_from(msg, 'foo@bar') msg.set_from('blah@temp', time.localtime()) @@ -1224,22 +1224,22 @@ class _TestMboxMMDFMessage(TestMessage): def test_flags(self): # Use get_flags(), set_flags(), add_flag(), remove_flag() msg = mailbox.mboxMessage(_sample_message) - self.assert_(msg.get_flags() == '') + self.assertTrue(msg.get_flags() == '') msg.set_flags('F') - self.assert_(msg.get_flags() == 'F') + self.assertTrue(msg.get_flags() == 'F') msg.set_flags('XODR') - self.assert_(msg.get_flags() == 'RODX') + self.assertTrue(msg.get_flags() == 'RODX') msg.add_flag('FA') - self.assert_(msg.get_flags() == 'RODFAX') + self.assertTrue(msg.get_flags() == 'RODFAX') msg.remove_flag('FDXA') - self.assert_(msg.get_flags() == 'RO') + self.assertTrue(msg.get_flags() == 'RO') self._check_sample(msg) def _check_from(self, msg, sender=None): # Check contents of "From " line if sender is None: sender = "MAILER-DAEMON" - self.assert_(re.match(sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:" + self.assertTrue(re.match(sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:" r"\d{2} \d{4}", msg.get_from()) is not None) @@ -1253,30 +1253,30 @@ class TestMHMessage(TestMessage): _factory = mailbox.MHMessage def _post_initialize_hook(self, msg): - self.assert_(msg._sequences == []) + self.assertTrue(msg._sequences == []) def test_sequences(self): # Get, set, join, and leave sequences msg = mailbox.MHMessage(_sample_message) - self.assert_(msg.get_sequences() == []) + self.assertTrue(msg.get_sequences() == []) msg.set_sequences(['foobar']) - self.assert_(msg.get_sequences() == ['foobar']) + self.assertTrue(msg.get_sequences() == ['foobar']) msg.set_sequences([]) - self.assert_(msg.get_sequences() == []) + self.assertTrue(msg.get_sequences() == []) msg.add_sequence('unseen') - self.assert_(msg.get_sequences() == ['unseen']) + self.assertTrue(msg.get_sequences() == ['unseen']) msg.add_sequence('flagged') - self.assert_(msg.get_sequences() == ['unseen', 'flagged']) + self.assertTrue(msg.get_sequences() == ['unseen', 'flagged']) msg.add_sequence('flagged') - self.assert_(msg.get_sequences() == ['unseen', 'flagged']) + self.assertTrue(msg.get_sequences() == ['unseen', 'flagged']) msg.remove_sequence('unseen') - self.assert_(msg.get_sequences() == ['flagged']) + self.assertTrue(msg.get_sequences() == ['flagged']) msg.add_sequence('foobar') - self.assert_(msg.get_sequences() == ['flagged', 'foobar']) + self.assertTrue(msg.get_sequences() == ['flagged', 'foobar']) msg.remove_sequence('replied') - self.assert_(msg.get_sequences() == ['flagged', 'foobar']) + self.assertTrue(msg.get_sequences() == ['flagged', 'foobar']) msg.set_sequences(['foobar', 'replied']) - self.assert_(msg.get_sequences() == ['foobar', 'replied']) + self.assertTrue(msg.get_sequences() == ['foobar', 'replied']) class TestBabylMessage(TestMessage): @@ -1284,54 +1284,54 @@ class TestBabylMessage(TestMessage): _factory = mailbox.BabylMessage def _post_initialize_hook(self, msg): - self.assert_(msg._labels == []) + self.assertTrue(msg._labels == []) def test_labels(self): # Get, set, join, and leave labels msg = mailbox.BabylMessage(_sample_message) - self.assert_(msg.get_labels() == []) + self.assertTrue(msg.get_labels() == []) msg.set_labels(['foobar']) - self.assert_(msg.get_labels() == ['foobar']) + self.assertTrue(msg.get_labels() == ['foobar']) msg.set_labels([]) - self.assert_(msg.get_labels() == []) + self.assertTrue(msg.get_labels() == []) msg.add_label('filed') - self.assert_(msg.get_labels() == ['filed']) + self.assertTrue(msg.get_labels() == ['filed']) msg.add_label('resent') - self.assert_(msg.get_labels() == ['filed', 'resent']) + self.assertTrue(msg.get_labels() == ['filed', 'resent']) msg.add_label('resent') - self.assert_(msg.get_labels() == ['filed', 'resent']) + self.assertTrue(msg.get_labels() == ['filed', 'resent']) msg.remove_label('filed') - self.assert_(msg.get_labels() == ['resent']) + self.assertTrue(msg.get_labels() == ['resent']) msg.add_label('foobar') - self.assert_(msg.get_labels() == ['resent', 'foobar']) + self.assertTrue(msg.get_labels() == ['resent', 'foobar']) msg.remove_label('unseen') - self.assert_(msg.get_labels() == ['resent', 'foobar']) + self.assertTrue(msg.get_labels() == ['resent', 'foobar']) msg.set_labels(['foobar', 'answered']) - self.assert_(msg.get_labels() == ['foobar', 'answered']) + self.assertTrue(msg.get_labels() == ['foobar', 'answered']) def test_visible(self): # Get, set, and update visible headers msg = mailbox.BabylMessage(_sample_message) visible = msg.get_visible() - self.assert_(visible.keys() == []) - self.assert_(visible.get_payload() is None) + self.assertTrue(visible.keys() == []) + self.assertTrue(visible.get_payload() is None) visible['User-Agent'] = 'FooBar 1.0' visible['X-Whatever'] = 'Blah' - self.assert_(msg.get_visible().keys() == []) + self.assertTrue(msg.get_visible().keys() == []) msg.set_visible(visible) visible = msg.get_visible() - self.assert_(visible.keys() == ['User-Agent', 'X-Whatever']) - self.assert_(visible['User-Agent'] == 'FooBar 1.0') - self.assert_(visible['X-Whatever'] == 'Blah') - self.assert_(visible.get_payload() is None) + self.assertTrue(visible.keys() == ['User-Agent', 'X-Whatever']) + self.assertTrue(visible['User-Agent'] == 'FooBar 1.0') + self.assertTrue(visible['X-Whatever'] == 'Blah') + self.assertTrue(visible.get_payload() is None) msg.update_visible() - self.assert_(visible.keys() == ['User-Agent', 'X-Whatever']) - self.assert_(visible.get_payload() is None) + self.assertTrue(visible.keys() == ['User-Agent', 'X-Whatever']) + self.assertTrue(visible.get_payload() is None) visible = msg.get_visible() - self.assert_(visible.keys() == ['User-Agent', 'Date', 'From', 'To', + self.assertTrue(visible.keys() == ['User-Agent', 'Date', 'From', 'To', 'Subject']) for header in ('User-Agent', 'Date', 'From', 'To', 'Subject'): - self.assert_(visible[header] == msg[header]) + self.assertTrue(visible[header] == msg[header]) class TestMMDFMessage(_TestMboxMMDFMessage): @@ -1374,9 +1374,9 @@ class TestMessageConversion(TestBase): date = msg_maildir.get_date() msg = mailbox.MaildirMessage(msg_maildir) self._check_sample(msg) - self.assert_(msg.get_flags() == 'DFPRST') - self.assert_(msg.get_subdir() == 'cur') - self.assert_(msg.get_date() == date) + self.assertTrue(msg.get_flags() == 'DFPRST') + self.assertTrue(msg.get_subdir() == 'cur') + self.assertTrue(msg.get_date() == date) def test_maildir_to_mboxmmdf(self): # Convert MaildirMessage to mboxmessage and MMDFMessage @@ -1388,11 +1388,11 @@ class TestMessageConversion(TestBase): for setting, result in pairs: msg_maildir.set_flags(setting) msg = class_(msg_maildir) - self.assert_(msg.get_flags() == result) - self.assert_(msg.get_from() == 'MAILER-DAEMON %s' % + self.assertTrue(msg.get_flags() == result) + self.assertTrue(msg.get_from() == 'MAILER-DAEMON %s' % time.asctime(time.gmtime(0.0))) msg_maildir.set_subdir('cur') - self.assert_(class_(msg_maildir).get_flags() == 'RODFA') + self.assertTrue(class_(msg_maildir).get_flags() == 'RODFA') def test_maildir_to_mh(self): # Convert MaildirMessage to MHMessage @@ -1402,7 +1402,7 @@ class TestMessageConversion(TestBase): ('T', ['unseen']), ('DFPRST', ['replied', 'flagged'])) for setting, result in pairs: msg_maildir.set_flags(setting) - self.assert_(mailbox.MHMessage(msg_maildir).get_sequences() == \ + self.assertTrue(mailbox.MHMessage(msg_maildir).get_sequences() == \ result) def test_maildir_to_babyl(self): @@ -1414,7 +1414,7 @@ class TestMessageConversion(TestBase): ('DFPRST', ['deleted', 'answered', 'forwarded'])) for setting, result in pairs: msg_maildir.set_flags(setting) - self.assert_(mailbox.BabylMessage(msg_maildir).get_labels() == \ + self.assertTrue(mailbox.BabylMessage(msg_maildir).get_labels() == \ result) def test_mboxmmdf_to_maildir(self): @@ -1427,10 +1427,10 @@ class TestMessageConversion(TestBase): for setting, result in pairs: msg_mboxMMDF.set_flags(setting) msg = mailbox.MaildirMessage(msg_mboxMMDF) - self.assert_(msg.get_flags() == result) - self.assert_(msg.get_date() == 0.0, msg.get_date()) + self.assertTrue(msg.get_flags() == result) + self.assertTrue(msg.get_date() == 0.0, msg.get_date()) msg_mboxMMDF.set_flags('O') - self.assert_(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir() == \ + self.assertTrue(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir() == \ 'cur') def test_mboxmmdf_to_mboxmmdf(self): @@ -1441,8 +1441,8 @@ class TestMessageConversion(TestBase): msg_mboxMMDF.set_from('foo@bar') for class2_ in (mailbox.mboxMessage, mailbox.MMDFMessage): msg2 = class2_(msg_mboxMMDF) - self.assert_(msg2.get_flags() == 'RODFA') - self.assert_(msg2.get_from() == 'foo@bar') + self.assertTrue(msg2.get_flags() == 'RODFA') + self.assertTrue(msg2.get_from() == 'foo@bar') def test_mboxmmdf_to_mh(self): # Convert mboxMessage and MMDFMessage to MHMessage @@ -1454,7 +1454,7 @@ class TestMessageConversion(TestBase): ('RODFA', ['replied', 'flagged'])) for setting, result in pairs: msg_mboxMMDF.set_flags(setting) - self.assert_(mailbox.MHMessage(msg_mboxMMDF).get_sequences() \ + self.assertTrue(mailbox.MHMessage(msg_mboxMMDF).get_sequences() \ == result) def test_mboxmmdf_to_babyl(self): @@ -1467,7 +1467,7 @@ class TestMessageConversion(TestBase): ('RODFA', ['deleted', 'answered'])) for setting, result in pairs: msg.set_flags(setting) - self.assert_(mailbox.BabylMessage(msg).get_labels() == result) + self.assertTrue(mailbox.BabylMessage(msg).get_labels() == result) def test_mh_to_maildir(self): # Convert MHMessage to MaildirMessage @@ -1475,14 +1475,14 @@ class TestMessageConversion(TestBase): for setting, result in pairs: msg = mailbox.MHMessage(_sample_message) msg.add_sequence(setting) - self.assert_(mailbox.MaildirMessage(msg).get_flags() == result) - self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur') + self.assertTrue(mailbox.MaildirMessage(msg).get_flags() == result) + self.assertTrue(mailbox.MaildirMessage(msg).get_subdir() == 'cur') msg = mailbox.MHMessage(_sample_message) msg.add_sequence('unseen') msg.add_sequence('replied') msg.add_sequence('flagged') - self.assert_(mailbox.MaildirMessage(msg).get_flags() == 'FR') - self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur') + self.assertTrue(mailbox.MaildirMessage(msg).get_flags() == 'FR') + self.assertTrue(mailbox.MaildirMessage(msg).get_subdir() == 'cur') def test_mh_to_mboxmmdf(self): # Convert MHMessage to mboxMessage and MMDFMessage @@ -1491,13 +1491,13 @@ class TestMessageConversion(TestBase): msg = mailbox.MHMessage(_sample_message) msg.add_sequence(setting) for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage): - self.assert_(class_(msg).get_flags() == result) + self.assertTrue(class_(msg).get_flags() == result) msg = mailbox.MHMessage(_sample_message) msg.add_sequence('unseen') msg.add_sequence('replied') msg.add_sequence('flagged') for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage): - self.assert_(class_(msg).get_flags() == 'OFA') + self.assertTrue(class_(msg).get_flags() == 'OFA') def test_mh_to_mh(self): # Convert MHMessage to MHMessage @@ -1505,7 +1505,7 @@ class TestMessageConversion(TestBase): msg.add_sequence('unseen') msg.add_sequence('replied') msg.add_sequence('flagged') - self.assert_(mailbox.MHMessage(msg).get_sequences() == \ + self.assertTrue(mailbox.MHMessage(msg).get_sequences() == \ ['unseen', 'replied', 'flagged']) def test_mh_to_babyl(self): @@ -1515,12 +1515,12 @@ class TestMessageConversion(TestBase): for setting, result in pairs: msg = mailbox.MHMessage(_sample_message) msg.add_sequence(setting) - self.assert_(mailbox.BabylMessage(msg).get_labels() == result) + self.assertTrue(mailbox.BabylMessage(msg).get_labels() == result) msg = mailbox.MHMessage(_sample_message) msg.add_sequence('unseen') msg.add_sequence('replied') msg.add_sequence('flagged') - self.assert_(mailbox.BabylMessage(msg).get_labels() == \ + self.assertTrue(mailbox.BabylMessage(msg).get_labels() == \ ['unseen', 'answered']) def test_babyl_to_maildir(self): @@ -1531,14 +1531,14 @@ class TestMessageConversion(TestBase): for setting, result in pairs: msg = mailbox.BabylMessage(_sample_message) msg.add_label(setting) - self.assert_(mailbox.MaildirMessage(msg).get_flags() == result) - self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur') + self.assertTrue(mailbox.MaildirMessage(msg).get_flags() == result) + self.assertTrue(mailbox.MaildirMessage(msg).get_subdir() == 'cur') msg = mailbox.BabylMessage(_sample_message) for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded', 'edited', 'resent'): msg.add_label(label) - self.assert_(mailbox.MaildirMessage(msg).get_flags() == 'PRT') - self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur') + self.assertTrue(mailbox.MaildirMessage(msg).get_flags() == 'PRT') + self.assertTrue(mailbox.MaildirMessage(msg).get_subdir() == 'cur') def test_babyl_to_mboxmmdf(self): # Convert BabylMessage to mboxMessage and MMDFMessage @@ -1549,13 +1549,13 @@ class TestMessageConversion(TestBase): for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage): msg = mailbox.BabylMessage(_sample_message) msg.add_label(setting) - self.assert_(class_(msg).get_flags() == result) + self.assertTrue(class_(msg).get_flags() == result) msg = mailbox.BabylMessage(_sample_message) for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded', 'edited', 'resent'): msg.add_label(label) for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage): - self.assert_(class_(msg).get_flags() == 'ODA') + self.assertTrue(class_(msg).get_flags() == 'ODA') def test_babyl_to_mh(self): # Convert BabylMessage to MHMessage @@ -1565,12 +1565,12 @@ class TestMessageConversion(TestBase): for setting, result in pairs: msg = mailbox.BabylMessage(_sample_message) msg.add_label(setting) - self.assert_(mailbox.MHMessage(msg).get_sequences() == result) + self.assertTrue(mailbox.MHMessage(msg).get_sequences() == result) msg = mailbox.BabylMessage(_sample_message) for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded', 'edited', 'resent'): msg.add_label(label) - self.assert_(mailbox.MHMessage(msg).get_sequences() == \ + self.assertTrue(mailbox.MHMessage(msg).get_sequences() == \ ['unseen', 'replied']) def test_babyl_to_babyl(self): @@ -1581,12 +1581,12 @@ class TestMessageConversion(TestBase): 'edited', 'resent'): msg.add_label(label) msg2 = mailbox.BabylMessage(msg) - self.assert_(msg2.get_labels() == ['unseen', 'deleted', 'filed', + self.assertTrue(msg2.get_labels() == ['unseen', 'deleted', 'filed', 'answered', 'forwarded', 'edited', 'resent']) - self.assert_(msg.get_visible().keys() == msg2.get_visible().keys()) + self.assertTrue(msg.get_visible().keys() == msg2.get_visible().keys()) for key in msg.get_visible().keys(): - self.assert_(msg.get_visible()[key] == msg2.get_visible()[key]) + self.assertTrue(msg.get_visible()[key] == msg2.get_visible()[key]) class TestProxyFileBase(TestBase): @@ -1594,69 +1594,69 @@ class TestProxyFileBase(TestBase): def _test_read(self, proxy): # Read by byte proxy.seek(0) - self.assert_(proxy.read() == 'bar') + self.assertTrue(proxy.read() == 'bar') proxy.seek(1) - self.assert_(proxy.read() == 'ar') + self.assertTrue(proxy.read() == 'ar') proxy.seek(0) - self.assert_(proxy.read(2) == 'ba') + self.assertTrue(proxy.read(2) == 'ba') proxy.seek(1) - self.assert_(proxy.read(-1) == 'ar') + self.assertTrue(proxy.read(-1) == 'ar') proxy.seek(2) - self.assert_(proxy.read(1000) == 'r') + self.assertTrue(proxy.read(1000) == 'r') def _test_readline(self, proxy): # Read by line proxy.seek(0) - self.assert_(proxy.readline() == 'foo' + os.linesep) - self.assert_(proxy.readline() == 'bar' + os.linesep) - self.assert_(proxy.readline() == 'fred' + os.linesep) - self.assert_(proxy.readline() == 'bob') + self.assertTrue(proxy.readline() == 'foo' + os.linesep) + self.assertTrue(proxy.readline() == 'bar' + os.linesep) + self.assertTrue(proxy.readline() == 'fred' + os.linesep) + self.assertTrue(proxy.readline() == 'bob') proxy.seek(2) - self.assert_(proxy.readline() == 'o' + os.linesep) + self.assertTrue(proxy.readline() == 'o' + os.linesep) proxy.seek(6 + 2 * len(os.linesep)) - self.assert_(proxy.readline() == 'fred' + os.linesep) + self.assertTrue(proxy.readline() == 'fred' + os.linesep) proxy.seek(6 + 2 * len(os.linesep)) - self.assert_(proxy.readline(2) == 'fr') - self.assert_(proxy.readline(-10) == 'ed' + os.linesep) + self.assertTrue(proxy.readline(2) == 'fr') + self.assertTrue(proxy.readline(-10) == 'ed' + os.linesep) def _test_readlines(self, proxy): # Read multiple lines proxy.seek(0) - self.assert_(proxy.readlines() == ['foo' + os.linesep, + self.assertTrue(proxy.readlines() == ['foo' + os.linesep, 'bar' + os.linesep, 'fred' + os.linesep, 'bob']) proxy.seek(0) - self.assert_(proxy.readlines(2) == ['foo' + os.linesep]) + self.assertTrue(proxy.readlines(2) == ['foo' + os.linesep]) proxy.seek(3 + len(os.linesep)) - self.assert_(proxy.readlines(4 + len(os.linesep)) == + self.assertTrue(proxy.readlines(4 + len(os.linesep)) == ['bar' + os.linesep, 'fred' + os.linesep]) proxy.seek(3) - self.assert_(proxy.readlines(1000) == [os.linesep, 'bar' + os.linesep, + self.assertTrue(proxy.readlines(1000) == [os.linesep, 'bar' + os.linesep, 'fred' + os.linesep, 'bob']) def _test_iteration(self, proxy): # Iterate by line proxy.seek(0) iterator = iter(proxy) - self.assert_(iterator.next() == 'foo' + os.linesep) - self.assert_(iterator.next() == 'bar' + os.linesep) - self.assert_(iterator.next() == 'fred' + os.linesep) - self.assert_(iterator.next() == 'bob') + self.assertTrue(iterator.next() == 'foo' + os.linesep) + self.assertTrue(iterator.next() == 'bar' + os.linesep) + self.assertTrue(iterator.next() == 'fred' + os.linesep) + self.assertTrue(iterator.next() == 'bob') self.assertRaises(StopIteration, lambda: iterator.next()) def _test_seek_and_tell(self, proxy): # Seek and use tell to check position proxy.seek(3) - self.assert_(proxy.tell() == 3) - self.assert_(proxy.read(len(os.linesep)) == os.linesep) + self.assertTrue(proxy.tell() == 3) + self.assertTrue(proxy.read(len(os.linesep)) == os.linesep) proxy.seek(2, 1) - self.assert_(proxy.read(1 + len(os.linesep)) == 'r' + os.linesep) + self.assertTrue(proxy.read(1 + len(os.linesep)) == 'r' + os.linesep) proxy.seek(-3 - len(os.linesep), 2) - self.assert_(proxy.read(3) == 'bar') + self.assertTrue(proxy.read(3) == 'bar') proxy.seek(2, 0) - self.assert_(proxy.read() == 'o' + os.linesep + 'bar' + os.linesep) + self.assertTrue(proxy.read() == 'o' + os.linesep + 'bar' + os.linesep) proxy.seek(100) - self.assert_(proxy.read() == '') + self.assertTrue(proxy.read() == '') def _test_close(self, proxy): # Close a file @@ -1679,11 +1679,11 @@ class TestProxyFile(TestProxyFileBase): self._file.write('foo') pos = self._file.tell() proxy0 = mailbox._ProxyFile(self._file) - self.assert_(proxy0.tell() == pos) - self.assert_(self._file.tell() == pos) + self.assertTrue(proxy0.tell() == pos) + self.assertTrue(self._file.tell() == pos) proxy1 = mailbox._ProxyFile(self._file, 0) - self.assert_(proxy1.tell() == 0) - self.assert_(self._file.tell() == pos) + self.assertTrue(proxy1.tell() == 0) + self.assertTrue(self._file.tell() == pos) def test_read(self): self._file.write('bar') @@ -1728,8 +1728,8 @@ class TestPartialFile(TestProxyFileBase): self._file.write('foo' + os.linesep + 'bar') pos = self._file.tell() proxy = mailbox._PartialFile(self._file, 2, 5) - self.assert_(proxy.tell() == 0) - self.assert_(self._file.tell() == pos) + self.assertTrue(proxy.tell() == 0) + self.assertTrue(self._file.tell() == pos) def test_read(self): self._file.write('***bar***') @@ -1821,36 +1821,36 @@ class MaildirTestCase(unittest.TestCase): # Test for regression on bug #117490: # Make sure the boxes attribute actually gets set. self.mbox = mailbox.Maildir(test_support.TESTFN) - #self.assert_(hasattr(self.mbox, "boxes")) - #self.assert_(len(self.mbox.boxes) == 0) - self.assert_(self.mbox.next() is None) - self.assert_(self.mbox.next() is None) + #self.assertTrue(hasattr(self.mbox, "boxes")) + #self.assertTrue(len(self.mbox.boxes) == 0) + self.assertTrue(self.mbox.next() is None) + self.assertTrue(self.mbox.next() is None) def test_nonempty_maildir_cur(self): self.createMessage("cur") self.mbox = mailbox.Maildir(test_support.TESTFN) - #self.assert_(len(self.mbox.boxes) == 1) - self.assert_(self.mbox.next() is not None) - self.assert_(self.mbox.next() is None) - self.assert_(self.mbox.next() is None) + #self.assertTrue(len(self.mbox.boxes) == 1) + self.assertTrue(self.mbox.next() is not None) + self.assertTrue(self.mbox.next() is None) + self.assertTrue(self.mbox.next() is None) def test_nonempty_maildir_new(self): self.createMessage("new") self.mbox = mailbox.Maildir(test_support.TESTFN) - #self.assert_(len(self.mbox.boxes) == 1) - self.assert_(self.mbox.next() is not None) - self.assert_(self.mbox.next() is None) - self.assert_(self.mbox.next() is None) + #self.assertTrue(len(self.mbox.boxes) == 1) + self.assertTrue(self.mbox.next() is not None) + self.assertTrue(self.mbox.next() is None) + self.assertTrue(self.mbox.next() is None) def test_nonempty_maildir_both(self): self.createMessage("cur") self.createMessage("new") self.mbox = mailbox.Maildir(test_support.TESTFN) - #self.assert_(len(self.mbox.boxes) == 2) - self.assert_(self.mbox.next() is not None) - self.assert_(self.mbox.next() is not None) - self.assert_(self.mbox.next() is None) - self.assert_(self.mbox.next() is None) + #self.assertTrue(len(self.mbox.boxes) == 2) + self.assertTrue(self.mbox.next() is not None) + self.assertTrue(self.mbox.next() is not None) + self.assertTrue(self.mbox.next() is None) + self.assertTrue(self.mbox.next() is None) def test_unix_mbox(self): ### should be better! |