[Python-3000-checkins] r56563 - python/branches/py3k-struni/Lib/test/test_mailbox.py
guido.van.rossum
python-3000-checkins at python.org
Fri Jul 27 07:17:50 CEST 2007
Author: guido.van.rossum
Date: Fri Jul 27 07:17:50 2007
New Revision: 56563
Modified:
python/branches/py3k-struni/Lib/test/test_mailbox.py
Log:
SF patch# 1757839 by Alexandre Vassalotti (part 2).
Change a bunch of .assert_(X == Y) to .assertEqual(X, Y).
Modified: python/branches/py3k-struni/Lib/test/test_mailbox.py
==============================================================================
--- python/branches/py3k-struni/Lib/test/test_mailbox.py (original)
+++ python/branches/py3k-struni/Lib/test/test_mailbox.py Fri Jul 27 07:17:50 2007
@@ -73,7 +73,7 @@
self.assertEqual(len(self._box), 4)
keys.append(self._box.add(_sample_message))
self.assertEqual(len(self._box), 5)
- self.assert_(self._box.get_string(keys[0]) == self._template % 0)
+ self.assertEqual(self._box.get_string(keys[0]), self._template % 0)
for i in (1, 2, 3, 4):
self._check_sample(self._box[keys[i]])
@@ -95,7 +95,7 @@
self.assert_(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.assertEqual(self._box.get_string(key1), self._template % 1)
key2 = self._box.add(self._template % 2)
self.assertEqual(len(self._box), 2)
method(key2)
@@ -103,7 +103,7 @@
self.assert_(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.assertEqual(self._box.get_string(key1), self._template % 1)
method(key1)
self.assertEqual(len(self._box), 0)
self.assertRaises(KeyError, lambda: self._box[key1])
@@ -160,17 +160,17 @@
# 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.assertEqual(self._box.get_string(key0), self._template % 0)
self.assertEqual(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._template % 0)
- self.assert_(self._box.get_file(key1).read().replace(os.linesep, '\n')
- == _sample_message)
+ self.assertEqual(self._box.get_file(key0).read().replace(os.linesep, '\n'),
+ self._template % 0)
+ self.assertEqual(self._box.get_file(key1).read().replace(os.linesep, '\n'),
+ _sample_message)
def test_iterkeys(self):
# Get keys using iterkeys()
@@ -256,32 +256,32 @@
for i in range(repetitions):
self.assertEqual(len(self._box), i)
keys.append(self._box.add(self._template % i))
- self.assert_(len(self._box) == i + 1)
+ self.assertEqual(len(self._box), i + 1)
for i in range(repetitions):
- self.assert_(len(self._box) == repetitions - i)
+ self.assertEqual(len(self._box), repetitions - i)
self._box.remove(keys[i])
- self.assert_(len(self._box) == repetitions - i - 1)
+ self.assertEqual(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._template % 'original 0')
+ self.assertEqual(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._template % 'original 1')
+ self.assertEqual(self._box.get_string(key1),
+ self._template % 'original 1')
self._box[key0] = self._template % 'changed 0'
- self.assert_(self._box.get_string(key0) == \
- self._template % 'changed 0')
+ self.assertEqual(self._box.get_string(key0),
+ self._template % 'changed 0')
self._box[key1] = self._template % 'changed 1'
- self.assert_(self._box.get_string(key1) == \
- self._template % 'changed 1')
+ self.assertEqual(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.assertEqual(self._box.get_string(key0),
self._template % 'original 0')
self._check_sample(self._box[key1])
self.assertRaises(KeyError,
@@ -343,30 +343,30 @@
self._box.update({key0: self._template % 'changed 0',
key2: _sample_message})
self.assertEqual(len(self._box), 3)
- self.assert_(self._box.get_string(key0) ==
+ self.assertEqual(self._box.get_string(key0),
self._template % 'changed 0')
- self.assert_(self._box.get_string(key1) ==
+ self.assertEqual(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.assertEqual(len(self._box), 3)
- self.assert_(self._box.get_string(key0) ==
+ self.assertEqual(self._box.get_string(key0),
self._template % 'original 0')
- self.assert_(self._box.get_string(key1) ==
+ self.assertEqual(self._box.get_string(key1),
self._template % 'changed 1')
- self.assert_(self._box.get_string(key2) ==
+ self.assertEqual(self._box.get_string(key2),
self._template % 'changed 2')
self.assertRaises(KeyError,
lambda: self._box.update({'foo': 'bar',
key0: self._template % "changed 0"}))
self.assertEqual(len(self._box), 3)
- self.assert_(self._box.get_string(key0) ==
+ self.assertEqual(self._box.get_string(key0),
self._template % "changed 0")
- self.assert_(self._box.get_string(key1) ==
+ self.assertEqual(self._box.get_string(key1),
self._template % "changed 1")
- self.assert_(self._box.get_string(key2) ==
+ self.assertEqual(self._box.get_string(key2),
self._template % "changed 2")
def test_flush(self):
@@ -535,7 +535,7 @@
self._box.add_folder('two')
self._box.add_folder('three')
self.assertEqual(len(self._box.list_folders()), 3)
- self.assert_(set(self._box.list_folders()) ==
+ self.assertEqual(set(self._box.list_folders()),
set(('one', 'two', 'three')))
def test_get_folder(self):
@@ -545,8 +545,8 @@
folder0.add(self._template % 'bar')
self.assert_(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._template % 'bar')
+ self.assertEqual(folder1.get_string(folder1.keys()[0]),
+ self._template % 'bar')
def test_add_and_remove_folders(self):
# Delete folders
@@ -559,7 +559,7 @@
self.assertEqual(set(self._box.list_folders()), set(('two',)))
self._box.add_folder('three')
self.assertEqual(len(self._box.list_folders()), 2)
- self.assert_(set(self._box.list_folders()) == set(('two', 'three')))
+ self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
self._box.remove_folder('three')
self.assertEqual(len(self._box.list_folders()), 1)
self.assertEqual(set(self._box.list_folders()), set(('two',)))
@@ -615,13 +615,13 @@
groups[0] != groups[1],
"Non-monotonic milliseconds: '%s' before '%s'" %
(previous_groups[1], groups[1]))
- self.assert_(int(groups[2]) == pid,
+ self.assertEqual(int(groups[2]), pid,
"Process ID mismatch: '%s' should be '%s'" %
(groups[2], pid))
self.assertEqual(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.assertEqual(groups[4], hostname,
"Host name mismatch: '%s' should be '%s'" %
(groups[4], hostname))
previous_groups = groups
@@ -630,7 +630,7 @@
self.assertEqual(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.assertEqual(file_count, repetitions,
"Wrong file count: '%s' should be '%s'" %
(file_count, repetitions))
@@ -641,23 +641,23 @@
key1 = self._box.add(self._template % 1)
self.assertEqual(self._box._toc, {})
self._box._refresh()
- self.assert_(self._box._toc == {key0: os.path.join('new', key0),
- key1: os.path.join('new', key1)})
+ self.assertEqual(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),
- key1: os.path.join('new', key1)})
+ self.assertEqual(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),
- key1: os.path.join('new', key1),
- key2: os.path.join('new', key2)})
+ self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
+ key1: os.path.join('new', key1),
+ key2: os.path.join('new', key2)})
def test_lookup(self):
# 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.assertEqual(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.assertEqual(self._box._toc, {key0: os.path.join('new', key0)})
self.assertRaises(KeyError, lambda: self._box._lookup(key0))
self.assertEqual(self._box._toc, {})
@@ -701,7 +701,7 @@
def test_add_from_string(self):
# Add a string starting with 'From ' to the mailbox
key = self._box.add('From foo at bar blah\nFrom: foo\n\n0')
- self.assert_(self._box[key].get_from() == 'foo at bar blah')
+ self.assertEqual(self._box[key].get_from(), 'foo at bar blah')
self.assertEqual(self._box[key].get_payload(), '0')
def test_add_mbox_or_mmdf_message(self):
@@ -734,7 +734,7 @@
self._box._file.seek(0)
contents = self._box._file.read()
self._box.close()
- self.assert_(contents == open(self._path, 'r').read())
+ self.assertEqual(contents, open(self._path, 'r').read())
self._box = self._factory(self._path)
def test_lock_conflict(self):
@@ -802,7 +802,7 @@
self._box.add_folder('two')
self._box.add_folder('three')
self.assertEqual(len(self._box.list_folders()), 3)
- self.assert_(set(self._box.list_folders()) ==
+ self.assertEqual(set(self._box.list_folders()),
set(('one', 'two', 'three')))
def test_get_folder(self):
@@ -816,8 +816,8 @@
folder0.add(self._template % 'bar')
self.assert_(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._template % 'bar')
+ self.assertEqual(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.
@@ -829,13 +829,13 @@
self._box.add_folder('one')
self._box.add_folder('two')
self.assertEqual(len(self._box.list_folders()), 2)
- self.assert_(set(self._box.list_folders()) == set(('one', 'two')))
+ self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
self._box.remove_folder('one')
self.assertEqual(len(self._box.list_folders()), 1)
self.assertEqual(set(self._box.list_folders()), set(('two',)))
self._box.add_folder('three')
self.assertEqual(len(self._box.list_folders()), 2)
- self.assert_(set(self._box.list_folders()) == set(('two', 'three')))
+ self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
self._box.remove_folder('three')
self.assertEqual(len(self._box.list_folders()), 1)
self.assertEqual(set(self._box.list_folders()), set(('two',)))
@@ -853,11 +853,11 @@
msg1 = mailbox.MHMessage(self._template % 1)
msg1.set_sequences(['bar', 'replied', 'foo'])
key1 = self._box.add(msg1)
- self.assert_(self._box.get_sequences() ==
+ self.assertEqual(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.assertEqual(self._box.get_sequences(),
{'foo':[key1], 'bar':[key1], 'replied':[key1],
'flagged':[key0]})
self._box.remove(key1)
@@ -877,11 +877,11 @@
key1 = self._box.add(msg1)
key2 = self._box.add(msg2)
key3 = self._box.add(msg3)
- self.assert_(self._box.get_sequences() ==
+ self.assertEqual(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.assertEqual(self._box.get_sequences(),
{'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3],
'replied':[key3]})
self._box.pack()
@@ -889,7 +889,7 @@
key0 = key0
key1 = key0 + 1
key2 = key1 + 1
- self.assert_(self._box.get_sequences() ==
+ self.assertEqual(self._box.get_sequences(),
{'foo':[1, 2, 3], 'unseen':[1], 'bar':[3], 'replied':[3]})
# Test case for packing while holding the mailbox locked.
@@ -903,7 +903,7 @@
self._box.lock()
self._box.pack()
self._box.unlock()
- self.assert_(self._box.get_sequences() ==
+ self.assertEqual(self._box.get_sequences(),
{'foo':[1, 2, 3, 4, 5],
'unseen':[1], 'bar':[3], 'replied':[3]})
@@ -930,10 +930,10 @@
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.assertEqual(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.assertEqual(set(self._box.get_labels()),
set(['foo', 'bar', 'blah']))
self._box.remove(key1)
self.assertEqual(set(self._box.get_labels()), set(['blah']))
@@ -1097,14 +1097,14 @@
msg = mailbox.Message(_sample_message)
msg.set_unixfrom('From foo at bar blah')
msg = mailbox.mboxMessage(msg)
- self.assert_(msg.get_from() == 'foo at bar blah', msg.get_from())
+ self.assertEqual(msg.get_from(), 'foo at 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.assertEqual(msg.get_from(), 'foo bar')
msg.set_from('foo at bar', True)
self._check_from(msg, 'foo at bar')
msg.set_from('blah at temp', time.localtime())
@@ -1155,17 +1155,17 @@
msg.add_sequence('unseen')
self.assertEqual(msg.get_sequences(), ['unseen'])
msg.add_sequence('flagged')
- self.assert_(msg.get_sequences() == ['unseen', 'flagged'])
+ self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
msg.add_sequence('flagged')
- self.assert_(msg.get_sequences() == ['unseen', 'flagged'])
+ self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
msg.remove_sequence('unseen')
self.assertEqual(msg.get_sequences(), ['flagged'])
msg.add_sequence('foobar')
- self.assert_(msg.get_sequences() == ['flagged', 'foobar'])
+ self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
msg.remove_sequence('replied')
- self.assert_(msg.get_sequences() == ['flagged', 'foobar'])
+ self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
msg.set_sequences(['foobar', 'replied'])
- self.assert_(msg.get_sequences() == ['foobar', 'replied'])
+ self.assertEqual(msg.get_sequences(), ['foobar', 'replied'])
class TestBabylMessage(TestMessage):
@@ -1186,17 +1186,17 @@
msg.add_label('filed')
self.assertEqual(msg.get_labels(), ['filed'])
msg.add_label('resent')
- self.assert_(msg.get_labels() == ['filed', 'resent'])
+ self.assertEqual(msg.get_labels(), ['filed', 'resent'])
msg.add_label('resent')
- self.assert_(msg.get_labels() == ['filed', 'resent'])
+ self.assertEqual(msg.get_labels(), ['filed', 'resent'])
msg.remove_label('filed')
self.assertEqual(msg.get_labels(), ['resent'])
msg.add_label('foobar')
- self.assert_(msg.get_labels() == ['resent', 'foobar'])
+ self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
msg.remove_label('unseen')
- self.assert_(msg.get_labels() == ['resent', 'foobar'])
+ self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
msg.set_labels(['foobar', 'answered'])
- self.assert_(msg.get_labels() == ['foobar', 'answered'])
+ self.assertEqual(msg.get_labels(), ['foobar', 'answered'])
def test_visible(self):
# Get, set, and update visible headers
@@ -1214,11 +1214,11 @@
self.assertEqual(visible['X-Whatever'], 'Blah')
self.assert_(visible.get_payload() is None)
msg.update_visible()
- self.assert_(visible.keys() == ['User-Agent', 'X-Whatever'])
+ self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
self.assert_(visible.get_payload() is None)
visible = msg.get_visible()
- self.assert_(visible.keys() == ['User-Agent', 'Date', 'From', 'To',
- 'Subject'])
+ self.assertEqual(visible.keys(), ['User-Agent', 'Date', 'From', 'To',
+ 'Subject'])
for header in ('User-Agent', 'Date', 'From', 'To', 'Subject'):
self.assertEqual(visible[header], msg[header])
@@ -1278,7 +1278,7 @@
msg_maildir.set_flags(setting)
msg = class_(msg_maildir)
self.assertEqual(msg.get_flags(), result)
- self.assert_(msg.get_from() == 'MAILER-DAEMON %s' %
+ self.assertEqual(msg.get_from(), 'MAILER-DAEMON %s' %
time.asctime(time.gmtime(0.0)))
msg_maildir.set_subdir('cur')
self.assertEqual(class_(msg_maildir).get_flags(), 'RODFA')
@@ -1291,8 +1291,8 @@
('T', ['unseen']), ('DFPRST', ['replied', 'flagged']))
for setting, result in pairs:
msg_maildir.set_flags(setting)
- self.assert_(mailbox.MHMessage(msg_maildir).get_sequences() == \
- result)
+ self.assertEqual(mailbox.MHMessage(msg_maildir).get_sequences(),
+ result)
def test_maildir_to_babyl(self):
# Convert MaildirMessage to Babyl
@@ -1303,8 +1303,8 @@
('DFPRST', ['deleted', 'answered', 'forwarded']))
for setting, result in pairs:
msg_maildir.set_flags(setting)
- self.assert_(mailbox.BabylMessage(msg_maildir).get_labels() == \
- result)
+ self.assertEqual(mailbox.BabylMessage(msg_maildir).get_labels(),
+ result)
def test_mboxmmdf_to_maildir(self):
# Convert mboxMessage and MMDFMessage to MaildirMessage
@@ -1319,8 +1319,8 @@
self.assertEqual(msg.get_flags(), result)
self.assert_(msg.get_date() == 0.0, msg.get_date())
msg_mboxMMDF.set_flags('O')
- self.assert_(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir() == \
- 'cur')
+ self.assertEqual(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir(),
+ 'cur')
def test_mboxmmdf_to_mboxmmdf(self):
# Convert mboxMessage and MMDFMessage to mboxMessage and MMDFMessage
@@ -1343,8 +1343,8 @@
('RODFA', ['replied', 'flagged']))
for setting, result in pairs:
msg_mboxMMDF.set_flags(setting)
- self.assert_(mailbox.MHMessage(msg_mboxMMDF).get_sequences() \
- == result)
+ self.assertEqual(mailbox.MHMessage(msg_mboxMMDF).get_sequences(),
+ result)
def test_mboxmmdf_to_babyl(self):
# Convert mboxMessage and MMDFMessage to BabylMessage
@@ -1394,8 +1394,8 @@
msg.add_sequence('unseen')
msg.add_sequence('replied')
msg.add_sequence('flagged')
- self.assert_(mailbox.MHMessage(msg).get_sequences() == \
- ['unseen', 'replied', 'flagged'])
+ self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
+ ['unseen', 'replied', 'flagged'])
def test_mh_to_babyl(self):
# Convert MHMessage to BabylMessage
@@ -1409,8 +1409,8 @@
msg.add_sequence('unseen')
msg.add_sequence('replied')
msg.add_sequence('flagged')
- self.assert_(mailbox.BabylMessage(msg).get_labels() == \
- ['unseen', 'answered'])
+ self.assertEqual(mailbox.BabylMessage(msg).get_labels(),
+ ['unseen', 'answered'])
def test_babyl_to_maildir(self):
# Convert BabylMessage to MaildirMessage
@@ -1459,8 +1459,8 @@
for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
'edited', 'resent'):
msg.add_label(label)
- self.assert_(mailbox.MHMessage(msg).get_sequences() == \
- ['unseen', 'replied'])
+ self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
+ ['unseen', 'replied'])
def test_babyl_to_babyl(self):
# Convert BabylMessage to BabylMessage
@@ -1470,9 +1470,9 @@
'edited', 'resent'):
msg.add_label(label)
msg2 = mailbox.BabylMessage(msg)
- self.assert_(msg2.get_labels() == ['unseen', 'deleted', 'filed',
- 'answered', 'forwarded', 'edited',
- 'resent'])
+ self.assertEqual(msg2.get_labels(), ['unseen', 'deleted', 'filed',
+ 'answered', 'forwarded', 'edited',
+ 'resent'])
self.assertEqual(msg.get_visible().keys(), msg2.get_visible().keys())
for key in msg.get_visible().keys():
self.assertEqual(msg.get_visible()[key], msg2.get_visible()[key])
@@ -1496,40 +1496,40 @@
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.assertEqual(proxy.readline(), 'foo' + os.linesep)
+ self.assertEqual(proxy.readline(), 'bar' + os.linesep)
+ self.assertEqual(proxy.readline(), 'fred' + os.linesep)
self.assertEqual(proxy.readline(), 'bob')
proxy.seek(2)
- self.assert_(proxy.readline() == 'o' + os.linesep)
+ self.assertEqual(proxy.readline(), 'o' + os.linesep)
proxy.seek(6 + 2 * len(os.linesep))
- self.assert_(proxy.readline() == 'fred' + os.linesep)
+ self.assertEqual(proxy.readline(), 'fred' + os.linesep)
proxy.seek(6 + 2 * len(os.linesep))
self.assertEqual(proxy.readline(2), 'fr')
- self.assert_(proxy.readline(-10) == 'ed' + os.linesep)
+ self.assertEqual(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.assertEqual(proxy.readlines(), ['foo' + os.linesep,
'bar' + os.linesep,
'fred' + os.linesep, 'bob'])
proxy.seek(0)
- self.assert_(proxy.readlines(2) == ['foo' + os.linesep])
+ self.assertEqual(proxy.readlines(2), ['foo' + os.linesep])
proxy.seek(3 + len(os.linesep))
- self.assert_(proxy.readlines(4 + len(os.linesep)) ==
+ self.assertEqual(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.assertEqual(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_(next(iterator) == 'foo' + os.linesep)
- self.assert_(next(iterator) == 'bar' + os.linesep)
- self.assert_(next(iterator) == 'fred' + os.linesep)
+ self.assertEqual(next(iterator), 'foo' + os.linesep)
+ self.assertEqual(next(iterator), 'bar' + os.linesep)
+ self.assertEqual(next(iterator), 'fred' + os.linesep)
self.assertEqual(next(iterator), 'bob')
self.assertRaises(StopIteration, next, iterator)
@@ -1539,11 +1539,11 @@
self.assertEqual(proxy.tell(), 3)
self.assertEqual(proxy.read(len(os.linesep)), os.linesep)
proxy.seek(2, 1)
- self.assert_(proxy.read(1 + len(os.linesep)) == 'r' + os.linesep)
+ self.assertEqual(proxy.read(1 + len(os.linesep)), 'r' + os.linesep)
proxy.seek(-3 - len(os.linesep), 2)
self.assertEqual(proxy.read(3), 'bar')
proxy.seek(2, 0)
- self.assert_(proxy.read() == 'o' + os.linesep + 'bar' + os.linesep)
+ self.assertEqual(proxy.read(), 'o' + os.linesep + 'bar' + os.linesep)
proxy.seek(100)
self.assertEqual(proxy.read(), '')
More information about the Python-3000-checkins
mailing list