Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_mailbox.py

    r2 r391  
    66import email
    77import email.message
    8 import rfc822
    98import re
     9import shutil
    1010import StringIO
     11import tempfile
    1112from test import test_support
    1213import unittest
    … …  
    1819    pass
    1920
    20 
    21 class TestBase(unittest.TestCase):
     21# Silence Py3k warning
     22rfc822 = test_support.import_module('rfc822', deprecated=True)
     23
     24class TestBase:
    2225
    2326    def _check_sample(self, msg):
    2427        # Inspect a mailbox.Message representation of the sample message
    25         self.assert_(isinstance(msg, email.message.Message))
    26         self.assert_(isinstance(msg, mailbox.Message))
     28        self.assertIsInstance(msg, email.message.Message)
     29        self.assertIsInstance(msg, mailbox.Message)
    2730        for key, value in _sample_headers.iteritems():
    28             self.assert_(value in msg.get_all(key))
    29         self.assert_(msg.is_multipart())
    30         self.assert_(len(msg.get_payload()) == len(_sample_payloads))
     31            self.assertIn(value, msg.get_all(key))
     32        self.assertTrue(msg.is_multipart())
     33        self.assertEqual(len(msg.get_payload()), len(_sample_payloads))
    3134        for i, payload in enumerate(_sample_payloads):
    3235            part = msg.get_payload(i)
    33             self.assert_(isinstance(part, email.message.Message))
    34             self.assert_(not isinstance(part, mailbox.Message))
    35             self.assert_(part.get_payload() == payload)
     36            self.assertIsInstance(part, email.message.Message)
     37            self.assertNotIsInstance(part, mailbox.Message)
     38            self.assertEqual(part.get_payload(), payload)
    3639
    3740    def _delete_recursively(self, target):
    3841        # Delete a file or delete a directory recursively
    3942        if os.path.isdir(target):
    40             for path, dirs, files in os.walk(target, topdown=False):
    41                 for name in files:
    42                     os.remove(os.path.join(path, name))
    43                 for name in dirs:
    44                     os.rmdir(os.path.join(path, name))
    45             os.rmdir(target)
     43            test_support.rmtree(target)
    4644        elif os.path.exists(target):
    47             os.remove(target)
     45            test_support.unlink(target)
    4846
    4947
    … …  
    5149
    5250    _factory = None     # Overridden by subclasses to reuse tests
    53     _template = 'From: foo\n\n%s'
     51    _template = 'From: foo\n\n%s\n'
    5452
    5553    def setUp(self):
    … …  
    6664        keys = []
    6765        keys.append(self._box.add(self._template % 0))
    68         self.assert_(len(self._box) == 1)
     66        self.assertEqual(len(self._box), 1)
    6967        keys.append(self._box.add(mailbox.Message(_sample_message)))
    70         self.assert_(len(self._box) == 2)
     68        self.assertEqual(len(self._box), 2)
    7169        keys.append(self._box.add(email.message_from_string(_sample_message)))
    72         self.assert_(len(self._box) == 3)
     70        self.assertEqual(len(self._box), 3)
    7371        keys.append(self._box.add(StringIO.StringIO(_sample_message)))
    74         self.assert_(len(self._box) == 4)
     72        self.assertEqual(len(self._box), 4)
    7573        keys.append(self._box.add(_sample_message))
    76         self.assert_(len(self._box) == 5)
    77         self.assert_(self._box.get_string(keys[0]) == self._template % 0)
     74        self.assertEqual(len(self._box), 5)
     75        self.assertEqual(self._box.get_string(keys[0]), self._template % 0)
    7876        for i in (1, 2, 3, 4):
    7977            self._check_sample(self._box[keys[i]])
     78
     79    def test_add_file(self):
     80        with tempfile.TemporaryFile('w+') as f:
     81            f.write(_sample_message)
     82            f.seek(0)
     83            key = self._box.add(f)
     84        self.assertEqual(self._box.get_string(key).split('\n'),
     85            _sample_message.split('\n'))
     86
     87    def test_add_StringIO(self):
     88        key = self._box.add(StringIO.StringIO(self._template % "0"))
     89        self.assertEqual(self._box.get_string(key), self._template % "0")
    8090
    8191    def test_remove(self):
    … …  
    91101        key0 = self._box.add(self._template % 0)
    92102        key1 = self._box.add(self._template % 1)
    93         self.assert_(len(self._box) == 2)
     103        self.assertEqual(len(self._box), 2)
    94104        method(key0)
    95105        l = len(self._box)
    96         self.assert_(l == 1, "actual l: %s" % l)
     106        self.assertEqual(l, 1)
    97107        self.assertRaises(KeyError, lambda: self._box[key0])
    98108        self.assertRaises(KeyError, lambda: method(key0))
    99         self.assert_(self._box.get_string(key1) == self._template % 1)
     109        self.assertEqual(self._box.get_string(key1), self._template % 1)
    100110        key2 = self._box.add(self._template % 2)
    101         self.assert_(len(self._box) == 2)
     111        self.assertEqual(len(self._box), 2)
    102112        method(key2)
    103113        l = len(self._box)
    104         self.assert_(l == 1, "actual l: %s" % l)
     114        self.assertEqual(l, 1)
    105115        self.assertRaises(KeyError, lambda: self._box[key2])
    106116        self.assertRaises(KeyError, lambda: method(key2))
    107         self.assert_(self._box.get_string(key1) == self._template % 1)
     117        self.assertEqual(self._box.get_string(key1), self._template % 1)
    108118        method(key1)
    109         self.assert_(len(self._box) == 0)
     119        self.assertEqual(len(self._box), 0)
    110120        self.assertRaises(KeyError, lambda: self._box[key1])
    111121        self.assertRaises(KeyError, lambda: method(key1))
    … …  
    115125        key0 = self._box.add(self._template % 0)
    116126        key1 = self._box.add(self._template % 1)
    117         self.assert_(len(self._box) == 2)
     127        self.assertEqual(len(self._box), 2)
    118128        self._box.discard(key0)
    119         self.assert_(len(self._box) == 1)
     129        self.assertEqual(len(self._box), 1)
    120130        self.assertRaises(KeyError, lambda: self._box[key0])
    121131        self._box.discard(key0)
    122         self.assert_(len(self._box) == 1)
     132        self.assertEqual(len(self._box), 1)
    123133        self.assertRaises(KeyError, lambda: self._box[key0])
    124134
    … …  
    127137        key0 = self._box.add(self._template % 0)
    128138        msg = self._box.get(key0)
    129         self.assert_(msg['from'] == 'foo')
    130         self.assert_(msg.get_payload() == '0')
    131         self.assert_(self._box.get('foo') is None)
    132         self.assert_(self._box.get('foo', False) is False)
     139        self.assertEqual(msg['from'], 'foo')
     140        self.assertEqual(msg.get_payload(), '0\n')
     141        self.assertIs(self._box.get('foo'), None)
     142        self.assertFalse(self._box.get('foo', False))
    133143        self._box.close()
    134144        self._box = self._factory(self._path, factory=rfc822.Message)
    135145        key1 = self._box.add(self._template % 1)
    136146        msg = self._box.get(key1)
    137         self.assert_(msg['from'] == 'foo')
    138         self.assert_(msg.fp.read() == '1')
     147        self.assertEqual(msg['from'], 'foo')
     148        self.assertEqual(msg.fp.read(), '1' + os.linesep)
     149        msg.fp.close()
    139150
    140151    def test_getitem(self):
    … …  
    142153        key0 = self._box.add(self._template % 0)
    143154        msg = self._box[key0]
    144         self.assert_(msg['from'] == 'foo')
    145         self.assert_(msg.get_payload() == '0')
     155        self.assertEqual(msg['from'], 'foo')
     156        self.assertEqual(msg.get_payload(), '0\n')
    146157        self.assertRaises(KeyError, lambda: self._box['foo'])
    147158        self._box.discard(key0)
    … …  
    153164        key1 = self._box.add(_sample_message)
    154165        msg0 = self._box.get_message(key0)
    155         self.assert_(isinstance(msg0, mailbox.Message))
    156         self.assert_(msg0['from'] == 'foo')
    157         self.assert_(msg0.get_payload() == '0')
     166        self.assertIsInstance(msg0, mailbox.Message)
     167        self.assertEqual(msg0['from'], 'foo')
     168        self.assertEqual(msg0.get_payload(), '0\n')
    158169        self._check_sample(self._box.get_message(key1))
    159170
    … …  
    162173        key0 = self._box.add(self._template % 0)
    163174        key1 = self._box.add(_sample_message)
    164         self.assert_(self._box.get_string(key0) == self._template % 0)
    165         self.assert_(self._box.get_string(key1) == _sample_message)
     175        self.assertEqual(self._box.get_string(key0), self._template % 0)
     176        self.assertEqual(self._box.get_string(key1), _sample_message)
    166177
    167178    def test_get_file(self):
    … …  
    169180        key0 = self._box.add(self._template % 0)
    170181        key1 = self._box.add(_sample_message)
    171         self.assert_(self._box.get_file(key0).read().replace(os.linesep, '\n')
    172                      == self._template % 0)
    173         self.assert_(self._box.get_file(key1).read().replace(os.linesep, '\n')
    174                      == _sample_message)
     182        msg0 = self._box.get_file(key0)
     183        self.assertEqual(msg0.read().replace(os.linesep, '\n'),
     184                         self._template % 0)
     185        msg1 = self._box.get_file(key1)
     186        self.assertEqual(msg1.read().replace(os.linesep, '\n'),
     187                         _sample_message)
     188        msg0.close()
     189        msg1.close()
     190
     191    def test_get_file_can_be_closed_twice(self):
     192        # Issue 11700
     193        key = self._box.add(_sample_message)
     194        f = self._box.get_file(key)
     195        f.close()
     196        f.close()
    175197
    176198    def test_iterkeys(self):
    … …  
    222244                returned_values.append(value)
    223245        if do_keys:
    224             self.assert_(len(keys) == len(returned_keys))
    225             self.assert_(set(keys) == set(returned_keys))
     246            self.assertEqual(len(keys), len(returned_keys))
     247            self.assertEqual(set(keys), set(returned_keys))
    226248        if do_values:
    227249            count = 0
    228250            for value in returned_values:
    229                 self.assert_(value['from'] == 'foo')
    230                 self.assert_(int(value.get_payload()) < repetitions)
     251                self.assertEqual(value['from'], 'foo')
     252                self.assertTrue(int(value.get_payload()) < repetitions,
     253                                (value.get_payload(), repetitions))
    231254                count += 1
    232             self.assert_(len(values) == count)
     255            self.assertEqual(len(values), count)
    233256
    234257    def test_has_key(self):
    … …  
    242265    def _test_has_key_or_contains(self, method):
    243266        # (Used by test_has_key() and test_contains().)
    244         self.assert_(not method('foo'))
     267        self.assertFalse(method('foo'))
    245268        key0 = self._box.add(self._template % 0)
    246         self.assert_(method(key0))
    247         self.assert_(not method('foo'))
     269        self.assertTrue(method(key0))
     270        self.assertFalse(method('foo'))
    248271        key1 = self._box.add(self._template % 1)
    249         self.assert_(method(key1))
    250         self.assert_(method(key0))
    251         self.assert_(not method('foo'))
     272        self.assertTrue(method(key1))
     273        self.assertTrue(method(key0))
     274        self.assertFalse(method('foo'))
    252275        self._box.remove(key0)
    253         self.assert_(not method(key0))
    254         self.assert_(method(key1))
    255         self.assert_(not method('foo'))
     276        self.assertFalse(method(key0))
     277        self.assertTrue(method(key1))
     278        self.assertFalse(method('foo'))
    256279        self._box.remove(key1)
    257         self.assert_(not method(key1))
    258         self.assert_(not method(key0))
    259         self.assert_(not method('foo'))
     280        self.assertFalse(method(key1))
     281        self.assertFalse(method(key0))
     282        self.assertFalse(method('foo'))
    260283
    261284    def test_len(self, repetitions=10):
    … …  
    263286        keys = []
    264287        for i in xrange(repetitions):
    265             self.assert_(len(self._box) == i)
     288            self.assertEqual(len(self._box), i)
    266289            keys.append(self._box.add(self._template % i))
    267             self.assert_(len(self._box) == i + 1)
     290            self.assertEqual(len(self._box), i + 1)
    268291        for i in xrange(repetitions):
    269             self.assert_(len(self._box) == repetitions - i)
     292            self.assertEqual(len(self._box), repetitions - i)
    270293            self._box.remove(keys[i])
    271             self.assert_(len(self._box) == repetitions - i - 1)
     294            self.assertEqual(len(self._box), repetitions - i - 1)
    272295
    273296    def test_set_item(self):
    274297        # Modify messages using __setitem__()
    275298        key0 = self._box.add(self._template % 'original 0')
    276         self.assert_(self._box.get_string(key0) == \
    277                      self._template % 'original 0')
     299        self.assertEqual(self._box.get_string(key0),
     300                         self._template % 'original 0')
    278301        key1 = self._box.add(self._template % 'original 1')
    279         self.assert_(self._box.get_string(key1) == \
    280                      self._template % 'original 1')
     302        self.assertEqual(self._box.get_string(key1),
     303                         self._template % 'original 1')
    281304        self._box[key0] = self._template % 'changed 0'
    282         self.assert_(self._box.get_string(key0) == \
    283                      self._template % 'changed 0')
     305        self.assertEqual(self._box.get_string(key0),
     306                         self._template % 'changed 0')
    284307        self._box[key1] = self._template % 'changed 1'
    285         self.assert_(self._box.get_string(key1) == \
    286                      self._template % 'changed 1')
     308        self.assertEqual(self._box.get_string(key1),
     309                         self._template % 'changed 1')
    287310        self._box[key0] = _sample_message
    288311        self._check_sample(self._box[key0])
    … …  
    290313        self._check_sample(self._box[key1])
    291314        self._box[key0] = self._template % 'original 0'
    292         self.assert_(self._box.get_string(key0) ==
    293                      self._template % 'original 0')
     315        self.assertEqual(self._box.get_string(key0),
     316                         self._template % 'original 0')
    294317        self._check_sample(self._box[key1])
    295318        self.assertRaises(KeyError,
    296319                          lambda: self._box.__setitem__('foo', 'bar'))
    297320        self.assertRaises(KeyError, lambda: self._box['foo'])
    298         self.assert_(len(self._box) == 2)
     321        self.assertEqual(len(self._box), 2)
    299322
    300323    def test_clear(self, iterations=10):
    … …  
    304327            self._box.add(self._template % i)
    305328        for i, key in enumerate(keys):
    306             self.assert_(self._box.get_string(key) == self._template % i)
     329            self.assertEqual(self._box.get_string(key), self._template % i)
    307330        self._box.clear()
    308         self.assert_(len(self._box) == 0)
     331        self.assertEqual(len(self._box), 0)
    309332        for i, key in enumerate(keys):
    310333            self.assertRaises(KeyError, lambda: self._box.get_string(key))
    … …  
    313336        # Get and remove a message using pop()
    314337        key0 = self._box.add(self._template % 0)
    315         self.assert_(key0 in self._box)
     338        self.assertIn(key0, self._box)
    316339        key1 = self._box.add(self._template % 1)
    317         self.assert_(key1 in self._box)
    318         self.assert_(self._box.pop(key0).get_payload() == '0')
    319         self.assert_(key0 not in self._box)
    320         self.assert_(key1 in self._box)
     340        self.assertIn(key1, self._box)
     341        self.assertEqual(self._box.pop(key0).get_payload(), '0\n')
     342        self.assertNotIn(key0, self._box)
     343        self.assertIn(key1, self._box)
    321344        key2 = self._box.add(self._template % 2)
    322         self.assert_(key2 in self._box)
    323         self.assert_(self._box.pop(key2).get_payload() == '2')
    324         self.assert_(key2 not in self._box)
    325         self.assert_(key1 in self._box)
    326         self.assert_(self._box.pop(key1).get_payload() == '1')
    327         self.assert_(key1 not in self._box)
    328         self.assert_(len(self._box) == 0)
     345        self.assertIn(key2, self._box)
     346        self.assertEqual(self._box.pop(key2).get_payload(), '2\n')
     347        self.assertNotIn(key2, self._box)
     348        self.assertIn(key1, self._box)
     349        self.assertEqual(self._box.pop(key1).get_payload(), '1\n')
     350        self.assertNotIn(key1, self._box)
     351        self.assertEqual(len(self._box), 0)
    329352
    330353    def test_popitem(self, iterations=10):
    … …  
    336359        for i in xrange(10):
    337360            key, msg = self._box.popitem()
    338             self.assert_(key in keys)
    339             self.assert_(key not in seen)
     361            self.assertIn(key, keys)
     362            self.assertNotIn(key, seen)
    340363            seen.append(key)
    341             self.assert_(int(msg.get_payload()) == keys.index(key))
    342         self.assert_(len(self._box) == 0)
     364            self.assertEqual(int(msg.get_payload()), keys.index(key))
     365        self.assertEqual(len(self._box), 0)
    343366        for key in keys:
    344367            self.assertRaises(KeyError, lambda: self._box[key])
    … …  
    351374        self._box.update({key0: self._template % 'changed 0',
    352375                          key2: _sample_message})
    353         self.assert_(len(self._box) == 3)
    354         self.assert_(self._box.get_string(key0) ==
    355                      self._template % 'changed 0')
    356         self.assert_(self._box.get_string(key1) ==
    357                      self._template % 'original 1')
     376        self.assertEqual(len(self._box), 3)
     377        self.assertEqual(self._box.get_string(key0),
     378                         self._template % 'changed 0')
     379        self.assertEqual(self._box.get_string(key1),
     380                         self._template % 'original 1')
    358381        self._check_sample(self._box[key2])
    359382        self._box.update([(key2, self._template % 'changed 2'),
    360383                    (key1, self._template % 'changed 1'),
    361384                    (key0, self._template % 'original 0')])
    362         self.assert_(len(self._box) == 3)
    363         self.assert_(self._box.get_string(key0) ==
    364                      self._template % 'original 0')
    365         self.assert_(self._box.get_string(key1) ==
    366                      self._template % 'changed 1')
    367         self.assert_(self._box.get_string(key2) ==
    368                      self._template % 'changed 2')
     385        self.assertEqual(len(self._box), 3)
     386        self.assertEqual(self._box.get_string(key0),
     387                         self._template % 'original 0')
     388        self.assertEqual(self._box.get_string(key1),
     389                         self._template % 'changed 1')
     390        self.assertEqual(self._box.get_string(key2),
     391                         self._template % 'changed 2')
    369392        self.assertRaises(KeyError,
    370393                          lambda: self._box.update({'foo': 'bar',
    371394                                          key0: self._template % "changed 0"}))
    372         self.assert_(len(self._box) == 3)
    373         self.assert_(self._box.get_string(key0) ==
    374                      self._template % "changed 0")
    375         self.assert_(self._box.get_string(key1) ==
    376                      self._template % "changed 1")
    377         self.assert_(self._box.get_string(key2) ==
    378                      self._template % "changed 2")
     395        self.assertEqual(len(self._box), 3)
     396        self.assertEqual(self._box.get_string(key0),
     397                         self._template % "changed 0")
     398        self.assertEqual(self._box.get_string(key1),
     399                         self._template % "changed 1")
     400        self.assertEqual(self._box.get_string(key2),
     401                         self._template % "changed 2")
    379402
    380403    def test_flush(self):
    … …  
    382405        self._test_flush_or_close(self._box.flush, True)
    383406
     407    def test_popitem_and_flush_twice(self):
     408        # See #15036.
     409        self._box.add(self._template % 0)
     410        self._box.add(self._template % 1)
     411        self._box.flush()
     412
     413        self._box.popitem()
     414        self._box.flush()
     415        self._box.popitem()
     416        self._box.flush()
     417
    384418    def test_lock_unlock(self):
    385419        # Lock and unlock the mailbox
    386         self.assert_(not os.path.exists(self._get_lock_path()))
     420        self.assertFalse(os.path.exists(self._get_lock_path()))
    387421        self._box.lock()
    388         self.assert_(os.path.exists(self._get_lock_path()))
     422        self.assertTrue(os.path.exists(self._get_lock_path()))
    389423        self._box.unlock()
    390         self.assert_(not os.path.exists(self._get_lock_path()))
     424        self.assertFalse(os.path.exists(self._get_lock_path()))
    391425
    392426    def test_close(self):
    … …  
    399433        self._box.add(contents[1])
    400434        self._box.add(contents[2])
     435        oldbox = self._box
    401436        method()
    402437        if should_call_close:
    … …  
    404439        self._box = self._factory(self._path)
    405440        keys = self._box.keys()
    406         self.assert_(len(keys) == 3)
     441        self.assertEqual(len(keys), 3)
    407442        for key in keys:
    408             self.assert_(self._box.get_string(key) in contents)
     443            self.assertIn(self._box.get_string(key), contents)
     444        oldbox.close()
    409445
    410446    def test_dump_message(self):
    … …  
    414450            output = StringIO.StringIO()
    415451            self._box._dump_message(input, output)
    416             self.assert_(output.getvalue() ==
    417                          _sample_message.replace('\n', os.linesep))
     452            self.assertEqual(output.getvalue(),
     453                             _sample_message.replace('\n', os.linesep))
    418454        output = StringIO.StringIO()
    419455        self.assertRaises(TypeError,
    … …  
    425461
    426462
    427 class TestMailboxSuperclass(TestBase):
     463class TestMailboxSuperclass(TestBase, unittest.TestCase):
    428464
    429465    def test_notimplemented(self):
    … …  
    460496
    461497
    462 class TestMaildir(TestMailbox):
     498class TestMaildir(TestMailbox, unittest.TestCase):
    463499
    464500    _factory = lambda self, path, factory=None: mailbox.Maildir(path, factory)
    … …  
    475511        msg.set_info('foo')
    476512        key = self._box.add(msg)
    477         self.assert_(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' %
     513        self.assertTrue(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' %
    478514                                                 (key, self._box.colon))))
    479515
    … …  
    485521        key = self._box.add(msg)
    486522        msg_returned = self._box.get_message(key)
    487         self.assert_(isinstance(msg_returned, mailbox.MaildirMessage))
    488         self.assert_(msg_returned.get_subdir() == 'cur')
    489         self.assert_(msg_returned.get_flags() == 'FR')
     523        self.assertIsInstance(msg_returned, mailbox.MaildirMessage)
     524        self.assertEqual(msg_returned.get_subdir(), 'cur')
     525        self.assertEqual(msg_returned.get_flags(), 'FR')
    490526
    491527    def test_set_MM(self):
    … …  
    495531        key = self._box.add(msg0)
    496532        msg_returned = self._box.get_message(key)
    497         self.assert_(msg_returned.get_subdir() == 'new')
    498         self.assert_(msg_returned.get_flags() == 'PT')
     533        self.assertEqual(msg_returned.get_subdir(), 'new')
     534        self.assertEqual(msg_returned.get_flags(), 'PT')
    499535        msg1 = mailbox.MaildirMessage(self._template % 1)
    500536        self._box[key] = msg1
    501537        msg_returned = self._box.get_message(key)
    502         self.assert_(msg_returned.get_subdir() == 'new')
    503         self.assert_(msg_returned.get_flags() == '')
    504         self.assert_(msg_returned.get_payload() == '1')
     538        self.assertEqual(msg_returned.get_subdir(), 'new')
     539        self.assertEqual(msg_returned.get_flags(), '')
     540        self.assertEqual(msg_returned.get_payload(), '1\n')
    505541        msg2 = mailbox.MaildirMessage(self._template % 2)
    506542        msg2.set_info('2,S')
    … …  
    508544        self._box[key] = self._template % 3
    509545        msg_returned = self._box.get_message(key)
    510         self.assert_(msg_returned.get_subdir() == 'new')
    511         self.assert_(msg_returned.get_flags() == 'S')
    512         self.assert_(msg_returned.get_payload() == '3')
     546        self.assertEqual(msg_returned.get_subdir(), 'new')
     547        self.assertEqual(msg_returned.get_flags(), 'S')
     548        self.assertEqual(msg_returned.get_payload(), '3\n')
    513549
    514550    def test_consistent_factory(self):
    … …  
    525561        box.colon = self._box.colon
    526562        msg2 = box.get_message(key)
    527         self.assert_(isinstance(msg2, FakeMessage))
     563        self.assertIsInstance(msg2, FakeMessage)
    528564
    529565    def test_initialize_new(self):
    … …  
    553589            path = os.path.join(self._path, subdir)
    554590            mode = os.stat(path)[stat.ST_MODE]
    555             self.assert_(stat.S_ISDIR(mode), "Not a directory: '%s'" % path)
     591            self.assertTrue(stat.S_ISDIR(mode), "Not a directory: '%s'" % path)
    556592
    557593    def test_list_folders(self):
    … …  
    560596        self._box.add_folder('two')
    561597        self._box.add_folder('three')
    562         self.assert_(len(self._box.list_folders()) == 3)
    563         self.assert_(set(self._box.list_folders()) ==
    564                      set(('one', 'two', 'three')))
     598        self.assertEqual(len(self._box.list_folders()), 3)
     599        self.assertEqual(set(self._box.list_folders()),
     600                         set(('one', 'two', 'three')))
    565601
    566602    def test_get_folder(self):
    … …  
    569605        folder0 = self._box.get_folder('foo.bar')
    570606        folder0.add(self._template % 'bar')
    571         self.assert_(os.path.isdir(os.path.join(self._path, '.foo.bar')))
     607        self.assertTrue(os.path.isdir(os.path.join(self._path, '.foo.bar')))
    572608        folder1 = self._box.get_folder('foo.bar')
    573         self.assert_(folder1.get_string(folder1.keys()[0]) == \
    574                      self._template % 'bar')
     609        self.assertEqual(folder1.get_string(folder1.keys()[0]),
     610                         self._template % 'bar')
    575611
    576612    def test_add_and_remove_folders(self):
    … …  
    578614        self._box.add_folder('one')
    579615        self._box.add_folder('two')
    580         self.assert_(len(self._box.list_folders()) == 2)
    581         self.assert_(set(self._box.list_folders()) == set(('one', 'two')))
     616        self.assertEqual(len(self._box.list_folders()), 2)
     617        self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
    582618        self._box.remove_folder('one')
    583         self.assert_(len(self._box.list_folders()) == 1)
    584         self.assert_(set(self._box.list_folders()) == set(('two',)))
     619        self.assertEqual(len(self._box.list_folders()), 1)
     620        self.assertEqual(set(self._box.list_folders()), set(('two',)))
    585621        self._box.add_folder('three')
    586         self.assert_(len(self._box.list_folders()) == 2)
    587         self.assert_(set(self._box.list_folders()) == set(('two', 'three')))
     622        self.assertEqual(len(self._box.list_folders()), 2)
     623        self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
    588624        self._box.remove_folder('three')
    589         self.assert_(len(self._box.list_folders()) == 1)
    590         self.assert_(set(self._box.list_folders()) == set(('two',)))
     625        self.assertEqual(len(self._box.list_folders()), 1)
     626        self.assertEqual(set(self._box.list_folders()), set(('two',)))
    591627        self._box.remove_folder('two')
    592         self.assert_(len(self._box.list_folders()) == 0)
    593         self.assert_(self._box.list_folders() == [])
     628        self.assertEqual(len(self._box.list_folders()), 0)
     629        self.assertEqual(self._box.list_folders(), [])
    594630
    595631    def test_clean(self):
    … …  
    597633        foo_path = os.path.join(self._path, 'tmp', 'foo')
    598634        bar_path = os.path.join(self._path, 'tmp', 'bar')
    599         f = open(foo_path, 'w')
    600         f.write("@")
    601         f.close()
    602         f = open(bar_path, 'w')
    603         f.write("@")
    604         f.close()
     635        with open(foo_path, 'w') as f:
     636            f.write("@")
     637        with open(bar_path, 'w') as f:
     638            f.write("@")
    605639        self._box.clean()
    606         self.assert_(os.path.exists(foo_path))
    607         self.assert_(os.path.exists(bar_path))
     640        self.assertTrue(os.path.exists(foo_path))
     641        self.assertTrue(os.path.exists(bar_path))
    608642        foo_stat = os.stat(foo_path)
    609643        os.utime(foo_path, (time.time() - 129600 - 2,
    610644                            foo_stat.st_mtime))
    611645        self._box.clean()
    612         self.assert_(not os.path.exists(foo_path))
    613         self.assert_(os.path.exists(bar_path))
     646        self.assertFalse(os.path.exists(foo_path))
     647        self.assertTrue(os.path.exists(bar_path))
    614648
    615649    def test_create_tmp(self, repetitions=10):
    … …  
    631665                             "File in wrong location: '%s'" % head)
    632666            match = pattern.match(tail)
    633             self.assert_(match is not None, "Invalid file name: '%s'" % tail)
     667            self.assertTrue(match is not None, "Invalid file name: '%s'" % tail)
    634668            groups = match.groups()
    635669            if previous_groups is not None:
    636                 self.assert_(int(groups[0] >= previous_groups[0]),
     670                self.assertGreaterEqual(int(groups[0]), int(previous_groups[0]),
    637671                             "Non-monotonic seconds: '%s' before '%s'" %
    638672                             (previous_groups[0], groups[0]))
    639                 self.assert_(int(groups[1] >= previous_groups[1]) or
    640                              groups[0] != groups[1],
    641                              "Non-monotonic milliseconds: '%s' before '%s'" %
    642                              (previous_groups[1], groups[1]))
    643                 self.assert_(int(groups[2]) == pid,
     673                if int(groups[0]) == int(previous_groups[0]):
     674                    self.assertGreaterEqual(int(groups[1]), int(previous_groups[1]),
     675                                "Non-monotonic milliseconds: '%s' before '%s'" %
     676                                (previous_groups[1], groups[1]))
     677                self.assertTrue(int(groups[2]) == pid,
    644678                             "Process ID mismatch: '%s' should be '%s'" %
    645679                             (groups[2], pid))
    646                 self.assert_(int(groups[3]) == int(previous_groups[3]) + 1,
     680                self.assertTrue(int(groups[3]) == int(previous_groups[3]) + 1,
    647681                             "Non-sequential counter: '%s' before '%s'" %
    648682                             (previous_groups[3], groups[3]))
    649                 self.assert_(groups[4] == hostname,
     683                self.assertTrue(groups[4] == hostname,
    650684                             "Host name mismatch: '%s' should be '%s'" %
    651685                             (groups[4], hostname))
    … …  
    653687            tmp_file.write(_sample_message)
    654688            tmp_file.seek(0)
    655             self.assert_(tmp_file.read() == _sample_message)
     689            self.assertTrue(tmp_file.read() == _sample_message)
    656690            tmp_file.close()
    657691        file_count = len(os.listdir(os.path.join(self._path, "tmp")))
    658         self.assert_(file_count == repetitions,
     692        self.assertTrue(file_count == repetitions,
    659693                     "Wrong file count: '%s' should be '%s'" %
    660694                     (file_count, repetitions))
    … …  
    662696    def test_refresh(self):
    663697        # Update the table of contents
    664         self.assert_(self._box._toc == {})
     698        self.assertEqual(self._box._toc, {})
    665699        key0 = self._box.add(self._template % 0)
    666700        key1 = self._box.add(self._template % 1)
    667         self.assert_(self._box._toc == {})
     701        self.assertEqual(self._box._toc, {})
    668702        self._box._refresh()
    669         self.assert_(self._box._toc == {key0: os.path.join('new', key0),
    670                                         key1: os.path.join('new', key1)})
     703        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
     704                                          key1: os.path.join('new', key1)})
    671705        key2 = self._box.add(self._template % 2)
    672         self.assert_(self._box._toc == {key0: os.path.join('new', key0),
    673                                         key1: os.path.join('new', key1)})
     706        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
     707                                          key1: os.path.join('new', key1)})
    674708        self._box._refresh()
    675         self.assert_(self._box._toc == {key0: os.path.join('new', key0),
    676                                         key1: os.path.join('new', key1),
    677                                         key2: os.path.join('new', key2)})
     709        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
     710                                          key1: os.path.join('new', key1),
     711                                          key2: os.path.join('new', key2)})
     712
     713    def test_refresh_after_safety_period(self):
     714        # Issue #13254: Call _refresh after the "file system safety
     715        # period" of 2 seconds has passed; _toc should still be
     716        # updated because this is the first call to _refresh.
     717        key0 = self._box.add(self._template % 0)
     718        key1 = self._box.add(self._template % 1)
     719
     720        self._box = self._factory(self._path)
     721        self.assertEqual(self._box._toc, {})
     722
     723        # Emulate sleeping. Instead of sleeping for 2 seconds, use the
     724        # skew factor to make _refresh think that the filesystem
     725        # safety period has passed and re-reading the _toc is only
     726        # required if mtimes differ.
     727        self._box._skewfactor = -3
     728
     729        self._box._refresh()
     730        self.assertEqual(sorted(self._box._toc.keys()), sorted([key0, key1]))
    678731
    679732    def test_lookup(self):
    … …  
    681734        self.assertRaises(KeyError, lambda: self._box._lookup('foo'))
    682735        key0 = self._box.add(self._template % 0)
    683         self.assert_(self._box._lookup(key0) == os.path.join('new', key0))
     736        self.assertEqual(self._box._lookup(key0), os.path.join('new', key0))
    684737        os.remove(os.path.join(self._path, 'new', key0))
    685         self.assert_(self._box._toc == {key0: os.path.join('new', key0)})
     738        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0)})
     739        # Be sure that the TOC is read back from disk (see issue #6896
     740        # about bad mtime behaviour on some systems).
     741        self._box.flush()
    686742        self.assertRaises(KeyError, lambda: self._box._lookup(key0))
    687         self.assert_(self._box._toc == {})
     743        self.assertEqual(self._box._toc, {})
    688744
    689745    def test_lock_unlock(self):
    … …  
    699755        box = self._factory(self._path, factory=dummy_factory)
    700756        folder = box.add_folder('folder1')
    701         self.assert_(folder._factory is dummy_factory)
     757        self.assertIs(folder._factory, dummy_factory)
    702758
    703759        folder1_alias = box.get_folder('folder1')
    704         self.assert_(folder1_alias._factory is dummy_factory)
     760        self.assertIs(folder1_alias._factory, dummy_factory)
    705761
    706762    def test_directory_in_folder (self):
    … …  
    729785        path = os.path.join(self._path, self._box._lookup(key))
    730786        mode = os.stat(path).st_mode
    731         self.assert_(mode & 0111 == 0)
     787        self.assertEqual(mode & 0111, 0)
    732788
    733789    def test_folder_file_perms(self):
    … …  
    748804        self.assertFalse((perms & 0111)) # Execute bits should all be off.
    749805
    750 
    751 class _TestMboxMMDF(TestMailbox):
     806    def test_reread(self):
     807        # Do an initial unconditional refresh
     808        self._box._refresh()
     809
     810        # Put the last modified times more than two seconds into the past
     811        # (because mtime may have only a two second granularity).
     812        for subdir in ('cur', 'new'):
     813            os.utime(os.path.join(self._box._path, subdir),
     814                     (time.time()-5,)*2)
     815
     816        # Because mtime has a two second granularity in worst case (FAT), a
     817        # refresh is done unconditionally if called for within
     818        # two-second-plus-a-bit of the last one, just in case the mbox has
     819        # changed; so now we have to wait for that interval to expire.
     820        #
     821        # Because this is a test, emulate sleeping. Instead of
     822        # sleeping for 2 seconds, use the skew factor to make _refresh
     823        # think that 2 seconds have passed and re-reading the _toc is
     824        # only required if mtimes differ.
     825        self._box._skewfactor = -3
     826
     827        # Re-reading causes the ._toc attribute to be assigned a new dictionary
     828        # object, so we'll check that the ._toc attribute isn't a different
     829        # object.
     830        orig_toc = self._box._toc
     831        def refreshed():
     832            return self._box._toc is not orig_toc
     833
     834        self._box._refresh()
     835        self.assertFalse(refreshed())
     836
     837        # Now, write something into cur and remove it.  This changes
     838        # the mtime and should cause a re-read. Note that "sleep
     839        # emulation" is still in effect, as skewfactor is -3.
     840        filename = os.path.join(self._path, 'cur', 'stray-file')
     841        f = open(filename, 'w')
     842        f.close()
     843        os.unlink(filename)
     844        self._box._refresh()
     845        self.assertTrue(refreshed())
     846
     847
     848class _TestSingleFile(TestMailbox):
     849    '''Common tests for single-file mailboxes'''
     850
     851    def test_add_doesnt_rewrite(self):
     852        # When only adding messages, flush() should not rewrite the
     853        # mailbox file. See issue #9559.
     854
     855        # Inode number changes if the contents are written to another
     856        # file which is then renamed over the original file. So we
     857        # must check that the inode number doesn't change.
     858        inode_before = os.stat(self._path).st_ino
     859
     860        self._box.add(self._template % 0)
     861        self._box.flush()
     862
     863        inode_after = os.stat(self._path).st_ino
     864        self.assertEqual(inode_before, inode_after)
     865
     866        # Make sure the message was really added
     867        self._box.close()
     868        self._box = self._factory(self._path)
     869        self.assertEqual(len(self._box), 1)
     870
     871    def test_permissions_after_flush(self):
     872        # See issue #5346
     873
     874        # Make the mailbox world writable. It's unlikely that the new
     875        # mailbox file would have these permissions after flush(),
     876        # because umask usually prevents it.
     877        mode = os.stat(self._path).st_mode | 0o666
     878        os.chmod(self._path, mode)
     879
     880        self._box.add(self._template % 0)
     881        i = self._box.add(self._template % 1)
     882        # Need to remove one message to make flush() create a new file
     883        self._box.remove(i)
     884        self._box.flush()
     885
     886        self.assertEqual(os.stat(self._path).st_mode, mode)
     887
     888
     889class _TestMboxMMDF(_TestSingleFile):
    752890
    753891    def tearDown(self):
    … …  
    759897    def test_add_from_string(self):
    760898        # Add a string starting with 'From ' to the mailbox
    761         key = self._box.add('From foo@bar blah\nFrom: foo\n\n0')
    762         self.assert_(self._box[key].get_from() == 'foo@bar blah')
    763         self.assert_(self._box[key].get_payload() == '0')
     899        key = self._box.add('From foo@bar blah\nFrom: foo\n\n0\n')
     900        self.assertEqual(self._box[key].get_from(), 'foo@bar blah')
     901        self.assertEqual(self._box[key].get_payload(), '0\n')
    764902
    765903    def test_add_mbox_or_mmdf_message(self):
    766904        # Add an mboxMessage or MMDFMessage
    767905        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
    768             msg = class_('From foo@bar blah\nFrom: foo\n\n0')
     906            msg = class_('From foo@bar blah\nFrom: foo\n\n0\n')
    769907            key = self._box.add(msg)
    770908
    … …  
    777915        mtime = os.path.getmtime(self._path)
    778916        self._box = self._factory(self._path)
    779         self.assert_(len(self._box) == 3)
     917        self.assertEqual(len(self._box), 3)
    780918        for key in self._box.iterkeys():
    781             self.assert_(self._box.get_string(key) in values)
     919            self.assertIn(self._box.get_string(key), values)
    782920        self._box.close()
    783         self.assert_(mtime == os.path.getmtime(self._path))
     921        self.assertEqual(mtime, os.path.getmtime(self._path))
    784922
    785923    def test_add_and_close(self):
    … …  
    793931        contents = self._box._file.read()
    794932        self._box.close()
    795         self.assert_(contents == open(self._path, 'rb').read())
     933        with open(self._path, 'rb') as f:
     934            self.assertEqual(contents, f.read())
    796935        self._box = self._factory(self._path)
    797936
     937    @unittest.skipUnless(hasattr(os, 'fork'), "Test needs fork().")
     938    @unittest.skipUnless(hasattr(socket, 'socketpair'), "Test needs socketpair().")
    798939    def test_lock_conflict(self):
    799         # Fork off a subprocess that will lock the file for 2 seconds,
    800         # unlock it, and then exit.
    801         if not hasattr(os, 'fork'):
    802             return
     940        # Fork off a child process that will lock the mailbox temporarily,
     941        # unlock it and exit.
     942        c, p = socket.socketpair()
     943        self.addCleanup(c.close)
     944        self.addCleanup(p.close)
     945
    803946        pid = os.fork()
    804947        if pid == 0:
    805             # In the child, lock the mailbox.
    806             self._box.lock()
    807             time.sleep(2)
    808             self._box.unlock()
    809             os._exit(0)
    810 
    811         # In the parent, sleep a bit to give the child time to acquire
    812         # the lock.
    813         time.sleep(0.5)
     948            # child
     949            try:
     950                # lock the mailbox, and signal the parent it can proceed
     951                self._box.lock()
     952                c.send(b'c')
     953
     954                # wait until the parent is done, and unlock the mailbox
     955                c.recv(1)
     956                self._box.unlock()
     957            finally:
     958                os._exit(0)
     959
     960        # In the parent, wait until the child signals it locked the mailbox.
     961        p.recv(1)
    814962        try:
    815963            self.assertRaises(mailbox.ExternalClashError,
    816964                              self._box.lock)
    817965        finally:
     966            # Signal the child it can now release the lock and exit.
     967            p.send(b'p')
    818968            # Wait for child to exit.  Locking should now succeed.
    819969            exited_pid, status = os.waitpid(pid, 0)
    … …  
    834984        key2 = self._box.add(msg)
    835985        self._box.flush()
    836         self.assert_(self._box._locked)
     986        self.assertTrue(self._box._locked)
    837987        self._box.close()
    838988
    839989
    840 class TestMbox(_TestMboxMMDF):
     990class TestMbox(_TestMboxMMDF, unittest.TestCase):
    841991
    842992    _factory = lambda self, path, factory=None: mailbox.mbox(path, factory)
    … …  
    8611011            self.assertFalse((perms & 0111)) # Execute bits should all be off.
    8621012
    863 class TestMMDF(_TestMboxMMDF):
     1013    def test_terminating_newline(self):
     1014        message = email.message.Message()
     1015        message['From'] = 'john@example.com'
     1016        message.set_payload('No newline at the end')
     1017        i = self._box.add(message)
     1018
     1019        # A newline should have been appended to the payload
     1020        message = self._box.get(i)
     1021        self.assertEqual(message.get_payload(), 'No newline at the end\n')
     1022
     1023    def test_message_separator(self):
     1024        # Check there's always a single blank line after each message
     1025        self._box.add('From: foo\n\n0')  # No newline at the end
     1026        with open(self._path) as f:
     1027            data = f.read()
     1028            self.assertEqual(data[-3:], '0\n\n')
     1029
     1030        self._box.add('From: foo\n\n0\n')  # Newline at the end
     1031        with open(self._path) as f:
     1032            data = f.read()
     1033            self.assertEqual(data[-3:], '0\n\n')
     1034
     1035
     1036class TestMMDF(_TestMboxMMDF, unittest.TestCase):
    8641037
    8651038    _factory = lambda self, path, factory=None: mailbox.MMDF(path, factory)
    8661039
    8671040
    868 class TestMH(TestMailbox):
     1041class TestMH(TestMailbox, unittest.TestCase):
    8691042
    8701043    _factory = lambda self, path, factory=None: mailbox.MH(path, factory)
    … …  
    8751048        self._box.add_folder('two')
    8761049        self._box.add_folder('three')
    877         self.assert_(len(self._box.list_folders()) == 3)
    878         self.assert_(set(self._box.list_folders()) ==
    879                      set(('one', 'two', 'three')))
     1050        self.assertEqual(len(self._box.list_folders()), 3)
     1051        self.assertEqual(set(self._box.list_folders()),
     1052                         set(('one', 'two', 'three')))
    8801053
    8811054    def test_get_folder(self):
    … …  
    8881061        folder0 = self._box.get_folder('foo.bar')
    8891062        folder0.add(self._template % 'bar')
    890         self.assert_(os.path.isdir(os.path.join(self._path, 'foo.bar')))
     1063        self.assertTrue(os.path.isdir(os.path.join(self._path, 'foo.bar')))
    8911064        folder1 = self._box.get_folder('foo.bar')
    892         self.assert_(folder1.get_string(folder1.keys()[0]) == \
    893                      self._template % 'bar')
     1065        self.assertEqual(folder1.get_string(folder1.keys()[0]),
     1066                         self._template % 'bar')
    8941067
    8951068        # Test for bug #1569790: verify that folders returned by .get_folder()
    8961069        # use the same factory function.
    897         self.assert_(new_folder._factory is self._box._factory)
    898         self.assert_(folder0._factory is self._box._factory)
     1070        self.assertIs(new_folder._factory, self._box._factory)
     1071        self.assertIs(folder0._factory, self._box._factory)
    8991072
    9001073    def test_add_and_remove_folders(self):
    … …  
    9021075        self._box.add_folder('one')
    9031076        self._box.add_folder('two')
    904         self.assert_(len(self._box.list_folders()) == 2)
    905         self.assert_(set(self._box.list_folders()) == set(('one', 'two')))
     1077        self.assertEqual(len(self._box.list_folders()), 2)
     1078        self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
    9061079        self._box.remove_folder('one')
    907         self.assert_(len(self._box.list_folders()) == 1)
    908         self.assert_(set(self._box.list_folders()) == set(('two',)))
     1080        self.assertEqual(len(self._box.list_folders()), 1)
     1081        self.assertEqual(set(self._box.list_folders()), set(('two', )))
    9091082        self._box.add_folder('three')
    910         self.assert_(len(self._box.list_folders()) == 2)
    911         self.assert_(set(self._box.list_folders()) == set(('two', 'three')))
     1083        self.assertEqual(len(self._box.list_folders()), 2)
     1084        self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
    9121085        self._box.remove_folder('three')
    913         self.assert_(len(self._box.list_folders()) == 1)
    914         self.assert_(set(self._box.list_folders()) == set(('two',)))
     1086        self.assertEqual(len(self._box.list_folders()), 1)
     1087        self.assertEqual(set(self._box.list_folders()), set(('two', )))
    9151088        self._box.remove_folder('two')
    916         self.assert_(len(self._box.list_folders()) == 0)
    917         self.assert_(self._box.list_folders() == [])
     1089        self.assertEqual(len(self._box.list_folders()), 0)
     1090        self.assertEqual(self._box.list_folders(), [])
    9181091
    9191092    def test_sequences(self):
    9201093        # Get and set sequences
    921         self.assert_(self._box.get_sequences() == {})
     1094        self.assertEqual(self._box.get_sequences(), {})
    9221095        msg0 = mailbox.MHMessage(self._template % 0)
    9231096        msg0.add_sequence('foo')
    9241097        key0 = self._box.add(msg0)
    925         self.assert_(self._box.get_sequences() == {'foo':[key0]})
     1098        self.assertEqual(self._box.get_sequences(), {'foo':[key0]})
    9261099        msg1 = mailbox.MHMessage(self._template % 1)
    9271100        msg1.set_sequences(['bar', 'replied', 'foo'])
    9281101        key1 = self._box.add(msg1)
    929         self.assert_(self._box.get_sequences() ==
    930                      {'foo':[key0, key1], 'bar':[key1], 'replied':[key1]})
     1102        self.assertEqual(self._box.get_sequences(),
     1103                         {'foo':[key0, key1], 'bar':[key1], 'replied':[key1]})
    9311104        msg0.set_sequences(['flagged'])
    9321105        self._box[key0] = msg0
    933         self.assert_(self._box.get_sequences() ==
    934                      {'foo':[key1], 'bar':[key1], 'replied':[key1],
    935                       'flagged':[key0]})
     1106        self.assertEqual(self._box.get_sequences(),
     1107                         {'foo':[key1], 'bar':[key1], 'replied':[key1],
     1108                          'flagged':[key0]})
    9361109        self._box.remove(key1)
    937         self.assert_(self._box.get_sequences() == {'flagged':[key0]})
     1110        self.assertEqual(self._box.get_sequences(), {'flagged':[key0]})
    9381111
    9391112    def test_issue2625(self):
    … …  
    9421115        key0 = self._box.add(msg0)
    9431116        refmsg0 = self._box.get_message(key0)
     1117
     1118    def test_issue7627(self):
     1119        msg0 = mailbox.MHMessage(self._template % 0)
     1120        key0 = self._box.add(msg0)
     1121        self._box.lock()
     1122        self._box.remove(key0)
     1123        self._box.unlock()
    9441124
    9451125    def test_pack(self):
    … …  
    9571137        key2 = self._box.add(msg2)
    9581138        key3 = self._box.add(msg3)
    959         self.assert_(self._box.get_sequences() ==
    960                      {'foo':[key0,key1,key2,key3], 'unseen':[key0],
    961                       'flagged':[key2], 'bar':[key3], 'replied':[key3]})
     1139        self.assertEqual(self._box.get_sequences(),
     1140                         {'foo':[key0,key1,key2,key3], 'unseen':[key0],
     1141                          'flagged':[key2], 'bar':[key3], 'replied':[key3]})
    9621142        self._box.remove(key2)
    963         self.assert_(self._box.get_sequences() ==
    964                      {'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3],
    965                       'replied':[key3]})
     1143        self.assertEqual(self._box.get_sequences(),
     1144                         {'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3],
     1145                          'replied':[key3]})
    9661146        self._box.pack()
    967         self.assert_(self._box.keys() == [1, 2, 3])
     1147        self.assertEqual(self._box.keys(), [1, 2, 3])
    9681148        key0 = key0
    9691149        key1 = key0 + 1
    9701150        key2 = key1 + 1
    971         self.assert_(self._box.get_sequences() ==
     1151        self.assertEqual(self._box.get_sequences(),
    9721152                     {'foo':[1, 2, 3], 'unseen':[1], 'bar':[3], 'replied':[3]})
    9731153
    … …  
    9831163        self._box.pack()
    9841164        self._box.unlock()
    985         self.assert_(self._box.get_sequences() ==
    986                      {'foo':[1, 2, 3, 4, 5],
    987                       'unseen':[1], 'bar':[3], 'replied':[3]})
     1165        self.assertEqual(self._box.get_sequences(),
     1166                         {'foo':[1, 2, 3, 4, 5],
     1167                          'unseen':[1], 'bar':[3], 'replied':[3]})
    9881168
    9891169    def _get_lock_path(self):
    … …  
    9911171
    9921172
    993 class TestBabyl(TestMailbox):
     1173class TestBabyl(_TestSingleFile, unittest.TestCase):
    9941174
    9951175    _factory = lambda self, path, factory=None: mailbox.Babyl(path, factory)
    … …  
    10031183    def test_labels(self):
    10041184        # Get labels from the mailbox
    1005         self.assert_(self._box.get_labels() == [])
     1185        self.assertEqual(self._box.get_labels(), [])
    10061186        msg0 = mailbox.BabylMessage(self._template % 0)
    10071187        msg0.add_label('foo')
    10081188        key0 = self._box.add(msg0)
    1009         self.assert_(self._box.get_labels() == ['foo'])
     1189        self.assertEqual(self._box.get_labels(), ['foo'])
    10101190        msg1 = mailbox.BabylMessage(self._template % 1)
    10111191        msg1.set_labels(['bar', 'answered', 'foo'])
    10121192        key1 = self._box.add(msg1)
    1013         self.assert_(set(self._box.get_labels()) == set(['foo', 'bar']))
     1193        self.assertEqual(set(self._box.get_labels()), set(['foo', 'bar']))
    10141194        msg0.set_labels(['blah', 'filed'])
    10151195        self._box[key0] = msg0
    1016         self.assert_(set(self._box.get_labels()) ==
    1017                      set(['foo', 'bar', 'blah']))
     1196        self.assertEqual(set(self._box.get_labels()),
     1197                         set(['foo', 'bar', 'blah']))
    10181198        self._box.remove(key1)
    1019         self.assert_(set(self._box.get_labels()) == set(['blah']))
    1020 
    1021 
    1022 class TestMessage(TestBase):
     1199        self.assertEqual(set(self._box.get_labels()), set(['blah']))
     1200
     1201
     1202class TestMessage(TestBase, unittest.TestCase):
    10231203
    10241204    _factory = mailbox.Message      # Overridden by subclasses to reuse tests
    … …  
    10451225    def test_initialize_with_file(self):
    10461226        # Initialize based on contents of file
    1047         f = open(self._path, 'w+')
    1048         f.write(_sample_message)
    1049         f.seek(0)
    1050         msg = self._factory(f)
    1051         self._post_initialize_hook(msg)
    1052         self._check_sample(msg)
    1053         f.close()
     1227        with open(self._path, 'w+') as f:
     1228            f.write(_sample_message)
     1229            f.seek(0)
     1230            msg = self._factory(f)
     1231            self._post_initialize_hook(msg)
     1232            self._check_sample(msg)
    10541233
    10551234    def test_initialize_with_nothing(self):
    … …  
    10571236        msg = self._factory()
    10581237        self._post_initialize_hook(msg)
    1059         self.assert_(isinstance(msg, email.message.Message))
    1060         self.assert_(isinstance(msg, mailbox.Message))
    1061         self.assert_(isinstance(msg, self._factory))
    1062         self.assert_(msg.keys() == [])
    1063         self.assert_(not msg.is_multipart())
    1064         self.assert_(msg.get_payload() == None)
     1238        self.assertIsInstance(msg, email.message.Message)
     1239        self.assertIsInstance(msg, mailbox.Message)
     1240        self.assertIsInstance(msg, self._factory)
     1241        self.assertEqual(msg.keys(), [])
     1242        self.assertFalse(msg.is_multipart())
     1243        self.assertEqual(msg.get_payload(), None)
    10651244
    10661245    def test_initialize_incorrectly(self):
    … …  
    10921271
    10931272
    1094 class TestMaildirMessage(TestMessage):
     1273class TestMaildirMessage(TestMessage, unittest.TestCase):
    10951274
    10961275    _factory = mailbox.MaildirMessage
    10971276
    10981277    def _post_initialize_hook(self, msg):
    1099         self.assert_(msg._subdir == 'new')
    1100         self.assert_(msg._info == '')
     1278        self.assertEqual(msg._subdir, 'new')
     1279        self.assertEqual(msg._info,'')
    11011280
    11021281    def test_subdir(self):
    11031282        # Use get_subdir() and set_subdir()
    11041283        msg = mailbox.MaildirMessage(_sample_message)
    1105         self.assert_(msg.get_subdir() == 'new')
     1284        self.assertEqual(msg.get_subdir(), 'new')
    11061285        msg.set_subdir('cur')
    1107         self.assert_(msg.get_subdir() == 'cur')
     1286        self.assertEqual(msg.get_subdir(), 'cur')
    11081287        msg.set_subdir('new')
    1109         self.assert_(msg.get_subdir() == 'new')
     1288        self.assertEqual(msg.get_subdir(), 'new')
    11101289        self.assertRaises(ValueError, lambda: msg.set_subdir('tmp'))
    1111         self.assert_(msg.get_subdir() == 'new')
     1290        self.assertEqual(msg.get_subdir(), 'new')
    11121291        msg.set_subdir('new')
    1113         self.assert_(msg.get_subdir() == 'new')
     1292        self.assertEqual(msg.get_subdir(), 'new')
    11141293        self._check_sample(msg)
    11151294
    … …  
    11171296        # Use get_flags(), set_flags(), add_flag(), remove_flag()
    11181297        msg = mailbox.MaildirMessage(_sample_message)
    1119         self.assert_(msg.get_flags() == '')
    1120         self.assert_(msg.get_subdir() == 'new')
     1298        self.assertEqual(msg.get_flags(), '')
     1299        self.assertEqual(msg.get_subdir(), 'new')
    11211300        msg.set_flags('F')
    1122         self.assert_(msg.get_subdir() == 'new')
    1123         self.assert_(msg.get_flags() == 'F')
     1301        self.assertEqual(msg.get_subdir(), 'new')
     1302        self.assertEqual(msg.get_flags(), 'F')
    11241303        msg.set_flags('SDTP')
    1125         self.assert_(msg.get_flags() == 'DPST')
     1304        self.assertEqual(msg.get_flags(), 'DPST')
    11261305        msg.add_flag('FT')
    1127         self.assert_(msg.get_flags() == 'DFPST')
     1306        self.assertEqual(msg.get_flags(), 'DFPST')
    11281307        msg.remove_flag('TDRP')
    1129         self.assert_(msg.get_flags() == 'FS')
    1130         self.assert_(msg.get_subdir() == 'new')
     1308        self.assertEqual(msg.get_flags(), 'FS')
     1309        self.assertEqual(msg.get_subdir(), 'new')
    11311310        self._check_sample(msg)
    11321311
    … …  
    11341313        # Use get_date() and set_date()
    11351314        msg = mailbox.MaildirMessage(_sample_message)
    1136         self.assert_(abs(msg.get_date() - time.time()) < 60)
     1315        diff = msg.get_date() - time.time()
     1316        self.assertTrue(abs(diff) < 60, diff)
    11371317        msg.set_date(0.0)
    1138         self.assert_(msg.get_date() == 0.0)
     1318        self.assertEqual(msg.get_date(), 0.0)
    11391319
    11401320    def test_info(self):
    11411321        # Use get_info() and set_info()
    11421322        msg = mailbox.MaildirMessage(_sample_message)
    1143         self.assert_(msg.get_info() == '')
     1323        self.assertEqual(msg.get_info(), '')
    11441324        msg.set_info('1,foo=bar')
    1145         self.assert_(msg.get_info() == '1,foo=bar')
     1325        self.assertEqual(msg.get_info(), '1,foo=bar')
    11461326        self.assertRaises(TypeError, lambda: msg.set_info(None))
    11471327        self._check_sample(msg)
    … …  
    11501330        # Test interaction of info and flag methods
    11511331        msg = mailbox.MaildirMessage(_sample_message)
    1152         self.assert_(msg.get_info() == '')
     1332        self.assertEqual(msg.get_info(), '')
    11531333        msg.set_flags('SF')
    1154         self.assert_(msg.get_flags() == 'FS')
    1155         self.assert_(msg.get_info() == '2,FS')
     1334        self.assertEqual(msg.get_flags(), 'FS')
     1335        self.assertEqual(msg.get_info(), '2,FS')
    11561336        msg.set_info('1,')
    1157         self.assert_(msg.get_flags() == '')
    1158         self.assert_(msg.get_info() == '1,')
     1337        self.assertEqual(msg.get_flags(), '')
     1338        self.assertEqual(msg.get_info(), '1,')
    11591339        msg.remove_flag('RPT')
    1160         self.assert_(msg.get_flags() == '')
    1161         self.assert_(msg.get_info() == '1,')
     1340        self.assertEqual(msg.get_flags(), '')
     1341        self.assertEqual(msg.get_info(), '1,')
    11621342        msg.add_flag('D')
    1163         self.assert_(msg.get_flags() == 'D')
    1164         self.assert_(msg.get_info() == '2,D')
     1343        self.assertEqual(msg.get_flags(), 'D')
     1344        self.assertEqual(msg.get_info(), '2,D')
    11651345        self._check_sample(msg)
    11661346
    11671347
    1168 class _TestMboxMMDFMessage(TestMessage):
     1348class _TestMboxMMDFMessage:
    11691349
    11701350    _factory = mailbox._mboxMMDFMessage
    … …  
    11781358        msg.set_unixfrom('From foo@bar blah')
    11791359        msg = mailbox.mboxMessage(msg)
    1180         self.assert_(msg.get_from() == 'foo@bar blah', msg.get_from())
     1360        self.assertEqual(msg.get_from(), 'foo@bar blah')
    11811361
    11821362    def test_from(self):
    … …  
    11851365        self._check_from(msg)
    11861366        msg.set_from('foo bar')
    1187         self.assert_(msg.get_from() == 'foo bar')
     1367        self.assertEqual(msg.get_from(), 'foo bar')
    11881368        msg.set_from('foo@bar', True)
    11891369        self._check_from(msg, 'foo@bar')
    … …  
    11941374        # Use get_flags(), set_flags(), add_flag(), remove_flag()
    11951375        msg = mailbox.mboxMessage(_sample_message)
    1196         self.assert_(msg.get_flags() == '')
     1376        self.assertEqual(msg.get_flags(), '')
    11971377        msg.set_flags('F')
    1198         self.assert_(msg.get_flags() == 'F')
     1378        self.assertEqual(msg.get_flags(), 'F')
    11991379        msg.set_flags('XODR')
    1200         self.assert_(msg.get_flags() == 'RODX')
     1380        self.assertEqual(msg.get_flags(), 'RODX')
    12011381        msg.add_flag('FA')
    1202         self.assert_(msg.get_flags() == 'RODFAX')
     1382        self.assertEqual(msg.get_flags(), 'RODFAX')
    12031383        msg.remove_flag('FDXA')
    1204         self.assert_(msg.get_flags() == 'RO')
     1384        self.assertEqual(msg.get_flags(), 'RO')
    12051385        self._check_sample(msg)
    12061386
    … …  
    12091389        if sender is None:
    12101390            sender = "MAILER-DAEMON"
    1211         self.assert_(re.match(sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:"
    1212                               r"\d{2} \d{4}", msg.get_from()) is not None)
    1213 
    1214 
    1215 class TestMboxMessage(_TestMboxMMDFMessage):
     1391        self.assertTrue(re.match(sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:"
     1392                                 r"\d{2} \d{4}", msg.get_from()))
     1393
     1394
     1395class TestMboxMessage(_TestMboxMMDFMessage, TestMessage):
    12161396
    12171397    _factory = mailbox.mboxMessage
    12181398
    12191399
    1220 class TestMHMessage(TestMessage):
     1400class TestMHMessage(TestMessage, unittest.TestCase):
    12211401
    12221402    _factory = mailbox.MHMessage
    12231403
    12241404    def _post_initialize_hook(self, msg):
    1225         self.assert_(msg._sequences == [])
     1405        self.assertEqual(msg._sequences, [])
    12261406
    12271407    def test_sequences(self):
    12281408        # Get, set, join, and leave sequences
    12291409        msg = mailbox.MHMessage(_sample_message)
    1230         self.assert_(msg.get_sequences() == [])
     1410        self.assertEqual(msg.get_sequences(), [])
    12311411        msg.set_sequences(['foobar'])
    1232         self.assert_(msg.get_sequences() == ['foobar'])
     1412        self.assertEqual(msg.get_sequences(), ['foobar'])
    12331413        msg.set_sequences([])
    1234         self.assert_(msg.get_sequences() == [])
     1414        self.assertEqual(msg.get_sequences(), [])
    12351415        msg.add_sequence('unseen')
    1236         self.assert_(msg.get_sequences() == ['unseen'])
     1416        self.assertEqual(msg.get_sequences(), ['unseen'])
    12371417        msg.add_sequence('flagged')
    1238         self.assert_(msg.get_sequences() == ['unseen', 'flagged'])
     1418        self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
    12391419        msg.add_sequence('flagged')
    1240         self.assert_(msg.get_sequences() == ['unseen', 'flagged'])
     1420        self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
    12411421        msg.remove_sequence('unseen')
    1242         self.assert_(msg.get_sequences() == ['flagged'])
     1422        self.assertEqual(msg.get_sequences(), ['flagged'])
    12431423        msg.add_sequence('foobar')
    1244         self.assert_(msg.get_sequences() == ['flagged', 'foobar'])
     1424        self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
    12451425        msg.remove_sequence('replied')
    1246         self.assert_(msg.get_sequences() == ['flagged', 'foobar'])
     1426        self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
    12471427        msg.set_sequences(['foobar', 'replied'])
    1248         self.assert_(msg.get_sequences() == ['foobar', 'replied'])
    1249 
    1250 
    1251 class TestBabylMessage(TestMessage):
     1428        self.assertEqual(msg.get_sequences(), ['foobar', 'replied'])
     1429
     1430
     1431class TestBabylMessage(TestMessage, unittest.TestCase):
    12521432
    12531433    _factory = mailbox.BabylMessage
    12541434
    12551435    def _post_initialize_hook(self, msg):
    1256         self.assert_(msg._labels == [])
     1436        self.assertEqual(msg._labels, [])
    12571437
    12581438    def test_labels(self):
    12591439        # Get, set, join, and leave labels
    12601440        msg = mailbox.BabylMessage(_sample_message)
    1261         self.assert_(msg.get_labels() == [])
     1441        self.assertEqual(msg.get_labels(), [])
    12621442        msg.set_labels(['foobar'])
    1263         self.assert_(msg.get_labels() == ['foobar'])
     1443        self.assertEqual(msg.get_labels(), ['foobar'])
    12641444        msg.set_labels([])
    1265         self.assert_(msg.get_labels() == [])
     1445        self.assertEqual(msg.get_labels(), [])
    12661446        msg.add_label('filed')
    1267         self.assert_(msg.get_labels() == ['filed'])
     1447        self.assertEqual(msg.get_labels(), ['filed'])
    12681448        msg.add_label('resent')
    1269         self.assert_(msg.get_labels() == ['filed', 'resent'])
     1449        self.assertEqual(msg.get_labels(), ['filed', 'resent'])
    12701450        msg.add_label('resent')
    1271         self.assert_(msg.get_labels() == ['filed', 'resent'])
     1451        self.assertEqual(msg.get_labels(), ['filed', 'resent'])
    12721452        msg.remove_label('filed')
    1273         self.assert_(msg.get_labels() == ['resent'])
     1453        self.assertEqual(msg.get_labels(), ['resent'])
    12741454        msg.add_label('foobar')
    1275         self.assert_(msg.get_labels() == ['resent', 'foobar'])
     1455        self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
    12761456        msg.remove_label('unseen')
    1277         self.assert_(msg.get_labels() == ['resent', 'foobar'])
     1457        self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
    12781458        msg.set_labels(['foobar', 'answered'])
    1279         self.assert_(msg.get_labels() == ['foobar', 'answered'])
     1459        self.assertEqual(msg.get_labels(), ['foobar', 'answered'])
    12801460
    12811461    def test_visible(self):
    … …  
    12831463        msg = mailbox.BabylMessage(_sample_message)
    12841464        visible = msg.get_visible()
    1285         self.assert_(visible.keys() == [])
    1286         self.assert_(visible.get_payload() is None)
     1465        self.assertEqual(visible.keys(), [])
     1466        self.assertIs(visible.get_payload(), None)
    12871467        visible['User-Agent'] = 'FooBar 1.0'
    12881468        visible['X-Whatever'] = 'Blah'
    1289         self.assert_(msg.get_visible().keys() == [])
     1469        self.assertEqual(msg.get_visible().keys(), [])
    12901470        msg.set_visible(visible)
    12911471        visible = msg.get_visible()
    1292         self.assert_(visible.keys() == ['User-Agent', 'X-Whatever'])
    1293         self.assert_(visible['User-Agent'] == 'FooBar 1.0')
    1294         self.assert_(visible['X-Whatever'] == 'Blah')
    1295         self.assert_(visible.get_payload() is None)
     1472        self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
     1473        self.assertEqual(visible['User-Agent'], 'FooBar 1.0')
     1474        self.assertEqual(visible['X-Whatever'], 'Blah')
     1475        self.assertIs(visible.get_payload(), None)
    12961476        msg.update_visible()
    1297         self.assert_(visible.keys() == ['User-Agent', 'X-Whatever'])
    1298         self.assert_(visible.get_payload() is None)
     1477        self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
     1478        self.assertIs(visible.get_payload(), None)
    12991479        visible = msg.get_visible()
    1300         self.assert_(visible.keys() == ['User-Agent', 'Date', 'From', 'To',
    1301                                         'Subject'])
     1480        self.assertEqual(visible.keys(), ['User-Agent', 'Date', 'From', 'To',
     1481                                          'Subject'])
    13021482        for header in ('User-Agent', 'Date', 'From', 'To', 'Subject'):
    1303             self.assert_(visible[header] == msg[header])
    1304 
    1305 
    1306 class TestMMDFMessage(_TestMboxMMDFMessage):
     1483            self.assertEqual(visible[header], msg[header])
     1484
     1485
     1486class TestMMDFMessage(_TestMboxMMDFMessage, TestMessage):
    13071487
    13081488    _factory = mailbox.MMDFMessage
    13091489
    13101490
    1311 class TestMessageConversion(TestBase):
     1491class TestMessageConversion(TestBase, unittest.TestCase):
    13121492
    13131493    def test_plain_to_x(self):
    … …  
    13441524        msg = mailbox.MaildirMessage(msg_maildir)
    13451525        self._check_sample(msg)
    1346         self.assert_(msg.get_flags() == 'DFPRST')
    1347         self.assert_(msg.get_subdir() == 'cur')
    1348         self.assert_(msg.get_date() == date)
     1526        self.assertEqual(msg.get_flags(), 'DFPRST')
     1527        self.assertEqual(msg.get_subdir(), 'cur')
     1528        self.assertEqual(msg.get_date(), date)
    13491529
    13501530    def test_maildir_to_mboxmmdf(self):
    … …  
    13581538                msg_maildir.set_flags(setting)
    13591539                msg = class_(msg_maildir)
    1360                 self.assert_(msg.get_flags() == result)
    1361                 self.assert_(msg.get_from() == 'MAILER-DAEMON %s' %
    1362                              time.asctime(time.gmtime(0.0)))
     1540                self.assertEqual(msg.get_flags(), result)
     1541                self.assertEqual(msg.get_from(), 'MAILER-DAEMON %s' %
     1542                                 time.asctime(time.gmtime(0.0)))
    13631543            msg_maildir.set_subdir('cur')
    1364             self.assert_(class_(msg_maildir).get_flags() == 'RODFA')
     1544            self.assertEqual(class_(msg_maildir).get_flags(), 'RODFA')
    13651545
    13661546    def test_maildir_to_mh(self):
    … …  
    13721552        for setting, result in pairs:
    13731553            msg_maildir.set_flags(setting)
    1374             self.assert_(mailbox.MHMessage(msg_maildir).get_sequences() == \
    1375                          result)
     1554            self.assertEqual(mailbox.MHMessage(msg_maildir).get_sequences(),
     1555                             result)
    13761556
    13771557    def test_maildir_to_babyl(self):
    … …  
    13841564        for setting, result in pairs:
    13851565            msg_maildir.set_flags(setting)
    1386             self.assert_(mailbox.BabylMessage(msg_maildir).get_labels() == \
    1387                          result)
     1566            self.assertEqual(mailbox.BabylMessage(msg_maildir).get_labels(),
     1567                             result)
    13881568
    13891569    def test_mboxmmdf_to_maildir(self):
    … …  
    13971577                msg_mboxMMDF.set_flags(setting)
    13981578                msg = mailbox.MaildirMessage(msg_mboxMMDF)
    1399                 self.assert_(msg.get_flags() == result)
    1400                 self.assert_(msg.get_date() == 0.0, msg.get_date())
     1579                self.assertEqual(msg.get_flags(), result)
     1580                self.assertEqual(msg.get_date(), 0.0)
    14011581            msg_mboxMMDF.set_flags('O')
    1402             self.assert_(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir() == \
    1403                          'cur')
     1582            self.assertEqual(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir(),
     1583                             'cur')
    14041584
    14051585    def test_mboxmmdf_to_mboxmmdf(self):
    … …  
    14111591            for class2_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
    14121592                msg2 = class2_(msg_mboxMMDF)
    1413                 self.assert_(msg2.get_flags() == 'RODFA')
    1414                 self.assert_(msg2.get_from() == 'foo@bar')
     1593                self.assertEqual(msg2.get_flags(), 'RODFA')
     1594                self.assertEqual(msg2.get_from(), 'foo@bar')
    14151595
    14161596    def test_mboxmmdf_to_mh(self):
    … …  
    14241604            for setting, result in pairs:
    14251605                msg_mboxMMDF.set_flags(setting)
    1426                 self.assert_(mailbox.MHMessage(msg_mboxMMDF).get_sequences() \
    1427                              == result)
     1606                self.assertEqual(mailbox.MHMessage(msg_mboxMMDF).get_sequences(),
     1607                                 result)
    14281608
    14291609    def test_mboxmmdf_to_babyl(self):
    … …  
    14371617            for setting, result in pairs:
    14381618                msg.set_flags(setting)
    1439                 self.assert_(mailbox.BabylMessage(msg).get_labels() == result)
     1619                self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
    14401620
    14411621    def test_mh_to_maildir(self):
    … …  
    14451625            msg = mailbox.MHMessage(_sample_message)
    14461626            msg.add_sequence(setting)
    1447             self.assert_(mailbox.MaildirMessage(msg).get_flags() == result)
    1448             self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur')
     1627            self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
     1628            self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
    14491629        msg = mailbox.MHMessage(_sample_message)
    14501630        msg.add_sequence('unseen')
    14511631        msg.add_sequence('replied')
    14521632        msg.add_sequence('flagged')
    1453         self.assert_(mailbox.MaildirMessage(msg).get_flags() == 'FR')
    1454         self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur')
     1633        self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'FR')
     1634        self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
    14551635
    14561636    def test_mh_to_mboxmmdf(self):
    … …  
    14611641            msg.add_sequence(setting)
    14621642            for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
    1463                 self.assert_(class_(msg).get_flags() == result)
     1643                self.assertEqual(class_(msg).get_flags(), result)
    14641644        msg = mailbox.MHMessage(_sample_message)
    14651645        msg.add_sequence('unseen')
    … …  
    14671647        msg.add_sequence('flagged')
    14681648        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
    1469             self.assert_(class_(msg).get_flags() == 'OFA')
     1649            self.assertEqual(class_(msg).get_flags(), 'OFA')
    14701650
    14711651    def test_mh_to_mh(self):
    … …  
    14751655        msg.add_sequence('replied')
    14761656        msg.add_sequence('flagged')
    1477         self.assert_(mailbox.MHMessage(msg).get_sequences() == \
    1478                      ['unseen', 'replied', 'flagged'])
     1657        self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
     1658                         ['unseen', 'replied', 'flagged'])
    14791659
    14801660    def test_mh_to_babyl(self):
    … …  
    14851665            msg = mailbox.MHMessage(_sample_message)
    14861666            msg.add_sequence(setting)
    1487             self.assert_(mailbox.BabylMessage(msg).get_labels() == result)
     1667            self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
    14881668        msg = mailbox.MHMessage(_sample_message)
    14891669        msg.add_sequence('unseen')
    14901670        msg.add_sequence('replied')
    14911671        msg.add_sequence('flagged')
    1492         self.assert_(mailbox.BabylMessage(msg).get_labels() == \
    1493                      ['unseen', 'answered'])
     1672        self.assertEqual(mailbox.BabylMessage(msg).get_labels(),
     1673                         ['unseen', 'answered'])
    14941674
    14951675    def test_babyl_to_maildir(self):
    … …  
    15011681            msg = mailbox.BabylMessage(_sample_message)
    15021682            msg.add_label(setting)
    1503             self.assert_(mailbox.MaildirMessage(msg).get_flags() == result)
    1504             self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur')
     1683            self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
     1684            self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
    15051685        msg = mailbox.BabylMessage(_sample_message)
    15061686        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
    15071687                      'edited', 'resent'):
    15081688            msg.add_label(label)
    1509         self.assert_(mailbox.MaildirMessage(msg).get_flags() == 'PRT')
    1510         self.assert_(mailbox.MaildirMessage(msg).get_subdir() == 'cur')
     1689        self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'PRT')
     1690        self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
    15111691
    15121692    def test_babyl_to_mboxmmdf(self):
    … …  
    15191699                msg = mailbox.BabylMessage(_sample_message)
    15201700                msg.add_label(setting)
    1521                 self.assert_(class_(msg).get_flags() == result)
     1701                self.assertEqual(class_(msg).get_flags(), result)
    15221702        msg = mailbox.BabylMessage(_sample_message)
    15231703        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
    … …  
    15251705            msg.add_label(label)
    15261706        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
    1527             self.assert_(class_(msg).get_flags() == 'ODA')
     1707            self.assertEqual(class_(msg).get_flags(), 'ODA')
    15281708
    15291709    def test_babyl_to_mh(self):
    … …  
    15351715            msg = mailbox.BabylMessage(_sample_message)
    15361716            msg.add_label(setting)
    1537             self.assert_(mailbox.MHMessage(msg).get_sequences() == result)
     1717            self.assertEqual(mailbox.MHMessage(msg).get_sequences(), result)
    15381718        msg = mailbox.BabylMessage(_sample_message)
    15391719        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
    15401720                      'edited', 'resent'):
    15411721            msg.add_label(label)
    1542         self.assert_(mailbox.MHMessage(msg).get_sequences() == \
    1543                      ['unseen', 'replied'])
     1722        self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
     1723                         ['unseen', 'replied'])
    15441724
    15451725    def test_babyl_to_babyl(self):
    … …  
    15511731            msg.add_label(label)
    15521732        msg2 = mailbox.BabylMessage(msg)
    1553         self.assert_(msg2.get_labels() == ['unseen', 'deleted', 'filed',
    1554                                            'answered', 'forwarded', 'edited',
    1555                                            'resent'])
    1556         self.assert_(msg.get_visible().keys() == msg2.get_visible().keys())
     1733        self.assertEqual(msg2.get_labels(), ['unseen', 'deleted', 'filed',
     1734                                             'answered', 'forwarded', 'edited',
     1735                                             'resent'])
     1736        self.assertEqual(msg.get_visible().keys(), msg2.get_visible().keys())
    15571737        for key in msg.get_visible().keys():
    1558             self.assert_(msg.get_visible()[key] == msg2.get_visible()[key])
     1738            self.assertEqual(msg.get_visible()[key], msg2.get_visible()[key])
    15591739
    15601740
    … …  
    15641744        # Read by byte
    15651745        proxy.seek(0)
    1566         self.assert_(proxy.read() == 'bar')
     1746        self.assertEqual(proxy.read(), 'bar')
    15671747        proxy.seek(1)
    1568         self.assert_(proxy.read() == 'ar')
     1748        self.assertEqual(proxy.read(), 'ar')
    15691749        proxy.seek(0)
    1570         self.assert_(proxy.read(2) == 'ba')
     1750        self.assertEqual(proxy.read(2), 'ba')
    15711751        proxy.seek(1)
    1572         self.assert_(proxy.read(-1) == 'ar')
     1752        self.assertEqual(proxy.read(-1), 'ar')
    15731753        proxy.seek(2)
    1574         self.assert_(proxy.read(1000) == 'r')
     1754        self.assertEqual(proxy.read(1000), 'r')
    15751755
    15761756    def _test_readline(self, proxy):
    15771757        # Read by line
    15781758        proxy.seek(0)
    1579         self.assert_(proxy.readline() == 'foo' + os.linesep)
    1580         self.assert_(proxy.readline() == 'bar' + os.linesep)
    1581         self.assert_(proxy.readline() == 'fred' + os.linesep)
    1582         self.assert_(proxy.readline() == 'bob')
     1759        self.assertEqual(proxy.readline(), 'foo' + os.linesep)
     1760        self.assertEqual(proxy.readline(), 'bar' + os.linesep)
     1761        self.assertEqual(proxy.readline(), 'fred' + os.linesep)
     1762        self.assertEqual(proxy.readline(), 'bob')
    15831763        proxy.seek(2)
    1584         self.assert_(proxy.readline() == 'o' + os.linesep)
     1764        self.assertEqual(proxy.readline(), 'o' + os.linesep)
    15851765        proxy.seek(6 + 2 * len(os.linesep))
    1586         self.assert_(proxy.readline() == 'fred' + os.linesep)
     1766        self.assertEqual(proxy.readline(), 'fred' + os.linesep)
    15871767        proxy.seek(6 + 2 * len(os.linesep))
    1588         self.assert_(proxy.readline(2) == 'fr')
    1589         self.assert_(proxy.readline(-10) == 'ed' + os.linesep)
     1768        self.assertEqual(proxy.readline(2), 'fr')
     1769        self.assertEqual(proxy.readline(-10), 'ed' + os.linesep)
    15901770
    15911771    def _test_readlines(self, proxy):
    15921772        # Read multiple lines
    15931773        proxy.seek(0)
    1594         self.assert_(proxy.readlines() == ['foo' + os.linesep,
    1595                                            'bar' + os.linesep,
    1596                                            'fred' + os.linesep, 'bob'])
     1774        self.assertEqual(proxy.readlines(), ['foo' + os.linesep,
     1775                                            'bar' + os.linesep,
     1776                                            'fred' + os.linesep, 'bob'])
    15971777        proxy.seek(0)
    1598         self.assert_(proxy.readlines(2) == ['foo' + os.linesep])
     1778        self.assertEqual(proxy.readlines(2), ['foo' + os.linesep])
    15991779        proxy.seek(3 + len(os.linesep))
    1600         self.assert_(proxy.readlines(4 + len(os.linesep)) ==
    1601                      ['bar' + os.linesep, 'fred' + os.linesep])
     1780        self.assertEqual(proxy.readlines(4 + len(os.linesep)),
     1781                         ['bar' + os.linesep, 'fred' + os.linesep])
    16021782        proxy.seek(3)
    1603         self.assert_(proxy.readlines(1000) == [os.linesep, 'bar' + os.linesep,
    1604                                                'fred' + os.linesep, 'bob'])
     1783        self.assertEqual(proxy.readlines(1000), [os.linesep, 'bar' + os.linesep,
     1784                                                 'fred' + os.linesep, 'bob'])
    16051785
    16061786    def _test_iteration(self, proxy):
    … …  
    16081788        proxy.seek(0)
    16091789        iterator = iter(proxy)
    1610         self.assert_(iterator.next() == 'foo' + os.linesep)
    1611         self.assert_(iterator.next() == 'bar' + os.linesep)
    1612         self.assert_(iterator.next() == 'fred' + os.linesep)
    1613         self.assert_(iterator.next() == 'bob')
    1614         self.assertRaises(StopIteration, lambda: iterator.next())
     1790        self.assertEqual(list(iterator),
     1791            ['foo' + os.linesep, 'bar' + os.linesep, 'fred' + os.linesep, 'bob'])
    16151792
    16161793    def _test_seek_and_tell(self, proxy):
    16171794        # Seek and use tell to check position
    16181795        proxy.seek(3)
    1619         self.assert_(proxy.tell() == 3)
    1620         self.assert_(proxy.read(len(os.linesep)) == os.linesep)
     1796        self.assertEqual(proxy.tell(), 3)
     1797        self.assertEqual(proxy.read(len(os.linesep)), os.linesep)
    16211798        proxy.seek(2, 1)
    1622         self.assert_(proxy.read(1 + len(os.linesep)) == 'r' + os.linesep)
     1799        self.assertEqual(proxy.read(1 + len(os.linesep)), 'r' + os.linesep)
    16231800        proxy.seek(-3 - len(os.linesep), 2)
    1624         self.assert_(proxy.read(3) == 'bar')
     1801        self.assertEqual(proxy.read(3), 'bar')
    16251802        proxy.seek(2, 0)
    1626         self.assert_(proxy.read() == 'o' + os.linesep + 'bar' + os.linesep)
     1803        self.assertEqual(proxy.read(), 'o' + os.linesep + 'bar' + os.linesep)
    16271804        proxy.seek(100)
    1628         self.assert_(proxy.read() == '')
     1805        self.assertEqual(proxy.read(), '')
    16291806
    16301807    def _test_close(self, proxy):
    16311808        # Close a file
    16321809        proxy.close()
    1633         self.assertRaises(AttributeError, lambda: proxy.close())
    1634 
    1635 
    1636 class TestProxyFile(TestProxyFileBase):
     1810        # Issue 11700 subsequent closes should be a no-op, not an error.
     1811        proxy.close()
     1812
     1813
     1814class TestProxyFile(TestProxyFileBase, unittest.TestCase):
    16371815
    16381816    def setUp(self):
    … …  
    16491827        pos = self._file.tell()
    16501828        proxy0 = mailbox._ProxyFile(self._file)
    1651         self.assert_(proxy0.tell() == pos)
    1652         self.assert_(self._file.tell() == pos)
     1829        self.assertEqual(proxy0.tell(), pos)
     1830        self.assertEqual(self._file.tell(), pos)
    16531831        proxy1 = mailbox._ProxyFile(self._file, 0)
    1654         self.assert_(proxy1.tell() == 0)
    1655         self.assert_(self._file.tell() == pos)
     1832        self.assertEqual(proxy1.tell(), 0)
     1833        self.assertEqual(self._file.tell(), pos)
    16561834
    16571835    def test_read(self):
    … …  
    16831861
    16841862
    1685 class TestPartialFile(TestProxyFileBase):
     1863class TestPartialFile(TestProxyFileBase, unittest.TestCase):
    16861864
    16871865    def setUp(self):
    … …  
    16981876        pos = self._file.tell()
    16991877        proxy = mailbox._PartialFile(self._file, 2, 5)
    1700         self.assert_(proxy.tell() == 0)
    1701         self.assert_(self._file.tell() == pos)
     1878        self.assertEqual(proxy.tell(), 0)
     1879        self.assertEqual(self._file.tell(), pos)
    17021880
    17031881    def test_read(self):
    … …  
    17501928        # create a new maildir mailbox to work with:
    17511929        self._dir = test_support.TESTFN
     1930        if os.path.isdir(self._dir):
     1931            test_support.rmtree(self._dir)
     1932        if os.path.isfile(self._dir):
     1933            test_support.unlink(self._dir)
    17521934        os.mkdir(self._dir)
    17531935        os.mkdir(os.path.join(self._dir, "cur"))
    … …  
    17591941    def tearDown(self):
    17601942        map(os.unlink, self._msgfiles)
    1761         os.rmdir(os.path.join(self._dir, "cur"))
    1762         os.rmdir(os.path.join(self._dir, "tmp"))
    1763         os.rmdir(os.path.join(self._dir, "new"))
    1764         os.rmdir(self._dir)
     1943        test_support.rmdir(os.path.join(self._dir, "cur"))
     1944        test_support.rmdir(os.path.join(self._dir, "tmp"))
     1945        test_support.rmdir(os.path.join(self._dir, "new"))
     1946        test_support.rmdir(self._dir)
    17651947
    17661948    def createMessage(self, dir, mbox=False):
    … …  
    17711953        tmpname = os.path.join(self._dir, "tmp", filename)
    17721954        newname = os.path.join(self._dir, dir, filename)
    1773         fp = open(tmpname, "w")
    1774         self._msgfiles.append(tmpname)
    1775         if mbox:
    1776             fp.write(FROM_)
    1777         fp.write(DUMMY_MESSAGE)
    1778         fp.close()
     1955        with open(tmpname, "w") as fp:
     1956            self._msgfiles.append(tmpname)
     1957            if mbox:
     1958                fp.write(FROM_)
     1959            fp.write(DUMMY_MESSAGE)
    17791960        if hasattr(os, "link"):
    17801961            os.link(tmpname, newname)
    17811962        else:
    1782             fp = open(newname, "w")
    1783             fp.write(DUMMY_MESSAGE)
    1784             fp.close()
     1963            with open(newname, "w") as fp:
     1964                fp.write(DUMMY_MESSAGE)
    17851965        self._msgfiles.append(newname)
    17861966        return tmpname
    … …  
    17911971        # Make sure the boxes attribute actually gets set.
    17921972        self.mbox = mailbox.Maildir(test_support.TESTFN)
    1793         #self.assert_(hasattr(self.mbox, "boxes"))
    1794         #self.assert_(len(self.mbox.boxes) == 0)
    1795         self.assert_(self.mbox.next() is None)
    1796         self.assert_(self.mbox.next() is None)
     1973        #self.assertTrue(hasattr(self.mbox, "boxes"))
     1974        #self.assertTrue(len(self.mbox.boxes) == 0)
     1975        self.assertIs(self.mbox.next(), None)
     1976        self.assertIs(self.mbox.next(), None)
    17971977
    17981978    def test_nonempty_maildir_cur(self):
    17991979        self.createMessage("cur")
    18001980        self.mbox = mailbox.Maildir(test_support.TESTFN)
    1801         #self.assert_(len(self.mbox.boxes) == 1)
    1802         self.assert_(self.mbox.next() is not None)
    1803         self.assert_(self.mbox.next() is None)
    1804         self.assert_(self.mbox.next() is None)
     1981        #self.assertTrue(len(self.mbox.boxes) == 1)
     1982        msg = self.mbox.next()
     1983        self.assertIsNot(msg, None)
     1984        msg.fp.close()
     1985        self.assertIs(self.mbox.next(), None)
     1986        self.assertIs(self.mbox.next(), None)
    18051987
    18061988    def test_nonempty_maildir_new(self):
    18071989        self.createMessage("new")
    18081990        self.mbox = mailbox.Maildir(test_support.TESTFN)
    1809         #self.assert_(len(self.mbox.boxes) == 1)
    1810         self.assert_(self.mbox.next() is not None)
    1811         self.assert_(self.mbox.next() is None)
    1812         self.assert_(self.mbox.next() is None)
     1991        #self.assertTrue(len(self.mbox.boxes) == 1)
     1992        msg = self.mbox.next()
     1993        self.assertIsNot(msg, None)
     1994        msg.fp.close()
     1995        self.assertIs(self.mbox.next(), None)
     1996        self.assertIs(self.mbox.next(), None)
    18131997
    18141998    def test_nonempty_maildir_both(self):
    … …  
    18162000        self.createMessage("new")
    18172001        self.mbox = mailbox.Maildir(test_support.TESTFN)
    1818         #self.assert_(len(self.mbox.boxes) == 2)
    1819         self.assert_(self.mbox.next() is not None)
    1820         self.assert_(self.mbox.next() is not None)
    1821         self.assert_(self.mbox.next() is None)
    1822         self.assert_(self.mbox.next() is None)
     2002        #self.assertTrue(len(self.mbox.boxes) == 2)
     2003        msg = self.mbox.next()
     2004        self.assertIsNot(msg, None)
     2005        msg.fp.close()
     2006        msg = self.mbox.next()
     2007        self.assertIsNot(msg, None)
     2008        msg.fp.close()
     2009        self.assertIs(self.mbox.next(), None)
     2010        self.assertIs(self.mbox.next(), None)
    18232011
    18242012    def test_unix_mbox(self):
    … …  
    18272015        fname = self.createMessage("cur", True)
    18282016        n = 0
    1829         for msg in mailbox.PortableUnixMailbox(open(fname),
     2017        fid = open(fname)
     2018        for msg in mailbox.PortableUnixMailbox(fid,
    18302019                                               email.parser.Parser().parse):
    18312020            n += 1
    18322021            self.assertEqual(msg["subject"], "Simple Test")
    18332022            self.assertEqual(len(str(msg)), len(FROM_)+len(DUMMY_MESSAGE))
     2023        fid.close()
    18342024        self.assertEqual(n, 1)
    18352025
Note: See TracChangeset for help on using the changeset viewer.