cleanup: polyfill assertRaisesRegex so we can avoid assertRaisesRegexp

The latter is deprecated on Python 3.7 and causes our tests to fail
due to the warning.

Differential Revision: https://phab.mercurial-scm.org/D3375

tests/test-simplekeyvaluefile.py

@@ -1,84 +1,90 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)
 
+    if not getattr(unittest.TestCase, 'assertRaisesRegex', False):
+        # Python 3.7 deprecates the regex*p* version, but 2.7 lacks
+        # the regex version.
+        assertRaisesRegex = (# camelcase-required
+            unittest.TestCase.assertRaisesRegexp)
+
     def testinvalidkeys(self):
         d = {'0key1': 'value1', 'Key2': 'value2'}
-        with self.assertRaisesRegexp(error.ProgrammingError,
+        with self.assertRaisesRegex(error.ProgrammingError,
                                      'keys must start with a letter.*'):
             scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
 
         d = {'key1@': 'value1', 'Key2': 'value2'}
-        with self.assertRaisesRegexp(error.ProgrammingError, 'invalid key.*'):
+        with self.assertRaisesRegex(error.ProgrammingError, 'invalid key.*'):
             scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
 
     def testinvalidvalues(self):
         d = {'key1': 'value1', 'Key2': 'value2\n'}
-        with self.assertRaisesRegexp(error.ProgrammingError,  'invalid val.*'):
+        with self.assertRaisesRegex(error.ProgrammingError,  'invalid val.*'):
             scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
 
     def testcorruptedfile(self):
         self.vfs.contents['badfile'] = 'ababagalamaga\n'
-        with self.assertRaisesRegexp(error.CorruptedState,
+        with self.assertRaisesRegex(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-wireproto-clientreactor.py

@@ -1,130 +1,143 b''
 from __future__ import absolute_import
 
 import unittest
 
 from mercurial import (
     error,
     wireprotoframing as framing,
 )
 
 ffs = framing.makeframefromhumanstring
 
 def sendframe(reactor, frame):
     """Send a frame bytearray to a reactor."""
     header = framing.parseheader(frame)
     payload = frame[framing.FRAME_HEADER_SIZE:]
     assert len(payload) == header.length
 
     return reactor.onframerecv(framing.frame(header.requestid,
                                              header.streamid,
                                              header.streamflags,
                                              header.typeid,
                                              header.flags,
                                              payload))
 
 class SingleSendTests(unittest.TestCase):
     """A reactor that can only send once rejects subsequent sends."""
+
+    if not getattr(unittest.TestCase, 'assertRaisesRegex', False):
+        # Python 3.7 deprecates the regex*p* version, but 2.7 lacks
+        # the regex version.
+        assertRaisesRegex = (# camelcase-required
+            unittest.TestCase.assertRaisesRegexp)
+
     def testbasic(self):
         reactor = framing.clientreactor(hasmultiplesend=False, buffersends=True)
 
         request, action, meta = reactor.callcommand(b'foo', {})
         self.assertEqual(request.state, b'pending')
         self.assertEqual(action, b'noop')
 
         action, meta = reactor.flushcommands()
         self.assertEqual(action, b'sendframes')
 
         for frame in meta[b'framegen']:
             self.assertEqual(request.state, b'sending')
 
         self.assertEqual(request.state, b'sent')
 
-        with self.assertRaisesRegexp(error.ProgrammingError,
+        with self.assertRaisesRegex(error.ProgrammingError,
                                      'cannot issue new commands'):
             reactor.callcommand(b'foo', {})
 
-        with self.assertRaisesRegexp(error.ProgrammingError,
+        with self.assertRaisesRegex(error.ProgrammingError,
                                      'cannot issue new commands'):
             reactor.callcommand(b'foo', {})
 
 class NoBufferTests(unittest.TestCase):
     """A reactor without send buffering sends requests immediately."""
     def testbasic(self):
         reactor = framing.clientreactor(hasmultiplesend=True, buffersends=False)
 
         request, action, meta = reactor.callcommand(b'command1', {})
         self.assertEqual(request.requestid, 1)
         self.assertEqual(action, b'sendframes')
 
         self.assertEqual(request.state, b'pending')
 
         for frame in meta[b'framegen']:
             self.assertEqual(request.state, b'sending')
 
         self.assertEqual(request.state, b'sent')
 
         action, meta = reactor.flushcommands()
         self.assertEqual(action, b'noop')
 
         # And we can send another command.
         request, action, meta = reactor.callcommand(b'command2', {})
         self.assertEqual(request.requestid, 3)
         self.assertEqual(action, b'sendframes')
 
         for frame in meta[b'framegen']:
             self.assertEqual(request.state, b'sending')
 
         self.assertEqual(request.state, b'sent')
 
 class BadFrameRecvTests(unittest.TestCase):
+    if not getattr(unittest.TestCase, 'assertRaisesRegex', False):
+        # Python 3.7 deprecates the regex*p* version, but 2.7 lacks
+        # the regex version.
+        assertRaisesRegex = (# camelcase-required
+            unittest.TestCase.assertRaisesRegexp)
+
     def testoddstream(self):
         reactor = framing.clientreactor()
 
         action, meta = sendframe(reactor, ffs(b'1 1 0 1 0 foo'))
         self.assertEqual(action, b'error')
         self.assertEqual(meta[b'message'],
                          b'received frame with odd numbered stream ID: 1')
 
     def testunknownstream(self):
         reactor = framing.clientreactor()
 
         action, meta = sendframe(reactor, ffs(b'1 0 0 1 0 foo'))
         self.assertEqual(action, b'error')
         self.assertEqual(meta[b'message'],
                          b'received frame on unknown stream without beginning '
                          b'of stream flag set')
 
     def testunhandledframetype(self):
         reactor = framing.clientreactor(buffersends=False)
 
         request, action, meta = reactor.callcommand(b'foo', {})
         for frame in meta[b'framegen']:
             pass
 
-        with self.assertRaisesRegexp(error.ProgrammingError,
+        with self.assertRaisesRegex(error.ProgrammingError,
                                      'unhandled frame type'):
             sendframe(reactor, ffs(b'1 0 stream-begin text-output 0 foo'))
 
 class StreamTests(unittest.TestCase):
     def testmultipleresponseframes(self):
         reactor = framing.clientreactor(buffersends=False)
 
         request, action, meta = reactor.callcommand(b'foo', {})
 
         self.assertEqual(action, b'sendframes')
         for f in meta[b'framegen']:
             pass
 
         action, meta = sendframe(
             reactor,
             ffs(b'%d 0 stream-begin 4 0 foo' % request.requestid))
         self.assertEqual(action, b'responsedata')
 
         action, meta = sendframe(
             reactor,
             ffs(b'%d 0 0 4 eos bar' % request.requestid))
         self.assertEqual(action, b'responsedata')
 
 if __name__ == '__main__':
     import silenttestrunner
     silenttestrunner.main(__name__)

tests/test-wireproto-framing.py

@@ -1,191 +1,197 b''
 from __future__ import absolute_import, print_function
 
 import unittest
 
 from mercurial import (
     util,
     wireprotoframing as framing,
 )
 
 ffs = framing.makeframefromhumanstring
 
 class FrameHumanStringTests(unittest.TestCase):
     def testbasic(self):
         self.assertEqual(ffs(b'1 1 0 1 0 '),
                          b'\x00\x00\x00\x01\x00\x01\x00\x10')
 
         self.assertEqual(ffs(b'2 4 0 1 0 '),
                          b'\x00\x00\x00\x02\x00\x04\x00\x10')
 
         self.assertEqual(ffs(b'2 4 0 1 0 foo'),
                          b'\x03\x00\x00\x02\x00\x04\x00\x10foo')
 
     def testcborint(self):
         self.assertEqual(ffs(b'1 1 0 1 0 cbor:15'),
                          b'\x01\x00\x00\x01\x00\x01\x00\x10\x0f')
 
         self.assertEqual(ffs(b'1 1 0 1 0 cbor:42'),
                          b'\x02\x00\x00\x01\x00\x01\x00\x10\x18*')
 
         self.assertEqual(ffs(b'1 1 0 1 0 cbor:1048576'),
                          b'\x05\x00\x00\x01\x00\x01\x00\x10\x1a'
                          b'\x00\x10\x00\x00')
 
         self.assertEqual(ffs(b'1 1 0 1 0 cbor:0'),
                          b'\x01\x00\x00\x01\x00\x01\x00\x10\x00')
 
         self.assertEqual(ffs(b'1 1 0 1 0 cbor:-1'),
                          b'\x01\x00\x00\x01\x00\x01\x00\x10 ')
 
         self.assertEqual(ffs(b'1 1 0 1 0 cbor:-342542'),
                          b'\x05\x00\x00\x01\x00\x01\x00\x10:\x00\x05:\r')
 
     def testcborstrings(self):
         self.assertEqual(ffs(b"1 1 0 1 0 cbor:b'foo'"),
                          b'\x04\x00\x00\x01\x00\x01\x00\x10Cfoo')
 
         self.assertEqual(ffs(b"1 1 0 1 0 cbor:u'foo'"),
                          b'\x04\x00\x00\x01\x00\x01\x00\x10cfoo')
 
     def testcborlists(self):
         self.assertEqual(ffs(b"1 1 0 1 0 cbor:[None, True, False, 42, b'foo']"),
                          b'\n\x00\x00\x01\x00\x01\x00\x10\x85\xf6\xf5\xf4'
                          b'\x18*Cfoo')
 
     def testcbordicts(self):
         self.assertEqual(ffs(b"1 1 0 1 0 "
                              b"cbor:{b'foo': b'val1', b'bar': b'val2'}"),
                          b'\x13\x00\x00\x01\x00\x01\x00\x10\xa2'
                          b'CbarDval2CfooDval1')
 
 class FrameTests(unittest.TestCase):
     def testdataexactframesize(self):
         data = util.bytesio(b'x' * framing.DEFAULT_MAX_FRAME_SIZE)
 
         stream = framing.stream(1)
         frames = list(framing.createcommandframes(stream, 1, b'command',
                                                   {}, data))
         self.assertEqual(frames, [
             ffs(b'1 1 stream-begin command-request new|have-data '
                 b"cbor:{b'name': b'command'}"),
             ffs(b'1 1 0 command-data continuation %s' % data.getvalue()),
             ffs(b'1 1 0 command-data eos ')
         ])
 
     def testdatamultipleframes(self):
         data = util.bytesio(b'x' * (framing.DEFAULT_MAX_FRAME_SIZE + 1))
 
         stream = framing.stream(1)
         frames = list(framing.createcommandframes(stream, 1, b'command', {},
                                                   data))
         self.assertEqual(frames, [
             ffs(b'1 1 stream-begin command-request new|have-data '
                 b"cbor:{b'name': b'command'}"),
             ffs(b'1 1 0 command-data continuation %s' % (
                 b'x' * framing.DEFAULT_MAX_FRAME_SIZE)),
             ffs(b'1 1 0 command-data eos x'),
         ])
 
     def testargsanddata(self):
         data = util.bytesio(b'x' * 100)
 
         stream = framing.stream(1)
         frames = list(framing.createcommandframes(stream, 1, b'command', {
             b'key1': b'key1value',
             b'key2': b'key2value',
             b'key3': b'key3value',
         }, data))
 
         self.assertEqual(frames, [
             ffs(b'1 1 stream-begin command-request new|have-data '
                 b"cbor:{b'name': b'command', b'args': {b'key1': b'key1value', "
                 b"b'key2': b'key2value', b'key3': b'key3value'}}"),
             ffs(b'1 1 0 command-data eos %s' % data.getvalue()),
         ])
 
+    if not getattr(unittest.TestCase, 'assertRaisesRegex', False):
+        # Python 3.7 deprecates the regex*p* version, but 2.7 lacks
+        # the regex version.
+        assertRaisesRegex = (# camelcase-required
+            unittest.TestCase.assertRaisesRegexp)
+
     def testtextoutputformattingstringtype(self):
         """Formatting string must be bytes."""
-        with self.assertRaisesRegexp(ValueError, 'must use bytes formatting '):
+        with self.assertRaisesRegex(ValueError, 'must use bytes formatting '):
             list(framing.createtextoutputframe(None, 1, [
                 (b'foo'.decode('ascii'), [], [])]))
 
     def testtextoutputargumentbytes(self):
-        with self.assertRaisesRegexp(ValueError, 'must use bytes for argument'):
+        with self.assertRaisesRegex(ValueError, 'must use bytes for argument'):
             list(framing.createtextoutputframe(None, 1, [
                 (b'foo', [b'foo'.decode('ascii')], [])]))
 
     def testtextoutputlabelbytes(self):
-        with self.assertRaisesRegexp(ValueError, 'must use bytes for labels'):
+        with self.assertRaisesRegex(ValueError, 'must use bytes for labels'):
             list(framing.createtextoutputframe(None, 1, [
                 (b'foo', [], [b'foo'.decode('ascii')])]))
 
     def testtextoutput1simpleatom(self):
         stream = framing.stream(1)
         val = list(framing.createtextoutputframe(stream, 1, [
             (b'foo', [], [])]))
 
         self.assertEqual(val, [
             ffs(b'1 1 stream-begin text-output 0 '
                 b"cbor:[{b'msg': b'foo'}]"),
         ])
 
     def testtextoutput2simpleatoms(self):
         stream = framing.stream(1)
         val = list(framing.createtextoutputframe(stream, 1, [
             (b'foo', [], []),
             (b'bar', [], []),
         ]))
 
         self.assertEqual(val, [
             ffs(b'1 1 stream-begin text-output 0 '
                 b"cbor:[{b'msg': b'foo'}, {b'msg': b'bar'}]")
         ])
 
     def testtextoutput1arg(self):
         stream = framing.stream(1)
         val = list(framing.createtextoutputframe(stream, 1, [
             (b'foo %s', [b'val1'], []),
         ]))
 
         self.assertEqual(val, [
             ffs(b'1 1 stream-begin text-output 0 '
                 b"cbor:[{b'msg': b'foo %s', b'args': [b'val1']}]")
         ])
 
     def testtextoutput2arg(self):
         stream = framing.stream(1)
         val = list(framing.createtextoutputframe(stream, 1, [
             (b'foo %s %s', [b'val', b'value'], []),
         ]))
 
         self.assertEqual(val, [
             ffs(b'1 1 stream-begin text-output 0 '
                 b"cbor:[{b'msg': b'foo %s %s', b'args': [b'val', b'value']}]")
         ])
 
     def testtextoutput1label(self):
         stream = framing.stream(1)
         val = list(framing.createtextoutputframe(stream, 1, [
             (b'foo', [], [b'label']),
         ]))
 
         self.assertEqual(val, [
             ffs(b'1 1 stream-begin text-output 0 '
                 b"cbor:[{b'msg': b'foo', b'labels': [b'label']}]")
         ])
 
     def testargandlabel(self):
         stream = framing.stream(1)
         val = list(framing.createtextoutputframe(stream, 1, [
             (b'foo %s', [b'arg'], [b'label']),
         ]))
 
         self.assertEqual(val, [
             ffs(b'1 1 stream-begin text-output 0 '
                 b"cbor:[{b'msg': b'foo %s', b'args': [b'arg'], "
                 b"b'labels': [b'label']}]")
         ])
 
 if __name__ == '__main__':
     import silenttestrunner
     silenttestrunner.main(__name__)

tests/test-wsgirequest.py

@@ -1,416 +1,422 b''
 from __future__ import absolute_import, print_function
 
 import unittest
 
 from mercurial.hgweb import (
     request as requestmod,
 )
 from mercurial import (
     error,
 )
 
 DEFAULT_ENV = {
     r'REQUEST_METHOD': r'GET',
     r'SERVER_NAME': r'testserver',
     r'SERVER_PORT': r'80',
     r'SERVER_PROTOCOL': r'http',
     r'wsgi.version': (1, 0),
     r'wsgi.url_scheme': r'http',
     r'wsgi.input': None,
     r'wsgi.errors': None,
     r'wsgi.multithread': False,
     r'wsgi.multiprocess': True,
     r'wsgi.run_once': False,
 }
 
 def parse(env, reponame=None, altbaseurl=None, extra=None):
     env = dict(env)
     env.update(extra or {})
 
     return requestmod.parserequestfromenv(env, reponame=reponame,
                                           altbaseurl=altbaseurl)
 
 class ParseRequestTests(unittest.TestCase):
     def testdefault(self):
         r = parse(DEFAULT_ENV)
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.method, b'GET')
         self.assertIsNone(r.remoteuser)
         self.assertIsNone(r.remotehost)
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
         self.assertIsNone(r.reponame)
         self.assertEqual(r.querystring, b'')
         self.assertEqual(len(r.qsparams), 0)
         self.assertEqual(len(r.headers), 0)
 
     def testcustomport(self):
         r = parse(DEFAULT_ENV, extra={
             r'SERVER_PORT': r'8000',
         })
 
         self.assertEqual(r.url, b'http://testserver:8000')
         self.assertEqual(r.baseurl, b'http://testserver:8000')
         self.assertEqual(r.advertisedurl, b'http://testserver:8000')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver:8000')
 
         r = parse(DEFAULT_ENV, extra={
             r'SERVER_PORT': r'4000',
             r'wsgi.url_scheme': r'https',
         })
 
         self.assertEqual(r.url, b'https://testserver:4000')
         self.assertEqual(r.baseurl, b'https://testserver:4000')
         self.assertEqual(r.advertisedurl, b'https://testserver:4000')
         self.assertEqual(r.advertisedbaseurl, b'https://testserver:4000')
 
     def testhttphost(self):
         r = parse(DEFAULT_ENV, extra={
             r'HTTP_HOST': r'altserver',
         })
 
         self.assertEqual(r.url, b'http://altserver')
         self.assertEqual(r.baseurl, b'http://altserver')
         self.assertEqual(r.advertisedurl, b'http://testserver')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
 
     def testscriptname(self):
         r = parse(DEFAULT_ENV, extra={
             r'SCRIPT_NAME': r'',
         })
 
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
 
         r = parse(DEFAULT_ENV, extra={
             r'SCRIPT_NAME': r'/script',
         })
 
         self.assertEqual(r.url, b'http://testserver/script')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver/script')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'/script')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
 
         r = parse(DEFAULT_ENV, extra={
             r'SCRIPT_NAME': r'/multiple words',
         })
 
         self.assertEqual(r.url, b'http://testserver/multiple%20words')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver/multiple%20words')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'/multiple words')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
 
     def testpathinfo(self):
         r = parse(DEFAULT_ENV, extra={
             r'PATH_INFO': r'',
         })
 
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [])
         self.assertEqual(r.dispatchpath, b'')
 
         r = parse(DEFAULT_ENV, extra={
             r'PATH_INFO': r'/pathinfo',
         })
 
         self.assertEqual(r.url, b'http://testserver/pathinfo')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver/pathinfo')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [b'pathinfo'])
         self.assertEqual(r.dispatchpath, b'pathinfo')
 
         r = parse(DEFAULT_ENV, extra={
             r'PATH_INFO': r'/one/two/',
         })
 
         self.assertEqual(r.url, b'http://testserver/one/two/')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver/one/two/')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [b'one', b'two'])
         self.assertEqual(r.dispatchpath, b'one/two')
 
     def testscriptandpathinfo(self):
         r = parse(DEFAULT_ENV, extra={
             r'SCRIPT_NAME': r'/script',
             r'PATH_INFO': r'/pathinfo',
         })
 
         self.assertEqual(r.url, b'http://testserver/script/pathinfo')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver/script/pathinfo')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'/script')
         self.assertEqual(r.dispatchparts, [b'pathinfo'])
         self.assertEqual(r.dispatchpath, b'pathinfo')
 
         r = parse(DEFAULT_ENV, extra={
             r'SCRIPT_NAME': r'/script1/script2',
             r'PATH_INFO': r'/path1/path2',
         })
 
         self.assertEqual(r.url,
                          b'http://testserver/script1/script2/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl,
                          b'http://testserver/script1/script2/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'/script1/script2')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
 
         r = parse(DEFAULT_ENV, extra={
             r'HTTP_HOST': r'hostserver',
             r'SCRIPT_NAME': r'/script',
             r'PATH_INFO': r'/pathinfo',
         })
 
         self.assertEqual(r.url, b'http://hostserver/script/pathinfo')
         self.assertEqual(r.baseurl, b'http://hostserver')
         self.assertEqual(r.advertisedurl, b'http://testserver/script/pathinfo')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'/script')
         self.assertEqual(r.dispatchparts, [b'pathinfo'])
         self.assertEqual(r.dispatchpath, b'pathinfo')
 
+    if not getattr(unittest.TestCase, 'assertRaisesRegex', False):
+        # Python 3.7 deprecates the regex*p* version, but 2.7 lacks
+        # the regex version.
+        assertRaisesRegex = (# camelcase-required
+            unittest.TestCase.assertRaisesRegexp)
+
     def testreponame(self):
         """repository path components get stripped from URL."""
 
-        with self.assertRaisesRegexp(error.ProgrammingError,
+        with self.assertRaisesRegex(error.ProgrammingError,
                                      b'reponame requires PATH_INFO'):
             parse(DEFAULT_ENV, reponame=b'repo')
 
-        with self.assertRaisesRegexp(error.ProgrammingError,
+        with self.assertRaisesRegex(error.ProgrammingError,
                                      b'PATH_INFO does not begin with repo '
                                      b'name'):
             parse(DEFAULT_ENV, reponame=b'repo', extra={
                 r'PATH_INFO': r'/pathinfo',
             })
 
-        with self.assertRaisesRegexp(error.ProgrammingError,
+        with self.assertRaisesRegex(error.ProgrammingError,
                                      b'reponame prefix of PATH_INFO'):
             parse(DEFAULT_ENV, reponame=b'repo', extra={
                 r'PATH_INFO': r'/repoextra/path',
             })
 
         r = parse(DEFAULT_ENV, reponame=b'repo', extra={
             r'PATH_INFO': r'/repo/path1/path2',
         })
 
         self.assertEqual(r.url, b'http://testserver/repo/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://testserver/repo/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'/repo')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertEqual(r.reponame, b'repo')
 
         r = parse(DEFAULT_ENV, reponame=b'prefix/repo', extra={
             r'PATH_INFO': r'/prefix/repo/path1/path2',
         })
 
         self.assertEqual(r.url, b'http://testserver/prefix/repo/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl,
                          b'http://testserver/prefix/repo/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://testserver')
         self.assertEqual(r.apppath, b'/prefix/repo')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertEqual(r.reponame, b'prefix/repo')
 
     def testaltbaseurl(self):
         # Simple hostname remap.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver')
 
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://altserver')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
         self.assertIsNone(r.reponame)
 
         # With a custom port.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver:8000')
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://altserver:8000')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver:8000')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
         self.assertIsNone(r.reponame)
 
         # With a changed protocol.
         r = parse(DEFAULT_ENV, altbaseurl='https://altserver')
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'https://altserver')
         self.assertEqual(r.advertisedbaseurl, b'https://altserver')
         # URL scheme is defined as the actual scheme, not advertised.
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
         self.assertIsNone(r.reponame)
 
         # Need to specify explicit port number for proper https:// alt URLs.
         r = parse(DEFAULT_ENV, altbaseurl='https://altserver:443')
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'https://altserver')
         self.assertEqual(r.advertisedbaseurl, b'https://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
         self.assertIsNone(r.reponame)
 
         # With only PATH_INFO defined.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver', extra={
             r'PATH_INFO': r'/path1/path2',
         })
         self.assertEqual(r.url, b'http://testserver/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertIsNone(r.reponame)
 
         # Path on alt URL.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath')
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://altserver/altpath')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'/altpath')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
         self.assertIsNone(r.reponame)
 
         # With a trailing slash.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath/')
         self.assertEqual(r.url, b'http://testserver')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://altserver/altpath/')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'/altpath/')
         self.assertEqual(r.dispatchparts, [])
         self.assertIsNone(r.dispatchpath)
         self.assertIsNone(r.reponame)
 
         # PATH_INFO + path on alt URL.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath', extra={
             r'PATH_INFO': r'/path1/path2',
         })
         self.assertEqual(r.url, b'http://testserver/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl,
                          b'http://altserver/altpath/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'/altpath')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertIsNone(r.reponame)
 
         # PATH_INFO + path on alt URL with trailing slash.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath/', extra={
             r'PATH_INFO': r'/path1/path2',
         })
         self.assertEqual(r.url, b'http://testserver/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl,
                          b'http://altserver/altpath//path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'/altpath/')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertIsNone(r.reponame)
 
         # Local SCRIPT_NAME is ignored.
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver', extra={
             r'SCRIPT_NAME': r'/script',
             r'PATH_INFO': r'/path1/path2',
         })
         self.assertEqual(r.url, b'http://testserver/script/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertIsNone(r.reponame)
 
         # Use remote's path for script name, app path
         r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altroot', extra={
             r'SCRIPT_NAME': r'/script',
             r'PATH_INFO': r'/path1/path2',
         })
         self.assertEqual(r.url, b'http://testserver/script/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl,
                          b'http://altserver/altroot/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.urlscheme, b'http')
         self.assertEqual(r.apppath, b'/altroot')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertIsNone(r.reponame)
 
         # reponame is factored in properly.
         r = parse(DEFAULT_ENV, reponame=b'repo',
                   altbaseurl='http://altserver/altroot',
                   extra={
                 r'SCRIPT_NAME': r'/script',
                 r'PATH_INFO': r'/repo/path1/path2',
             })
 
         self.assertEqual(r.url, b'http://testserver/script/repo/path1/path2')
         self.assertEqual(r.baseurl, b'http://testserver')
         self.assertEqual(r.advertisedurl,
                          b'http://altserver/altroot/repo/path1/path2')
         self.assertEqual(r.advertisedbaseurl, b'http://altserver')
         self.assertEqual(r.apppath, b'/altroot/repo')
         self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
         self.assertEqual(r.dispatchpath, b'path1/path2')
         self.assertEqual(r.reponame, b'repo')
 
 if __name__ == '__main__':
     import silenttestrunner
     silenttestrunner.main(__name__)