tests: use context manager form of assertRaises

Support for using unittest.TestCase.assertRaises as a context
manager was added in Python 2.7. This form is more readable,
especially for complex tests.

While I was here, I also restored the use of assertRaisesRegexp,
which was removed in c6921568cd20 for Python 2.6 compatibility.

tests/test-atomictempfile.py

@@ -1,119 +1,120 b''
 from __future__ import absolute_import
 
 import glob
 import os
 import shutil
 import tempfile
 import unittest
 
 from mercurial import (
     util,
 )
 atomictempfile = util.atomictempfile
 
 class testatomictempfile(unittest.TestCase):
     def setUp(self):
         self._testdir = tempfile.mkdtemp('atomictempfiletest')
         self._filename = os.path.join(self._testdir, 'testfilename')
 
     def tearDown(self):
         shutil.rmtree(self._testdir, True)
 
     def testsimple(self):
         file = atomictempfile(self._filename)
         self.assertFalse(os.path.isfile(self._filename))
         tempfilename = file._tempname
         self.assertTrue(tempfilename in glob.glob(
             os.path.join(self._testdir, '.testfilename-*')))
 
         file.write(b'argh\n')
         file.close()
 
         self.assertTrue(os.path.isfile(self._filename))
         self.assertTrue(tempfilename not in glob.glob(
             os.path.join(self._testdir, '.testfilename-*')))
 
     # discard() removes the temp file without making the write permanent
     def testdiscard(self):
         file = atomictempfile(self._filename)
         (dir, basename) = os.path.split(file._tempname)
 
         file.write(b'yo\n')
         file.discard()
 
         self.assertFalse(os.path.isfile(self._filename))
         self.assertTrue(basename not in os.listdir('.'))
 
     # if a programmer screws up and passes bad args to atomictempfile, they
     # get a plain ordinary TypeError, not infinite recursion
     def testoops(self):
-        self.assertRaises(TypeError, atomictempfile)
+        with self.assertRaises(TypeError):
+            atomictempfile()
 
     # checkambig=True avoids ambiguity of timestamp
     def testcheckambig(self):
         def atomicwrite(checkambig):
             f = atomictempfile(self._filename, checkambig=checkambig)
             f.write('FOO')
             f.close()
 
         # try some times, because reproduction of ambiguity depends on
         # "filesystem time"
         for i in xrange(5):
             atomicwrite(False)
             oldstat = os.stat(self._filename)
             if oldstat.st_ctime != oldstat.st_mtime:
                 # subsequent changing never causes ambiguity
                 continue
 
             repetition = 3
 
             # repeat atomic write with checkambig=True, to examine
             # whether st_mtime is advanced multiple times as expected
             for j in xrange(repetition):
                 atomicwrite(True)
             newstat = os.stat(self._filename)
             if oldstat.st_ctime != newstat.st_ctime:
                 # timestamp ambiguity was naturally avoided while repetition
                 continue
 
             # st_mtime should be advanced "repetition" times, because
             # all atomicwrite() occurred at same time (in sec)
             self.assertTrue(newstat.st_mtime ==
                             ((oldstat.st_mtime + repetition) & 0x7fffffff))
             # no more examination is needed, if assumption above is true
             break
         else:
             # This platform seems too slow to examine anti-ambiguity
             # of file timestamp (or test happened to be executed at
             # bad timing). Exit silently in this case, because running
             # on other faster platforms can detect problems
             pass
 
     def testread(self):
         with open(self._filename, 'wb') as f:
             f.write(b'foobar\n')
         file = atomictempfile(self._filename, mode='rb')
         self.assertTrue(file.read(), b'foobar\n')
         file.discard()
 
     def testcontextmanagersuccess(self):
         """When the context closes, the file is closed"""
         with atomictempfile('foo') as f:
             self.assertFalse(os.path.isfile('foo'))
             f.write(b'argh\n')
         self.assertTrue(os.path.isfile('foo'))
 
     def testcontextmanagerfailure(self):
         """On exception, the file is discarded"""
         try:
             with atomictempfile('foo') as f:
                 self.assertFalse(os.path.isfile('foo'))
                 f.write(b'argh\n')
                 raise ValueError
         except ValueError:
             pass
         self.assertFalse(os.path.isfile('foo'))
 
 if __name__ == '__main__':
     import silenttestrunner
     silenttestrunner.main(__name__)

tests/test-ctxmanager.py

@@ -1,79 +1,77 b''
 from __future__ import absolute_import
 
 import silenttestrunner
 import unittest
 
 from mercurial import util
 
 class contextmanager(object):
     def __init__(self, name, trace):
         self.name = name
         self.entered = False
         self.exited = False
         self.trace = trace
 
     def __enter__(self):
         self.entered = True
         self.trace(('enter', self.name))
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.exited = exc_type, exc_val, exc_tb
         self.trace(('exit', self.name))
 
     def __repr__(self):
         return '<ctx %r>' % self.name
 
 class ctxerror(Exception):
     pass
 
 class raise_on_enter(contextmanager):
     def __enter__(self):
         self.trace(('raise', self.name))
         raise ctxerror(self.name)
 
 class raise_on_exit(contextmanager):
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.trace(('raise', self.name))
         raise ctxerror(self.name)
 
 def ctxmgr(name, trace):
     return lambda: contextmanager(name, trace)
 
 class test_ctxmanager(unittest.TestCase):
     def test_basics(self):
         trace = []
         addtrace = trace.append
         with util.ctxmanager(ctxmgr('a', addtrace), ctxmgr('b', addtrace)) as c:
             a, b = c.enter()
             c.atexit(addtrace, ('atexit', 'x'))
             c.atexit(addtrace, ('atexit', 'y'))
         self.assertEqual(trace, [('enter', 'a'), ('enter', 'b'),
                                  ('atexit', 'y'), ('atexit', 'x'),
                                  ('exit', 'b'), ('exit', 'a')])
 
     def test_raise_on_enter(self):
         trace = []
         addtrace = trace.append
-        def go():
+        with self.assertRaises(ctxerror):
             with util.ctxmanager(ctxmgr('a', addtrace),
                                  lambda: raise_on_enter('b', addtrace)) as c:
                 c.enter()
                 addtrace('unreachable')
-        self.assertRaises(ctxerror, go)
         self.assertEqual(trace, [('enter', 'a'), ('raise', 'b'), ('exit', 'a')])
 
     def test_raise_on_exit(self):
         trace = []
         addtrace = trace.append
-        def go():
+        with self.assertRaises(ctxerror):
             with util.ctxmanager(ctxmgr('a', addtrace),
                                  lambda: raise_on_exit('b', addtrace)) as c:
                 c.enter()
                 addtrace('running')
-        self.assertRaises(ctxerror, go)
         self.assertEqual(trace, [('enter', 'a'), ('enter', 'b'), 'running',
                                  ('raise', 'b'), ('exit', 'a')])
 
 if __name__ == '__main__':
     silenttestrunner.main(__name__)

tests/test-lock.py

@@ -1,298 +1,296 b''
 from __future__ import absolute_import
 
 import copy
 import errno
 import os
 import silenttestrunner
 import tempfile
 import types
 import unittest
 
 from mercurial import (
     error,
     lock,
     vfs as vfsmod,
 )
 
 testlockname = 'testlock'
 
 # work around http://bugs.python.org/issue1515
 if types.MethodType not in copy._deepcopy_dispatch:
     def _deepcopy_method(x, memo):
         return type(x)(x.im_func, copy.deepcopy(x.im_self, memo), x.im_class)
     copy._deepcopy_dispatch[types.MethodType] = _deepcopy_method
 
 class lockwrapper(lock.lock):
     def __init__(self, pidoffset, *args, **kwargs):
         # lock.lock.__init__() calls lock(), so the pidoffset assignment needs
         # to be earlier
         self._pidoffset = pidoffset
         super(lockwrapper, self).__init__(*args, **kwargs)
     def _getpid(self):
         return super(lockwrapper, self)._getpid() + self._pidoffset
 
 class teststate(object):
     def __init__(self, testcase, dir, pidoffset=0):
         self._testcase = testcase
         self._acquirecalled = False
         self._releasecalled = False
         self._postreleasecalled = False
         self.vfs = vfsmod.vfs(dir, audit=False)
         self._pidoffset = pidoffset
 
     def makelock(self, *args, **kwargs):
         l = lockwrapper(self._pidoffset, self.vfs, testlockname,
                         releasefn=self.releasefn, acquirefn=self.acquirefn,
                         *args, **kwargs)
         l.postrelease.append(self.postreleasefn)
         return l
 
     def acquirefn(self):
         self._acquirecalled = True
 
     def releasefn(self):
         self._releasecalled = True
 
     def postreleasefn(self):
         self._postreleasecalled = True
 
     def assertacquirecalled(self, called):
         self._testcase.assertEqual(
             self._acquirecalled, called,
             'expected acquire to be %s but was actually %s' % (
                 self._tocalled(called),
                 self._tocalled(self._acquirecalled),
             ))
 
     def resetacquirefn(self):
         self._acquirecalled = False
 
     def assertreleasecalled(self, called):
         self._testcase.assertEqual(
             self._releasecalled, called,
             'expected release to be %s but was actually %s' % (
                 self._tocalled(called),
                 self._tocalled(self._releasecalled),
             ))
 
     def assertpostreleasecalled(self, called):
         self._testcase.assertEqual(
             self._postreleasecalled, called,
             'expected postrelease to be %s but was actually %s' % (
                 self._tocalled(called),
                 self._tocalled(self._postreleasecalled),
             ))
 
     def assertlockexists(self, exists):
         actual = self.vfs.lexists(testlockname)
         self._testcase.assertEqual(
             actual, exists,
             'expected lock to %s but actually did %s' % (
                 self._toexists(exists),
                 self._toexists(actual),
             ))
 
     def _tocalled(self, called):
         if called:
             return 'called'
         else:
             return 'not called'
 
     def _toexists(self, exists):
         if exists:
             return 'exist'
         else:
             return 'not exist'
 
 class testlock(unittest.TestCase):
     def testlock(self):
         state = teststate(self, tempfile.mkdtemp(dir=os.getcwd()))
         lock = state.makelock()
         state.assertacquirecalled(True)
         lock.release()
         state.assertreleasecalled(True)
         state.assertpostreleasecalled(True)
         state.assertlockexists(False)
 
     def testrecursivelock(self):
         state = teststate(self, tempfile.mkdtemp(dir=os.getcwd()))
         lock = state.makelock()
         state.assertacquirecalled(True)
 
         state.resetacquirefn()
         lock.lock()
         # recursive lock should not call acquirefn again
         state.assertacquirecalled(False)
 
         lock.release() # brings lock refcount down from 2 to 1
         state.assertreleasecalled(False)
         state.assertpostreleasecalled(False)
         state.assertlockexists(True)
 
         lock.release() # releases the lock
         state.assertreleasecalled(True)
         state.assertpostreleasecalled(True)
         state.assertlockexists(False)
 
     def testlockfork(self):
         state = teststate(self, tempfile.mkdtemp(dir=os.getcwd()))
         lock = state.makelock()
         state.assertacquirecalled(True)
 
         # fake a fork
         forklock = copy.deepcopy(lock)
         forklock._pidoffset = 1
         forklock.release()
         state.assertreleasecalled(False)
         state.assertpostreleasecalled(False)
         state.assertlockexists(True)
 
         # release the actual lock
         lock.release()
         state.assertreleasecalled(True)
         state.assertpostreleasecalled(True)
         state.assertlockexists(False)
 
     def testinheritlock(self):
         d = tempfile.mkdtemp(dir=os.getcwd())
         parentstate = teststate(self, d)
         parentlock = parentstate.makelock()
         parentstate.assertacquirecalled(True)
 
         # set up lock inheritance
         with parentlock.inherit() as lockname:
             parentstate.assertreleasecalled(True)
             parentstate.assertpostreleasecalled(False)
             parentstate.assertlockexists(True)
 
             childstate = teststate(self, d, pidoffset=1)
             childlock = childstate.makelock(parentlock=lockname)
             childstate.assertacquirecalled(True)
 
             childlock.release()
             childstate.assertreleasecalled(True)
             childstate.assertpostreleasecalled(False)
             childstate.assertlockexists(True)
 
             parentstate.resetacquirefn()
 
         parentstate.assertacquirecalled(True)
 
         parentlock.release()
         parentstate.assertreleasecalled(True)
         parentstate.assertpostreleasecalled(True)
         parentstate.assertlockexists(False)
 
     def testmultilock(self):
         d = tempfile.mkdtemp(dir=os.getcwd())
         state0 = teststate(self, d)
         lock0 = state0.makelock()
         state0.assertacquirecalled(True)
 
         with lock0.inherit() as lock0name:
             state0.assertreleasecalled(True)
             state0.assertpostreleasecalled(False)
             state0.assertlockexists(True)
 
             state1 = teststate(self, d, pidoffset=1)
             lock1 = state1.makelock(parentlock=lock0name)
             state1.assertacquirecalled(True)
 
             # from within lock1, acquire another lock
             with lock1.inherit() as lock1name:
                 # since the file on disk is lock0's this should have the same
                 # name
                 self.assertEqual(lock0name, lock1name)
 
                 state2 = teststate(self, d, pidoffset=2)
                 lock2 = state2.makelock(parentlock=lock1name)
                 state2.assertacquirecalled(True)
 
                 lock2.release()
                 state2.assertreleasecalled(True)
                 state2.assertpostreleasecalled(False)
                 state2.assertlockexists(True)
 
                 state1.resetacquirefn()
 
             state1.assertacquirecalled(True)
 
             lock1.release()
             state1.assertreleasecalled(True)
             state1.assertpostreleasecalled(False)
             state1.assertlockexists(True)
 
         lock0.release()
 
     def testinheritlockfork(self):
         d = tempfile.mkdtemp(dir=os.getcwd())
         parentstate = teststate(self, d)
         parentlock = parentstate.makelock()
         parentstate.assertacquirecalled(True)
 
         # set up lock inheritance
         with parentlock.inherit() as lockname:
             childstate = teststate(self, d, pidoffset=1)
             childlock = childstate.makelock(parentlock=lockname)
             childstate.assertacquirecalled(True)
 
             # fork the child lock
             forkchildlock = copy.deepcopy(childlock)
             forkchildlock._pidoffset += 1
             forkchildlock.release()
             childstate.assertreleasecalled(False)
             childstate.assertpostreleasecalled(False)
             childstate.assertlockexists(True)
 
             # release the child lock
             childlock.release()
             childstate.assertreleasecalled(True)
             childstate.assertpostreleasecalled(False)
             childstate.assertlockexists(True)
 
         parentlock.release()
 
     def testinheritcheck(self):
         d = tempfile.mkdtemp(dir=os.getcwd())
         state = teststate(self, d)
         def check():
             raise error.LockInheritanceContractViolation('check failed')
         lock = state.makelock(inheritchecker=check)
         state.assertacquirecalled(True)
 
-        def tryinherit():
+        with self.assertRaises(error.LockInheritanceContractViolation):
             with lock.inherit():
                 pass
 
-        self.assertRaises(error.LockInheritanceContractViolation, tryinherit)
-
         lock.release()
 
     def testfrequentlockunlock(self):
         """This tests whether lock acquisition fails as expected, even if
         (1) lock can't be acquired (makelock fails by EEXIST), and
         (2) locker info can't be read in (readlock fails by ENOENT) while
         retrying 5 times.
         """
 
         d = tempfile.mkdtemp(dir=os.getcwd())
         state = teststate(self, d)
 
         def emulatefrequentlock(*args):
             raise OSError(errno.EEXIST, "File exists")
         def emulatefrequentunlock(*args):
             raise OSError(errno.ENOENT, "No such file or directory")
 
         state.vfs.makelock = emulatefrequentlock
         state.vfs.readlock = emulatefrequentunlock
 
         try:
             state.makelock(timeout=0)
             self.fail("unexpected lock acquisition")
         except error.LockHeld as why:
             self.assertTrue(why.errno == errno.ETIMEDOUT)
             self.assertTrue(why.locker == "")
             state.assertlockexists(False)
 
 if __name__ == '__main__':
     silenttestrunner.main(__name__)

tests/test-manifest.py

@@ -1,487 +1,491 b''
 from __future__ import absolute_import
 
 import binascii
 import itertools
 import silenttestrunner
 import unittest
 
 from mercurial import (
     manifest as manifestmod,
     match as matchmod,
 )
 
 EMTPY_MANIFEST = ''
 EMTPY_MANIFEST_V2 = '\0\n'
 
 HASH_1 = '1' * 40
 BIN_HASH_1 = binascii.unhexlify(HASH_1)
 HASH_2 = 'f' * 40
 BIN_HASH_2 = binascii.unhexlify(HASH_2)
 HASH_3 = '1234567890abcdef0987654321deadbeef0fcafe'
 BIN_HASH_3 = binascii.unhexlify(HASH_3)
 A_SHORT_MANIFEST = (
     'bar/baz/qux.py\0%(hash2)s%(flag2)s\n'
     'foo\0%(hash1)s%(flag1)s\n'
     ) % {'hash1': HASH_1,
          'flag1': '',
          'hash2': HASH_2,
          'flag2': 'l',
          }
 
 # Same data as A_SHORT_MANIFEST
 A_SHORT_MANIFEST_V2 = (
     '\0\n'
     '\x00bar/baz/qux.py\0%(flag2)s\n%(hash2)s\n'
     '\x00foo\0%(flag1)s\n%(hash1)s\n'
     ) % {'hash1': BIN_HASH_1,
          'flag1': '',
          'hash2': BIN_HASH_2,
          'flag2': 'l',
          }
 
 # Same data as A_SHORT_MANIFEST
 A_METADATA_MANIFEST = (
     '\0foo\0bar\n'
     '\x00bar/baz/qux.py\0%(flag2)s\0foo\0bar\n%(hash2)s\n' # flag and metadata
     '\x00foo\0%(flag1)s\0foo\n%(hash1)s\n' # no flag, but metadata
     ) % {'hash1': BIN_HASH_1,
          'flag1': '',
          'hash2': BIN_HASH_2,
          'flag2': 'l',
          }
 
 A_STEM_COMPRESSED_MANIFEST = (
     '\0\n'
     '\x00bar/baz/qux.py\0%(flag2)s\n%(hash2)s\n'
     '\x04qux/foo.py\0%(flag1)s\n%(hash1)s\n' # simple case of 4 stem chars
     '\x0az.py\0%(flag1)s\n%(hash1)s\n' # tricky newline = 10 stem characters
     '\x00%(verylongdir)sx/x\0\n%(hash1)s\n'
     '\xffx/y\0\n%(hash2)s\n' # more than 255 stem chars
     ) % {'hash1': BIN_HASH_1,
          'flag1': '',
          'hash2': BIN_HASH_2,
          'flag2': 'l',
          'verylongdir': 255 * 'x',
          }
 
 A_DEEPER_MANIFEST = (
     'a/b/c/bar.py\0%(hash3)s%(flag1)s\n'
     'a/b/c/bar.txt\0%(hash1)s%(flag1)s\n'
     'a/b/c/foo.py\0%(hash3)s%(flag1)s\n'
     'a/b/c/foo.txt\0%(hash2)s%(flag2)s\n'
     'a/b/d/baz.py\0%(hash3)s%(flag1)s\n'
     'a/b/d/qux.py\0%(hash1)s%(flag2)s\n'
     'a/b/d/ten.txt\0%(hash3)s%(flag2)s\n'
     'a/b/dog.py\0%(hash3)s%(flag1)s\n'
     'a/b/fish.py\0%(hash2)s%(flag1)s\n'
     'a/c/london.py\0%(hash3)s%(flag2)s\n'
     'a/c/paper.txt\0%(hash2)s%(flag2)s\n'
     'a/c/paris.py\0%(hash2)s%(flag1)s\n'
     'a/d/apple.py\0%(hash3)s%(flag1)s\n'
     'a/d/pizza.py\0%(hash3)s%(flag2)s\n'
     'a/green.py\0%(hash1)s%(flag2)s\n'
     'a/purple.py\0%(hash2)s%(flag1)s\n'
     'app.py\0%(hash3)s%(flag1)s\n'
     'readme.txt\0%(hash2)s%(flag1)s\n'
     ) % {'hash1': HASH_1,
          'flag1': '',
          'hash2': HASH_2,
          'flag2': 'l',
          'hash3': HASH_3,
          }
 
 HUGE_MANIFEST_ENTRIES = 200001
 
 A_HUGE_MANIFEST = ''.join(sorted(
     'file%d\0%s%s\n' % (i, h, f) for i, h, f in
     itertools.izip(xrange(200001),
                    itertools.cycle((HASH_1, HASH_2)),
                    itertools.cycle(('', 'x', 'l')))))
 
 class basemanifesttests(object):
     def parsemanifest(self, text):
         raise NotImplementedError('parsemanifest not implemented by test case')
 
     def assertIn(self, thing, container, msg=None):
         # assertIn new in 2.7, use it if available, otherwise polyfill
         sup = getattr(unittest.TestCase, 'assertIn', False)
         if sup:
             return sup(self, thing, container, msg=msg)
         if not msg:
             msg = 'Expected %r in %r' % (thing, container)
         self.assert_(thing in container, msg)
 
     def testEmptyManifest(self):
         m = self.parsemanifest(EMTPY_MANIFEST)
         self.assertEqual(0, len(m))
         self.assertEqual([], list(m))
 
     def testEmptyManifestv2(self):
         m = self.parsemanifest(EMTPY_MANIFEST_V2)
         self.assertEqual(0, len(m))
         self.assertEqual([], list(m))
 
     def testManifest(self):
         m = self.parsemanifest(A_SHORT_MANIFEST)
         self.assertEqual(['bar/baz/qux.py', 'foo'], list(m))
         self.assertEqual(BIN_HASH_2, m['bar/baz/qux.py'])
         self.assertEqual('l', m.flags('bar/baz/qux.py'))
         self.assertEqual(BIN_HASH_1, m['foo'])
         self.assertEqual('', m.flags('foo'))
-        self.assertRaises(KeyError, lambda : m['wat'])
+        with self.assertRaises(KeyError):
+            m['wat']
 
     def testParseManifestV2(self):
         m1 = self.parsemanifest(A_SHORT_MANIFEST)
         m2 = self.parsemanifest(A_SHORT_MANIFEST_V2)
         # Should have same content as A_SHORT_MANIFEST
         self.assertEqual(m1.text(), m2.text())
 
     def testParseManifestMetadata(self):
         # Metadata is for future-proofing and should be accepted but ignored
         m = self.parsemanifest(A_METADATA_MANIFEST)
         self.assertEqual(A_SHORT_MANIFEST, m.text())
 
     def testParseManifestStemCompression(self):
         m = self.parsemanifest(A_STEM_COMPRESSED_MANIFEST)
         self.assertIn('bar/baz/qux.py', m)
         self.assertIn('bar/qux/foo.py', m)
         self.assertIn('bar/qux/foz.py', m)
         self.assertIn(256 * 'x' + '/x', m)
         self.assertIn(256 * 'x' + '/y', m)
         self.assertEqual(A_STEM_COMPRESSED_MANIFEST, m.text(usemanifestv2=True))
 
     def testTextV2(self):
         m1 = self.parsemanifest(A_SHORT_MANIFEST)
         v2text = m1.text(usemanifestv2=True)
         self.assertEqual(A_SHORT_MANIFEST_V2, v2text)
 
     def testSetItem(self):
         want = BIN_HASH_1
 
         m = self.parsemanifest(EMTPY_MANIFEST)
         m['a'] = want
         self.assertIn('a', m)
         self.assertEqual(want, m['a'])
         self.assertEqual('a\0' + HASH_1 + '\n', m.text())
 
         m = self.parsemanifest(A_SHORT_MANIFEST)
         m['a'] = want
         self.assertEqual(want, m['a'])
         self.assertEqual('a\0' + HASH_1 + '\n' + A_SHORT_MANIFEST,
                          m.text())
 
     def testSetFlag(self):
         want = 'x'
 
         m = self.parsemanifest(EMTPY_MANIFEST)
         # first add a file; a file-less flag makes no sense
         m['a'] = BIN_HASH_1
         m.setflag('a', want)
         self.assertEqual(want, m.flags('a'))
         self.assertEqual('a\0' + HASH_1 + want + '\n', m.text())
 
         m = self.parsemanifest(A_SHORT_MANIFEST)
         # first add a file; a file-less flag makes no sense
         m['a'] = BIN_HASH_1
         m.setflag('a', want)
         self.assertEqual(want, m.flags('a'))
         self.assertEqual('a\0' + HASH_1 + want + '\n' + A_SHORT_MANIFEST,
                          m.text())
 
     def testCopy(self):
         m = self.parsemanifest(A_SHORT_MANIFEST)
         m['a'] = BIN_HASH_1
         m2 = m.copy()
         del m
         del m2 # make sure we don't double free() anything
 
     def testCompaction(self):
         unhex = binascii.unhexlify
         h1, h2 = unhex(HASH_1), unhex(HASH_2)
         m = self.parsemanifest(A_SHORT_MANIFEST)
         m['alpha'] = h1
         m['beta'] = h2
         del m['foo']
         want = 'alpha\0%s\nbar/baz/qux.py\0%sl\nbeta\0%s\n' % (
             HASH_1, HASH_2, HASH_2)
         self.assertEqual(want, m.text())
         self.assertEqual(3, len(m))
         self.assertEqual(['alpha', 'bar/baz/qux.py', 'beta'], list(m))
         self.assertEqual(h1, m['alpha'])
         self.assertEqual(h2, m['bar/baz/qux.py'])
         self.assertEqual(h2, m['beta'])
         self.assertEqual('', m.flags('alpha'))
         self.assertEqual('l', m.flags('bar/baz/qux.py'))
         self.assertEqual('', m.flags('beta'))
-        self.assertRaises(KeyError, lambda : m['foo'])
+        with self.assertRaises(KeyError):
+            m['foo']
 
     def testSetGetNodeSuffix(self):
         clean = self.parsemanifest(A_SHORT_MANIFEST)
         m = self.parsemanifest(A_SHORT_MANIFEST)
         h = m['foo']
         f = m.flags('foo')
         want = h + 'a'
         # Merge code wants to set 21-byte fake hashes at times
         m['foo'] = want
         self.assertEqual(want, m['foo'])
         self.assertEqual([('bar/baz/qux.py', BIN_HASH_2),
                           ('foo', BIN_HASH_1 + 'a')],
                          list(m.iteritems()))
         # Sometimes it even tries a 22-byte fake hash, but we can
         # return 21 and it'll work out
         m['foo'] = want + '+'
         self.assertEqual(want, m['foo'])
         # make sure the suffix survives a copy
         match = matchmod.match('', '', ['re:foo'])
         m2 = m.matches(match)
         self.assertEqual(want, m2['foo'])
         self.assertEqual(1, len(m2))
         m2 = m.copy()
         self.assertEqual(want, m2['foo'])
         # suffix with iteration
         self.assertEqual([('bar/baz/qux.py', BIN_HASH_2),
                           ('foo', want)],
                          list(m.iteritems()))
 
         # shows up in diff
         self.assertEqual({'foo': ((want, f), (h, ''))}, m.diff(clean))
         self.assertEqual({'foo': ((h, ''), (want, f))}, clean.diff(m))
 
     def testMatchException(self):
         m = self.parsemanifest(A_SHORT_MANIFEST)
         match = matchmod.match('', '', ['re:.*'])
         def filt(path):
             if path == 'foo':
                 assert False
             return True
         match.matchfn = filt
-        self.assertRaises(AssertionError, m.matches, match)
+        with self.assertRaises(AssertionError):
+            m.matches(match)
 
     def testRemoveItem(self):
         m = self.parsemanifest(A_SHORT_MANIFEST)
         del m['foo']
-        self.assertRaises(KeyError, lambda : m['foo'])
+        with self.assertRaises(KeyError):
+            m['foo']
         self.assertEqual(1, len(m))
         self.assertEqual(1, len(list(m)))
         # now restore and make sure everything works right
         m['foo'] = 'a' * 20
         self.assertEqual(2, len(m))
         self.assertEqual(2, len(list(m)))
 
     def testManifestDiff(self):
         MISSING = (None, '')
         addl = 'z-only-in-left\0' + HASH_1 + '\n'
         addr = 'z-only-in-right\0' + HASH_2 + 'x\n'
         left = self.parsemanifest(
             A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + 'x') + addl)
         right = self.parsemanifest(A_SHORT_MANIFEST + addr)
         want = {
             'foo': ((BIN_HASH_3, 'x'),
                     (BIN_HASH_1, '')),
             'z-only-in-left': ((BIN_HASH_1, ''), MISSING),
             'z-only-in-right': (MISSING, (BIN_HASH_2, 'x')),
             }
         self.assertEqual(want, left.diff(right))
 
         want = {
             'bar/baz/qux.py': (MISSING, (BIN_HASH_2, 'l')),
             'foo': (MISSING, (BIN_HASH_3, 'x')),
             'z-only-in-left': (MISSING, (BIN_HASH_1, '')),
             }
         self.assertEqual(want, self.parsemanifest(EMTPY_MANIFEST).diff(left))
 
         want = {
             'bar/baz/qux.py': ((BIN_HASH_2, 'l'), MISSING),
             'foo': ((BIN_HASH_3, 'x'), MISSING),
             'z-only-in-left': ((BIN_HASH_1, ''), MISSING),
             }
         self.assertEqual(want, left.diff(self.parsemanifest(EMTPY_MANIFEST)))
         copy = right.copy()
         del copy['z-only-in-right']
         del right['foo']
         want = {
             'foo': (MISSING, (BIN_HASH_1, '')),
             'z-only-in-right': ((BIN_HASH_2, 'x'), MISSING),
             }
         self.assertEqual(want, right.diff(copy))
 
         short = self.parsemanifest(A_SHORT_MANIFEST)
         pruned = short.copy()
         del pruned['foo']
         want = {
             'foo': ((BIN_HASH_1, ''), MISSING),
             }
         self.assertEqual(want, short.diff(pruned))
         want = {
             'foo': (MISSING, (BIN_HASH_1, '')),
             }
         self.assertEqual(want, pruned.diff(short))
         want = {
             'bar/baz/qux.py': None,
             'foo': (MISSING, (BIN_HASH_1, '')),
             }
         self.assertEqual(want, pruned.diff(short, clean=True))
 
     def testReversedLines(self):
         backwards = ''.join(
             l + '\n' for l in reversed(A_SHORT_MANIFEST.split('\n')) if l)
         try:
             self.parsemanifest(backwards)
             self.fail('Should have raised ValueError')
         except ValueError as v:
             self.assertIn('Manifest lines not in sorted order.', str(v))
 
     def testNoTerminalNewline(self):
         try:
             self.parsemanifest(A_SHORT_MANIFEST + 'wat')
             self.fail('Should have raised ValueError')
         except ValueError as v:
             self.assertIn('Manifest did not end in a newline.', str(v))
 
     def testNoNewLineAtAll(self):
         try:
             self.parsemanifest('wat')
             self.fail('Should have raised ValueError')
         except ValueError as v:
             self.assertIn('Manifest did not end in a newline.', str(v))
 
     def testHugeManifest(self):
         m = self.parsemanifest(A_HUGE_MANIFEST)
         self.assertEqual(HUGE_MANIFEST_ENTRIES, len(m))
         self.assertEqual(len(m), len(list(m)))
 
     def testMatchesMetadata(self):
         '''Tests matches() for a few specific files to make sure that both
         the set of files as well as their flags and nodeids are correct in
         the resulting manifest.'''
         m = self.parsemanifest(A_HUGE_MANIFEST)
 
         match = matchmod.match('/', '',
                 ['file1', 'file200', 'file300'], exact=True)
         m2 = m.matches(match)
 
         w = ('file1\0%sx\n'
              'file200\0%sl\n'
              'file300\0%s\n') % (HASH_2, HASH_1, HASH_1)
         self.assertEqual(w, m2.text())
 
     def testMatchesNonexistentFile(self):
         '''Tests matches() for a small set of specific files, including one
         nonexistent file to make sure in only matches against existing files.
         '''
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         match = matchmod.match('/', '',
                 ['a/b/c/bar.txt', 'a/b/d/qux.py', 'readme.txt', 'nonexistent'],
                 exact=True)
         m2 = m.matches(match)
 
         self.assertEqual(
                 ['a/b/c/bar.txt', 'a/b/d/qux.py', 'readme.txt'],
                 m2.keys())
 
     def testMatchesNonexistentDirectory(self):
         '''Tests matches() for a relpath match on a directory that doesn't
         actually exist.'''
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         match = matchmod.match('/', '', ['a/f'], default='relpath')
         m2 = m.matches(match)
 
         self.assertEqual([], m2.keys())
 
     def testMatchesExactLarge(self):
         '''Tests matches() for files matching a large list of exact files.
         '''
         m = self.parsemanifest(A_HUGE_MANIFEST)
 
         flist = m.keys()[80:300]
         match = matchmod.match('/', '', flist, exact=True)
         m2 = m.matches(match)
 
         self.assertEqual(flist, m2.keys())
 
     def testMatchesFull(self):
         '''Tests matches() for what should be a full match.'''
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         match = matchmod.match('/', '', [''])
         m2 = m.matches(match)
 
         self.assertEqual(m.keys(), m2.keys())
 
     def testMatchesDirectory(self):
         '''Tests matches() on a relpath match on a directory, which should
         match against all files within said directory.'''
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         match = matchmod.match('/', '', ['a/b'], default='relpath')
         m2 = m.matches(match)
 
         self.assertEqual([
             'a/b/c/bar.py', 'a/b/c/bar.txt', 'a/b/c/foo.py', 'a/b/c/foo.txt',
             'a/b/d/baz.py', 'a/b/d/qux.py', 'a/b/d/ten.txt', 'a/b/dog.py',
             'a/b/fish.py'], m2.keys())
 
     def testMatchesExactPath(self):
         '''Tests matches() on an exact match on a directory, which should
         result in an empty manifest because you can't perform an exact match
         against a directory.'''
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         match = matchmod.match('/', '', ['a/b'], exact=True)
         m2 = m.matches(match)
 
         self.assertEqual([], m2.keys())
 
     def testMatchesCwd(self):
         '''Tests matches() on a relpath match with the current directory ('.')
         when not in the root directory.'''
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         match = matchmod.match('/', 'a/b', ['.'], default='relpath')
         m2 = m.matches(match)
 
         self.assertEqual([
             'a/b/c/bar.py', 'a/b/c/bar.txt', 'a/b/c/foo.py', 'a/b/c/foo.txt',
             'a/b/d/baz.py', 'a/b/d/qux.py', 'a/b/d/ten.txt', 'a/b/dog.py',
             'a/b/fish.py'], m2.keys())
 
     def testMatchesWithPattern(self):
         '''Tests matches() for files matching a pattern that reside
         deeper than the specified directory.'''
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         match = matchmod.match('/', '', ['a/b/*/*.txt'])
         m2 = m.matches(match)
 
         self.assertEqual(
                 ['a/b/c/bar.txt', 'a/b/c/foo.txt', 'a/b/d/ten.txt'],
                 m2.keys())
 
 class testmanifestdict(unittest.TestCase, basemanifesttests):
     def parsemanifest(self, text):
         return manifestmod.manifestdict(text)
 
 class testtreemanifest(unittest.TestCase, basemanifesttests):
     def parsemanifest(self, text):
         return manifestmod.treemanifest('', text)
 
     def testWalkSubtrees(self):
         m = self.parsemanifest(A_DEEPER_MANIFEST)
 
         dirs = [s._dir for s in m.walksubtrees()]
         self.assertEqual(
             sorted(['', 'a/', 'a/c/', 'a/d/', 'a/b/', 'a/b/c/', 'a/b/d/']),
             sorted(dirs)
         )
 
         match = matchmod.match('/', '', ['path:a/b/'])
         dirs = [s._dir for s in m.walksubtrees(matcher=match)]
         self.assertEqual(
             sorted(['a/b/', 'a/b/c/', 'a/b/d/']),
             sorted(dirs)
         )
 
 if __name__ == '__main__':
     silenttestrunner.main(__name__)

tests/test-simplekeyvaluefile.py

@@ -1,84 +1,84 b''
 from __future__ import absolute_import
 
 import unittest
 import silenttestrunner
 
 from mercurial import (
     error,
     scmutil,
 )
 
 class mockfile(object):
     def __init__(self, name, fs):
         self.name = name
         self.fs = fs
 
     def __enter__(self):
         return self
 
     def __exit__(self, *args, **kwargs):
         pass
 
     def write(self, text):
         self.fs.contents[self.name] = text
 
     def read(self):
         return self.fs.contents[self.name]
 
 class mockvfs(object):
     def __init__(self):
         self.contents = {}
 
     def read(self, path):
         return mockfile(path, self).read()
 
     def readlines(self, path):
         # lines need to contain the trailing '\n' to mock the real readlines
         return [l for l in mockfile(path, self).read().splitlines(True)]
 
     def __call__(self, path, mode, atomictemp):
         return mockfile(path, self)
 
 class testsimplekeyvaluefile(unittest.TestCase):
     def setUp(self):
         self.vfs = mockvfs()
 
     def testbasicwritingiandreading(self):
         dw = {'key1': 'value1', 'Key2': 'value2'}
         scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(dw)
         self.assertEqual(sorted(self.vfs.read('kvfile').split('\n')),
                          ['', 'Key2=value2', 'key1=value1'])
         dr = scmutil.simplekeyvaluefile(self.vfs, 'kvfile').read()
         self.assertEqual(dr, dw)
 
     def testinvalidkeys(self):
         d = {'0key1': 'value1', 'Key2': 'value2'}
-        self.assertRaises(error.ProgrammingError,
-                          scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write,
-                          d)
+        with self.assertRaisesRegexp(error.ProgrammingError,
+                                     'keys must start with a letter.*'):
+            scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
+
         d = {'key1@': 'value1', 'Key2': 'value2'}
-        self.assertRaises(error.ProgrammingError,
-                          scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write,
-                          d)
+        with self.assertRaisesRegexp(error.ProgrammingError, 'invalid key.*'):
+            scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
 
     def testinvalidvalues(self):
         d = {'key1': 'value1', 'Key2': 'value2\n'}
-        self.assertRaises(error.ProgrammingError,
-                          scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write,
-                          d)
+        with self.assertRaisesRegexp(error.ProgrammingError,  'invalid val.*'):
+            scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
 
     def testcorruptedfile(self):
         self.vfs.contents['badfile'] = 'ababagalamaga\n'
-        self.assertRaises(error.CorruptedState,
-                          scmutil.simplekeyvaluefile(self.vfs, 'badfile').read)
+        with self.assertRaisesRegexp(error.CorruptedState,
+                                     'dictionary.*element.*'):
+            scmutil.simplekeyvaluefile(self.vfs, 'badfile').read()
 
     def testfirstline(self):
         dw = {'key1': 'value1'}
         scmutil.simplekeyvaluefile(self.vfs, 'fl').write(dw, firstline='1.0')
         self.assertEqual(self.vfs.read('fl'), '1.0\nkey1=value1\n')
         dr = scmutil.simplekeyvaluefile(self.vfs, 'fl')\
                     .read(firstlinenonkeyval=True)
         self.assertEqual(dr, {'__firstline': '1.0', 'key1': 'value1'})
 
 if __name__ == "__main__":
     silenttestrunner.main(__name__)

tests/test-simplemerge.py

@@ -1,360 +1,361 b''
 # Copyright (C) 2004, 2005 Canonical Ltd
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import
 
 import unittest
 from mercurial import (
     error,
     simplemerge,
     util,
 )
 
 TestCase = unittest.TestCase
 # bzr compatible interface, for the tests
 class Merge3(simplemerge.Merge3Text):
     """3-way merge of texts.
 
     Given BASE, OTHER, THIS, tries to produce a combined text
     incorporating the changes from both BASE->OTHER and BASE->THIS.
     All three will typically be sequences of lines."""
     def __init__(self, base, a, b):
         basetext = '\n'.join([i.strip('\n') for i in base] + [''])
         atext = '\n'.join([i.strip('\n') for i in a] + [''])
         btext = '\n'.join([i.strip('\n') for i in b] + [''])
         if util.binary(basetext) or util.binary(atext) or util.binary(btext):
             raise error.Abort("don't know how to merge binary files")
         simplemerge.Merge3Text.__init__(self, basetext, atext, btext,
                                         base, a, b)
 
 CantReprocessAndShowBase = simplemerge.CantReprocessAndShowBase
 
 def split_lines(t):
     return util.stringio(t).readlines()
 
 ############################################################
 # test case data from the gnu diffutils manual
 # common base
 TZU = split_lines("""     The Nameless is the origin of Heaven and Earth;
      The named is the mother of all things.
 
      Therefore let there always be non-being,
        so we may see their subtlety,
      And let there always be being,
        so we may see their outcome.
      The two are the same,
      But after they are produced,
        they have different names.
      They both may be called deep and profound.
      Deeper and more profound,
      The door of all subtleties!
 """)
 
 LAO = split_lines("""     The Way that can be told of is not the eternal Way;
      The name that can be named is not the eternal name.
      The Nameless is the origin of Heaven and Earth;
      The Named is the mother of all things.
      Therefore let there always be non-being,
        so we may see their subtlety,
      And let there always be being,
        so we may see their outcome.
      The two are the same,
      But after they are produced,
        they have different names.
 """)
 
 
 TAO = split_lines("""     The Way that can be told of is not the eternal Way;
      The name that can be named is not the eternal name.
      The Nameless is the origin of Heaven and Earth;
      The named is the mother of all things.
 
      Therefore let there always be non-being,
        so we may see their subtlety,
      And let there always be being,
        so we may see their result.
      The two are the same,
      But after they are produced,
        they have different names.
 
        -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
 """)
 
 MERGED_RESULT = split_lines("""\
      The Way that can be told of is not the eternal Way;
      The name that can be named is not the eternal name.
      The Nameless is the origin of Heaven and Earth;
      The Named is the mother of all things.
      Therefore let there always be non-being,
        so we may see their subtlety,
      And let there always be being,
        so we may see their result.
      The two are the same,
      But after they are produced,
        they have different names.
 <<<<<<< LAO
 =======
 
        -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
 >>>>>>> TAO
 """)
 
 class TestMerge3(TestCase):
     def log(self, msg):
         pass
 
     def test_no_changes(self):
         """No conflicts because nothing changed"""
         m3 = Merge3(['aaa', 'bbb'],
                     ['aaa', 'bbb'],
                     ['aaa', 'bbb'])
 
         self.assertEquals(m3.find_unconflicted(),
                           [(0, 2)])
 
         self.assertEquals(list(m3.find_sync_regions()),
                           [(0, 2,
                             0, 2,
                             0, 2),
                            (2, 2,  2, 2,  2, 2)])
 
         self.assertEquals(list(m3.merge_regions()),
                           [('unchanged', 0, 2)])
 
         self.assertEquals(list(m3.merge_groups()),
                           [('unchanged', ['aaa', 'bbb'])])
 
     def test_front_insert(self):
         m3 = Merge3(['zz'],
                     ['aaa', 'bbb', 'zz'],
                     ['zz'])
 
         # todo: should use a sentinel at end as from get_matching_blocks
         # to match without zz
         self.assertEquals(list(m3.find_sync_regions()),
                           [(0, 1,  2, 3,  0, 1),
                            (1, 1,  3, 3,  1, 1)])
 
         self.assertEquals(list(m3.merge_regions()),
                           [('a', 0, 2),
                            ('unchanged', 0, 1)])
 
         self.assertEquals(list(m3.merge_groups()),
                           [('a', ['aaa', 'bbb']),
                            ('unchanged', ['zz'])])
 
     def test_null_insert(self):
         m3 = Merge3([],
                     ['aaa', 'bbb'],
                     [])
         # todo: should use a sentinel at end as from get_matching_blocks
         # to match without zz
         self.assertEquals(list(m3.find_sync_regions()),
                           [(0, 0,  2, 2,  0, 0)])
 
         self.assertEquals(list(m3.merge_regions()),
                           [('a', 0, 2)])
 
         self.assertEquals(list(m3.merge_lines()),
                           ['aaa', 'bbb'])
 
     def test_no_conflicts(self):
         """No conflicts because only one side changed"""
         m3 = Merge3(['aaa', 'bbb'],
                     ['aaa', '111', 'bbb'],
                     ['aaa', 'bbb'])
 
         self.assertEquals(m3.find_unconflicted(),
                           [(0, 1), (1, 2)])
 
         self.assertEquals(list(m3.find_sync_regions()),
                           [(0, 1,  0, 1,  0, 1),
                            (1, 2,  2, 3,  1, 2),
                            (2, 2,  3, 3,  2, 2)])
 
         self.assertEquals(list(m3.merge_regions()),
                           [('unchanged', 0, 1),
                            ('a', 1, 2),
                            ('unchanged', 1, 2)])
 
     def test_append_a(self):
         m3 = Merge3(['aaa\n', 'bbb\n'],
                     ['aaa\n', 'bbb\n', '222\n'],
                     ['aaa\n', 'bbb\n'])
 
         self.assertEquals(''.join(m3.merge_lines()),
                           'aaa\nbbb\n222\n')
 
     def test_append_b(self):
         m3 = Merge3(['aaa\n', 'bbb\n'],
                     ['aaa\n', 'bbb\n'],
                     ['aaa\n', 'bbb\n', '222\n'])
 
         self.assertEquals(''.join(m3.merge_lines()),
                           'aaa\nbbb\n222\n')
 
     def test_append_agreement(self):
         m3 = Merge3(['aaa\n', 'bbb\n'],
                     ['aaa\n', 'bbb\n', '222\n'],
                     ['aaa\n', 'bbb\n', '222\n'])
 
         self.assertEquals(''.join(m3.merge_lines()),
                           'aaa\nbbb\n222\n')
 
     def test_append_clash(self):
         m3 = Merge3(['aaa\n', 'bbb\n'],
                     ['aaa\n', 'bbb\n', '222\n'],
                     ['aaa\n', 'bbb\n', '333\n'])
 
         ml = m3.merge_lines(name_a='a',
                             name_b='b',
                             start_marker='<<',
                             mid_marker='--',
                             end_marker='>>')
         self.assertEquals(''.join(ml),
                           'aaa\n'
                           'bbb\n'
                           '<< a\n'
                           '222\n'
                           '--\n'
                           '333\n'
                           '>> b\n'
                          )
 
     def test_insert_agreement(self):
         m3 = Merge3(['aaa\n', 'bbb\n'],
                     ['aaa\n', '222\n', 'bbb\n'],
                     ['aaa\n', '222\n', 'bbb\n'])
 
         ml = m3.merge_lines(name_a='a',
                             name_b='b',
                             start_marker='<<',
                             mid_marker='--',
                             end_marker='>>')
         self.assertEquals(''.join(ml), 'aaa\n222\nbbb\n')
 
 
     def test_insert_clash(self):
         """Both try to insert lines in the same place."""
         m3 = Merge3(['aaa\n', 'bbb\n'],
                     ['aaa\n', '111\n', 'bbb\n'],
                     ['aaa\n', '222\n', 'bbb\n'])
 
         self.assertEquals(m3.find_unconflicted(),
                           [(0, 1), (1, 2)])
 
         self.assertEquals(list(m3.find_sync_regions()),
                           [(0, 1,  0, 1,  0, 1),
                            (1, 2,  2, 3,  2, 3),
                            (2, 2,  3, 3,  3, 3)])
 
         self.assertEquals(list(m3.merge_regions()),
                           [('unchanged', 0, 1),
                            ('conflict', 1, 1,  1, 2,  1, 2),
                            ('unchanged', 1, 2)])
 
         self.assertEquals(list(m3.merge_groups()),
                           [('unchanged', ['aaa\n']),
                            ('conflict', [], ['111\n'], ['222\n']),
                            ('unchanged', ['bbb\n']),
                            ])
 
         ml = m3.merge_lines(name_a='a',
                             name_b='b',
                             start_marker='<<',
                             mid_marker='--',
                             end_marker='>>')
         self.assertEquals(''.join(ml),
 '''aaa
 << a
 111
 --
 222
 >> b
 bbb
 ''')
 
     def test_replace_clash(self):
         """Both try to insert lines in the same place."""
         m3 = Merge3(['aaa', '000', 'bbb'],
                     ['aaa', '111', 'bbb'],
                     ['aaa', '222', 'bbb'])
 
         self.assertEquals(m3.find_unconflicted(),
                           [(0, 1), (2, 3)])
 
         self.assertEquals(list(m3.find_sync_regions()),
                           [(0, 1,  0, 1,  0, 1),
                            (2, 3,  2, 3,  2, 3),
                            (3, 3,  3, 3,  3, 3)])
 
     def test_replace_multi(self):
         """Replacement with regions of different size."""
         m3 = Merge3(['aaa', '000', '000', 'bbb'],
                     ['aaa', '111', '111', '111', 'bbb'],
                     ['aaa', '222', '222', '222', '222', 'bbb'])
 
         self.assertEquals(m3.find_unconflicted(),
                           [(0, 1), (3, 4)])
 
 
         self.assertEquals(list(m3.find_sync_regions()),
                           [(0, 1,  0, 1,  0, 1),
                            (3, 4,  4, 5,  5, 6),
                            (4, 4,  5, 5,  6, 6)])
 
     def test_merge_poem(self):
         """Test case from diff3 manual"""
         m3 = Merge3(TZU, LAO, TAO)
         ml = list(m3.merge_lines('LAO', 'TAO'))
         self.log('merge result:')
         self.log(''.join(ml))
         self.assertEquals(ml, MERGED_RESULT)
 
     def test_binary(self):
-        self.assertRaises(error.Abort, Merge3, ['\x00'], ['a'], ['b'])
+        with self.assertRaises(error.Abort):
+            Merge3(['\x00'], ['a'], ['b'])
 
     def test_dos_text(self):
         base_text = 'a\r\n'
         this_text = 'b\r\n'
         other_text = 'c\r\n'
         m3 = Merge3(base_text.splitlines(True), other_text.splitlines(True),
                     this_text.splitlines(True))
         m_lines = m3.merge_lines('OTHER', 'THIS')
         self.assertEqual('<<<<<<< OTHER\r\nc\r\n=======\r\nb\r\n'
             '>>>>>>> THIS\r\n'.splitlines(True), list(m_lines))
 
     def test_mac_text(self):
         base_text = 'a\r'
         this_text = 'b\r'
         other_text = 'c\r'
         m3 = Merge3(base_text.splitlines(True), other_text.splitlines(True),
                     this_text.splitlines(True))
         m_lines = m3.merge_lines('OTHER', 'THIS')
         self.assertEqual('<<<<<<< OTHER\rc\r=======\rb\r'
             '>>>>>>> THIS\r'.splitlines(True), list(m_lines))
 
 if __name__ == '__main__':
     # hide the timer
     import time
     orig = time.time
     try:
         time.time = lambda: 0
         unittest.main()
     finally:
         time.time = orig