##// END OF EJS Templates
tests: support passing testcase after .t paths that have path separators...
Kyle Lippincott -
r41174:8ddc5d8b default
parent child Browse files
Show More
@@ -1,3302 +1,3303 b''
1 #!/usr/bin/env python
1 #!/usr/bin/env python
2 #
2 #
3 # run-tests.py - Run a set of tests on Mercurial
3 # run-tests.py - Run a set of tests on Mercurial
4 #
4 #
5 # Copyright 2006 Matt Mackall <mpm@selenic.com>
5 # Copyright 2006 Matt Mackall <mpm@selenic.com>
6 #
6 #
7 # This software may be used and distributed according to the terms of the
7 # This software may be used and distributed according to the terms of the
8 # GNU General Public License version 2 or any later version.
8 # GNU General Public License version 2 or any later version.
9
9
10 # Modifying this script is tricky because it has many modes:
10 # Modifying this script is tricky because it has many modes:
11 # - serial (default) vs parallel (-jN, N > 1)
11 # - serial (default) vs parallel (-jN, N > 1)
12 # - no coverage (default) vs coverage (-c, -C, -s)
12 # - no coverage (default) vs coverage (-c, -C, -s)
13 # - temp install (default) vs specific hg script (--with-hg, --local)
13 # - temp install (default) vs specific hg script (--with-hg, --local)
14 # - tests are a mix of shell scripts and Python scripts
14 # - tests are a mix of shell scripts and Python scripts
15 #
15 #
16 # If you change this script, it is recommended that you ensure you
16 # If you change this script, it is recommended that you ensure you
17 # haven't broken it by running it in various modes with a representative
17 # haven't broken it by running it in various modes with a representative
18 # sample of test scripts. For example:
18 # sample of test scripts. For example:
19 #
19 #
20 # 1) serial, no coverage, temp install:
20 # 1) serial, no coverage, temp install:
21 # ./run-tests.py test-s*
21 # ./run-tests.py test-s*
22 # 2) serial, no coverage, local hg:
22 # 2) serial, no coverage, local hg:
23 # ./run-tests.py --local test-s*
23 # ./run-tests.py --local test-s*
24 # 3) serial, coverage, temp install:
24 # 3) serial, coverage, temp install:
25 # ./run-tests.py -c test-s*
25 # ./run-tests.py -c test-s*
26 # 4) serial, coverage, local hg:
26 # 4) serial, coverage, local hg:
27 # ./run-tests.py -c --local test-s* # unsupported
27 # ./run-tests.py -c --local test-s* # unsupported
28 # 5) parallel, no coverage, temp install:
28 # 5) parallel, no coverage, temp install:
29 # ./run-tests.py -j2 test-s*
29 # ./run-tests.py -j2 test-s*
30 # 6) parallel, no coverage, local hg:
30 # 6) parallel, no coverage, local hg:
31 # ./run-tests.py -j2 --local test-s*
31 # ./run-tests.py -j2 --local test-s*
32 # 7) parallel, coverage, temp install:
32 # 7) parallel, coverage, temp install:
33 # ./run-tests.py -j2 -c test-s* # currently broken
33 # ./run-tests.py -j2 -c test-s* # currently broken
34 # 8) parallel, coverage, local install:
34 # 8) parallel, coverage, local install:
35 # ./run-tests.py -j2 -c --local test-s* # unsupported (and broken)
35 # ./run-tests.py -j2 -c --local test-s* # unsupported (and broken)
36 # 9) parallel, custom tmp dir:
36 # 9) parallel, custom tmp dir:
37 # ./run-tests.py -j2 --tmpdir /tmp/myhgtests
37 # ./run-tests.py -j2 --tmpdir /tmp/myhgtests
38 # 10) parallel, pure, tests that call run-tests:
38 # 10) parallel, pure, tests that call run-tests:
39 # ./run-tests.py --pure `grep -l run-tests.py *.t`
39 # ./run-tests.py --pure `grep -l run-tests.py *.t`
40 #
40 #
41 # (You could use any subset of the tests: test-s* happens to match
41 # (You could use any subset of the tests: test-s* happens to match
42 # enough that it's worth doing parallel runs, few enough that it
42 # enough that it's worth doing parallel runs, few enough that it
43 # completes fairly quickly, includes both shell and Python scripts, and
43 # completes fairly quickly, includes both shell and Python scripts, and
44 # includes some scripts that run daemon processes.)
44 # includes some scripts that run daemon processes.)
45
45
46 from __future__ import absolute_import, print_function
46 from __future__ import absolute_import, print_function
47
47
48 import argparse
48 import argparse
49 import collections
49 import collections
50 import difflib
50 import difflib
51 import distutils.version as version
51 import distutils.version as version
52 import errno
52 import errno
53 import json
53 import json
54 import multiprocessing
54 import multiprocessing
55 import os
55 import os
56 import random
56 import random
57 import re
57 import re
58 import shutil
58 import shutil
59 import signal
59 import signal
60 import socket
60 import socket
61 import subprocess
61 import subprocess
62 import sys
62 import sys
63 import sysconfig
63 import sysconfig
64 import tempfile
64 import tempfile
65 import threading
65 import threading
66 import time
66 import time
67 import unittest
67 import unittest
68 import uuid
68 import uuid
69 import xml.dom.minidom as minidom
69 import xml.dom.minidom as minidom
70
70
71 try:
71 try:
72 import Queue as queue
72 import Queue as queue
73 except ImportError:
73 except ImportError:
74 import queue
74 import queue
75
75
76 try:
76 try:
77 import shlex
77 import shlex
78 shellquote = shlex.quote
78 shellquote = shlex.quote
79 except (ImportError, AttributeError):
79 except (ImportError, AttributeError):
80 import pipes
80 import pipes
81 shellquote = pipes.quote
81 shellquote = pipes.quote
82
82
83 if os.environ.get('RTUNICODEPEDANTRY', False):
83 if os.environ.get('RTUNICODEPEDANTRY', False):
84 try:
84 try:
85 reload(sys)
85 reload(sys)
86 sys.setdefaultencoding("undefined")
86 sys.setdefaultencoding("undefined")
87 except NameError:
87 except NameError:
88 pass
88 pass
89
89
90 processlock = threading.Lock()
90 processlock = threading.Lock()
91
91
92 pygmentspresent = False
92 pygmentspresent = False
93 # ANSI color is unsupported prior to Windows 10
93 # ANSI color is unsupported prior to Windows 10
94 if os.name != 'nt':
94 if os.name != 'nt':
95 try: # is pygments installed
95 try: # is pygments installed
96 import pygments
96 import pygments
97 import pygments.lexers as lexers
97 import pygments.lexers as lexers
98 import pygments.lexer as lexer
98 import pygments.lexer as lexer
99 import pygments.formatters as formatters
99 import pygments.formatters as formatters
100 import pygments.token as token
100 import pygments.token as token
101 import pygments.style as style
101 import pygments.style as style
102 pygmentspresent = True
102 pygmentspresent = True
103 difflexer = lexers.DiffLexer()
103 difflexer = lexers.DiffLexer()
104 terminal256formatter = formatters.Terminal256Formatter()
104 terminal256formatter = formatters.Terminal256Formatter()
105 except ImportError:
105 except ImportError:
106 pass
106 pass
107
107
108 if pygmentspresent:
108 if pygmentspresent:
109 class TestRunnerStyle(style.Style):
109 class TestRunnerStyle(style.Style):
110 default_style = ""
110 default_style = ""
111 skipped = token.string_to_tokentype("Token.Generic.Skipped")
111 skipped = token.string_to_tokentype("Token.Generic.Skipped")
112 failed = token.string_to_tokentype("Token.Generic.Failed")
112 failed = token.string_to_tokentype("Token.Generic.Failed")
113 skippedname = token.string_to_tokentype("Token.Generic.SName")
113 skippedname = token.string_to_tokentype("Token.Generic.SName")
114 failedname = token.string_to_tokentype("Token.Generic.FName")
114 failedname = token.string_to_tokentype("Token.Generic.FName")
115 styles = {
115 styles = {
116 skipped: '#e5e5e5',
116 skipped: '#e5e5e5',
117 skippedname: '#00ffff',
117 skippedname: '#00ffff',
118 failed: '#7f0000',
118 failed: '#7f0000',
119 failedname: '#ff0000',
119 failedname: '#ff0000',
120 }
120 }
121
121
122 class TestRunnerLexer(lexer.RegexLexer):
122 class TestRunnerLexer(lexer.RegexLexer):
123 testpattern = r'[\w-]+\.(t|py)(#[a-zA-Z0-9_\-\.]+)?'
123 testpattern = r'[\w-]+\.(t|py)(#[a-zA-Z0-9_\-\.]+)?'
124 tokens = {
124 tokens = {
125 'root': [
125 'root': [
126 (r'^Skipped', token.Generic.Skipped, 'skipped'),
126 (r'^Skipped', token.Generic.Skipped, 'skipped'),
127 (r'^Failed ', token.Generic.Failed, 'failed'),
127 (r'^Failed ', token.Generic.Failed, 'failed'),
128 (r'^ERROR: ', token.Generic.Failed, 'failed'),
128 (r'^ERROR: ', token.Generic.Failed, 'failed'),
129 ],
129 ],
130 'skipped': [
130 'skipped': [
131 (testpattern, token.Generic.SName),
131 (testpattern, token.Generic.SName),
132 (r':.*', token.Generic.Skipped),
132 (r':.*', token.Generic.Skipped),
133 ],
133 ],
134 'failed': [
134 'failed': [
135 (testpattern, token.Generic.FName),
135 (testpattern, token.Generic.FName),
136 (r'(:| ).*', token.Generic.Failed),
136 (r'(:| ).*', token.Generic.Failed),
137 ]
137 ]
138 }
138 }
139
139
140 runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle)
140 runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle)
141 runnerlexer = TestRunnerLexer()
141 runnerlexer = TestRunnerLexer()
142
142
143 origenviron = os.environ.copy()
143 origenviron = os.environ.copy()
144
144
145 if sys.version_info > (3, 5, 0):
145 if sys.version_info > (3, 5, 0):
146 PYTHON3 = True
146 PYTHON3 = True
147 xrange = range # we use xrange in one place, and we'd rather not use range
147 xrange = range # we use xrange in one place, and we'd rather not use range
148 def _bytespath(p):
148 def _bytespath(p):
149 if p is None:
149 if p is None:
150 return p
150 return p
151 return p.encode('utf-8')
151 return p.encode('utf-8')
152
152
153 def _strpath(p):
153 def _strpath(p):
154 if p is None:
154 if p is None:
155 return p
155 return p
156 return p.decode('utf-8')
156 return p.decode('utf-8')
157
157
158 osenvironb = getattr(os, 'environb', None)
158 osenvironb = getattr(os, 'environb', None)
159 if osenvironb is None:
159 if osenvironb is None:
160 # Windows lacks os.environb, for instance. A proxy over the real thing
160 # Windows lacks os.environb, for instance. A proxy over the real thing
161 # instead of a copy allows the environment to be updated via bytes on
161 # instead of a copy allows the environment to be updated via bytes on
162 # all platforms.
162 # all platforms.
163 class environbytes(object):
163 class environbytes(object):
164 def __init__(self, strenv):
164 def __init__(self, strenv):
165 self.__len__ = strenv.__len__
165 self.__len__ = strenv.__len__
166 self.clear = strenv.clear
166 self.clear = strenv.clear
167 self._strenv = strenv
167 self._strenv = strenv
168 def __getitem__(self, k):
168 def __getitem__(self, k):
169 v = self._strenv.__getitem__(_strpath(k))
169 v = self._strenv.__getitem__(_strpath(k))
170 return _bytespath(v)
170 return _bytespath(v)
171 def __setitem__(self, k, v):
171 def __setitem__(self, k, v):
172 self._strenv.__setitem__(_strpath(k), _strpath(v))
172 self._strenv.__setitem__(_strpath(k), _strpath(v))
173 def __delitem__(self, k):
173 def __delitem__(self, k):
174 self._strenv.__delitem__(_strpath(k))
174 self._strenv.__delitem__(_strpath(k))
175 def __contains__(self, k):
175 def __contains__(self, k):
176 return self._strenv.__contains__(_strpath(k))
176 return self._strenv.__contains__(_strpath(k))
177 def __iter__(self):
177 def __iter__(self):
178 return iter([_bytespath(k) for k in iter(self._strenv)])
178 return iter([_bytespath(k) for k in iter(self._strenv)])
179 def get(self, k, default=None):
179 def get(self, k, default=None):
180 v = self._strenv.get(_strpath(k), _strpath(default))
180 v = self._strenv.get(_strpath(k), _strpath(default))
181 return _bytespath(v)
181 return _bytespath(v)
182 def pop(self, k, default=None):
182 def pop(self, k, default=None):
183 v = self._strenv.pop(_strpath(k), _strpath(default))
183 v = self._strenv.pop(_strpath(k), _strpath(default))
184 return _bytespath(v)
184 return _bytespath(v)
185
185
186 osenvironb = environbytes(os.environ)
186 osenvironb = environbytes(os.environ)
187
187
188 getcwdb = getattr(os, 'getcwdb')
188 getcwdb = getattr(os, 'getcwdb')
189 if not getcwdb or os.name == 'nt':
189 if not getcwdb or os.name == 'nt':
190 getcwdb = lambda: _bytespath(os.getcwd())
190 getcwdb = lambda: _bytespath(os.getcwd())
191
191
192 elif sys.version_info >= (3, 0, 0):
192 elif sys.version_info >= (3, 0, 0):
193 print('%s is only supported on Python 3.5+ and 2.7, not %s' %
193 print('%s is only supported on Python 3.5+ and 2.7, not %s' %
194 (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3])))
194 (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3])))
195 sys.exit(70) # EX_SOFTWARE from `man 3 sysexit`
195 sys.exit(70) # EX_SOFTWARE from `man 3 sysexit`
196 else:
196 else:
197 PYTHON3 = False
197 PYTHON3 = False
198
198
199 # In python 2.x, path operations are generally done using
199 # In python 2.x, path operations are generally done using
200 # bytestrings by default, so we don't have to do any extra
200 # bytestrings by default, so we don't have to do any extra
201 # fiddling there. We define the wrapper functions anyway just to
201 # fiddling there. We define the wrapper functions anyway just to
202 # help keep code consistent between platforms.
202 # help keep code consistent between platforms.
203 def _bytespath(p):
203 def _bytespath(p):
204 return p
204 return p
205
205
206 _strpath = _bytespath
206 _strpath = _bytespath
207 osenvironb = os.environ
207 osenvironb = os.environ
208 getcwdb = os.getcwd
208 getcwdb = os.getcwd
209
209
210 # For Windows support
210 # For Windows support
211 wifexited = getattr(os, "WIFEXITED", lambda x: False)
211 wifexited = getattr(os, "WIFEXITED", lambda x: False)
212
212
213 # Whether to use IPv6
213 # Whether to use IPv6
214 def checksocketfamily(name, port=20058):
214 def checksocketfamily(name, port=20058):
215 """return true if we can listen on localhost using family=name
215 """return true if we can listen on localhost using family=name
216
216
217 name should be either 'AF_INET', or 'AF_INET6'.
217 name should be either 'AF_INET', or 'AF_INET6'.
218 port being used is okay - EADDRINUSE is considered as successful.
218 port being used is okay - EADDRINUSE is considered as successful.
219 """
219 """
220 family = getattr(socket, name, None)
220 family = getattr(socket, name, None)
221 if family is None:
221 if family is None:
222 return False
222 return False
223 try:
223 try:
224 s = socket.socket(family, socket.SOCK_STREAM)
224 s = socket.socket(family, socket.SOCK_STREAM)
225 s.bind(('localhost', port))
225 s.bind(('localhost', port))
226 s.close()
226 s.close()
227 return True
227 return True
228 except socket.error as exc:
228 except socket.error as exc:
229 if exc.errno == errno.EADDRINUSE:
229 if exc.errno == errno.EADDRINUSE:
230 return True
230 return True
231 elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT):
231 elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT):
232 return False
232 return False
233 else:
233 else:
234 raise
234 raise
235 else:
235 else:
236 return False
236 return False
237
237
238 # useipv6 will be set by parseargs
238 # useipv6 will be set by parseargs
239 useipv6 = None
239 useipv6 = None
240
240
241 def checkportisavailable(port):
241 def checkportisavailable(port):
242 """return true if a port seems free to bind on localhost"""
242 """return true if a port seems free to bind on localhost"""
243 if useipv6:
243 if useipv6:
244 family = socket.AF_INET6
244 family = socket.AF_INET6
245 else:
245 else:
246 family = socket.AF_INET
246 family = socket.AF_INET
247 try:
247 try:
248 s = socket.socket(family, socket.SOCK_STREAM)
248 s = socket.socket(family, socket.SOCK_STREAM)
249 s.bind(('localhost', port))
249 s.bind(('localhost', port))
250 s.close()
250 s.close()
251 return True
251 return True
252 except socket.error as exc:
252 except socket.error as exc:
253 if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL,
253 if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL,
254 errno.EPROTONOSUPPORT):
254 errno.EPROTONOSUPPORT):
255 raise
255 raise
256 return False
256 return False
257
257
258 closefds = os.name == 'posix'
258 closefds = os.name == 'posix'
259 def Popen4(cmd, wd, timeout, env=None):
259 def Popen4(cmd, wd, timeout, env=None):
260 processlock.acquire()
260 processlock.acquire()
261 p = subprocess.Popen(_strpath(cmd), shell=True, bufsize=-1,
261 p = subprocess.Popen(_strpath(cmd), shell=True, bufsize=-1,
262 cwd=_strpath(wd), env=env,
262 cwd=_strpath(wd), env=env,
263 close_fds=closefds,
263 close_fds=closefds,
264 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
264 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
265 stderr=subprocess.STDOUT)
265 stderr=subprocess.STDOUT)
266 processlock.release()
266 processlock.release()
267
267
268 p.fromchild = p.stdout
268 p.fromchild = p.stdout
269 p.tochild = p.stdin
269 p.tochild = p.stdin
270 p.childerr = p.stderr
270 p.childerr = p.stderr
271
271
272 p.timeout = False
272 p.timeout = False
273 if timeout:
273 if timeout:
274 def t():
274 def t():
275 start = time.time()
275 start = time.time()
276 while time.time() - start < timeout and p.returncode is None:
276 while time.time() - start < timeout and p.returncode is None:
277 time.sleep(.1)
277 time.sleep(.1)
278 p.timeout = True
278 p.timeout = True
279 if p.returncode is None:
279 if p.returncode is None:
280 terminate(p)
280 terminate(p)
281 threading.Thread(target=t).start()
281 threading.Thread(target=t).start()
282
282
283 return p
283 return p
284
284
285 PYTHON = _bytespath(sys.executable.replace('\\', '/'))
285 PYTHON = _bytespath(sys.executable.replace('\\', '/'))
286 IMPL_PATH = b'PYTHONPATH'
286 IMPL_PATH = b'PYTHONPATH'
287 if 'java' in sys.platform:
287 if 'java' in sys.platform:
288 IMPL_PATH = b'JYTHONPATH'
288 IMPL_PATH = b'JYTHONPATH'
289
289
290 defaults = {
290 defaults = {
291 'jobs': ('HGTEST_JOBS', multiprocessing.cpu_count()),
291 'jobs': ('HGTEST_JOBS', multiprocessing.cpu_count()),
292 'timeout': ('HGTEST_TIMEOUT', 180),
292 'timeout': ('HGTEST_TIMEOUT', 180),
293 'slowtimeout': ('HGTEST_SLOWTIMEOUT', 500),
293 'slowtimeout': ('HGTEST_SLOWTIMEOUT', 500),
294 'port': ('HGTEST_PORT', 20059),
294 'port': ('HGTEST_PORT', 20059),
295 'shell': ('HGTEST_SHELL', 'sh'),
295 'shell': ('HGTEST_SHELL', 'sh'),
296 }
296 }
297
297
298 def canonpath(path):
298 def canonpath(path):
299 return os.path.realpath(os.path.expanduser(path))
299 return os.path.realpath(os.path.expanduser(path))
300
300
301 def parselistfiles(files, listtype, warn=True):
301 def parselistfiles(files, listtype, warn=True):
302 entries = dict()
302 entries = dict()
303 for filename in files:
303 for filename in files:
304 try:
304 try:
305 path = os.path.expanduser(os.path.expandvars(filename))
305 path = os.path.expanduser(os.path.expandvars(filename))
306 f = open(path, "rb")
306 f = open(path, "rb")
307 except IOError as err:
307 except IOError as err:
308 if err.errno != errno.ENOENT:
308 if err.errno != errno.ENOENT:
309 raise
309 raise
310 if warn:
310 if warn:
311 print("warning: no such %s file: %s" % (listtype, filename))
311 print("warning: no such %s file: %s" % (listtype, filename))
312 continue
312 continue
313
313
314 for line in f.readlines():
314 for line in f.readlines():
315 line = line.split(b'#', 1)[0].strip()
315 line = line.split(b'#', 1)[0].strip()
316 if line:
316 if line:
317 entries[line] = filename
317 entries[line] = filename
318
318
319 f.close()
319 f.close()
320 return entries
320 return entries
321
321
322 def parsettestcases(path):
322 def parsettestcases(path):
323 """read a .t test file, return a set of test case names
323 """read a .t test file, return a set of test case names
324
324
325 If path does not exist, return an empty set.
325 If path does not exist, return an empty set.
326 """
326 """
327 cases = []
327 cases = []
328 try:
328 try:
329 with open(path, 'rb') as f:
329 with open(path, 'rb') as f:
330 for l in f:
330 for l in f:
331 if l.startswith(b'#testcases '):
331 if l.startswith(b'#testcases '):
332 cases.append(sorted(l[11:].split()))
332 cases.append(sorted(l[11:].split()))
333 except IOError as ex:
333 except IOError as ex:
334 if ex.errno != errno.ENOENT:
334 if ex.errno != errno.ENOENT:
335 raise
335 raise
336 return cases
336 return cases
337
337
338 def getparser():
338 def getparser():
339 """Obtain the OptionParser used by the CLI."""
339 """Obtain the OptionParser used by the CLI."""
340 parser = argparse.ArgumentParser(usage='%(prog)s [options] [tests]')
340 parser = argparse.ArgumentParser(usage='%(prog)s [options] [tests]')
341
341
342 selection = parser.add_argument_group('Test Selection')
342 selection = parser.add_argument_group('Test Selection')
343 selection.add_argument('--allow-slow-tests', action='store_true',
343 selection.add_argument('--allow-slow-tests', action='store_true',
344 help='allow extremely slow tests')
344 help='allow extremely slow tests')
345 selection.add_argument("--blacklist", action="append",
345 selection.add_argument("--blacklist", action="append",
346 help="skip tests listed in the specified blacklist file")
346 help="skip tests listed in the specified blacklist file")
347 selection.add_argument("--changed",
347 selection.add_argument("--changed",
348 help="run tests that are changed in parent rev or working directory")
348 help="run tests that are changed in parent rev or working directory")
349 selection.add_argument("-k", "--keywords",
349 selection.add_argument("-k", "--keywords",
350 help="run tests matching keywords")
350 help="run tests matching keywords")
351 selection.add_argument("-r", "--retest", action="store_true",
351 selection.add_argument("-r", "--retest", action="store_true",
352 help = "retest failed tests")
352 help = "retest failed tests")
353 selection.add_argument("--test-list", action="append",
353 selection.add_argument("--test-list", action="append",
354 help="read tests to run from the specified file")
354 help="read tests to run from the specified file")
355 selection.add_argument("--whitelist", action="append",
355 selection.add_argument("--whitelist", action="append",
356 help="always run tests listed in the specified whitelist file")
356 help="always run tests listed in the specified whitelist file")
357 selection.add_argument('tests', metavar='TESTS', nargs='*',
357 selection.add_argument('tests', metavar='TESTS', nargs='*',
358 help='Tests to run')
358 help='Tests to run')
359
359
360 harness = parser.add_argument_group('Test Harness Behavior')
360 harness = parser.add_argument_group('Test Harness Behavior')
361 harness.add_argument('--bisect-repo',
361 harness.add_argument('--bisect-repo',
362 metavar='bisect_repo',
362 metavar='bisect_repo',
363 help=("Path of a repo to bisect. Use together with "
363 help=("Path of a repo to bisect. Use together with "
364 "--known-good-rev"))
364 "--known-good-rev"))
365 harness.add_argument("-d", "--debug", action="store_true",
365 harness.add_argument("-d", "--debug", action="store_true",
366 help="debug mode: write output of test scripts to console"
366 help="debug mode: write output of test scripts to console"
367 " rather than capturing and diffing it (disables timeout)")
367 " rather than capturing and diffing it (disables timeout)")
368 harness.add_argument("-f", "--first", action="store_true",
368 harness.add_argument("-f", "--first", action="store_true",
369 help="exit on the first test failure")
369 help="exit on the first test failure")
370 harness.add_argument("-i", "--interactive", action="store_true",
370 harness.add_argument("-i", "--interactive", action="store_true",
371 help="prompt to accept changed output")
371 help="prompt to accept changed output")
372 harness.add_argument("-j", "--jobs", type=int,
372 harness.add_argument("-j", "--jobs", type=int,
373 help="number of jobs to run in parallel"
373 help="number of jobs to run in parallel"
374 " (default: $%s or %d)" % defaults['jobs'])
374 " (default: $%s or %d)" % defaults['jobs'])
375 harness.add_argument("--keep-tmpdir", action="store_true",
375 harness.add_argument("--keep-tmpdir", action="store_true",
376 help="keep temporary directory after running tests")
376 help="keep temporary directory after running tests")
377 harness.add_argument('--known-good-rev',
377 harness.add_argument('--known-good-rev',
378 metavar="known_good_rev",
378 metavar="known_good_rev",
379 help=("Automatically bisect any failures using this "
379 help=("Automatically bisect any failures using this "
380 "revision as a known-good revision."))
380 "revision as a known-good revision."))
381 harness.add_argument("--list-tests", action="store_true",
381 harness.add_argument("--list-tests", action="store_true",
382 help="list tests instead of running them")
382 help="list tests instead of running them")
383 harness.add_argument("--loop", action="store_true",
383 harness.add_argument("--loop", action="store_true",
384 help="loop tests repeatedly")
384 help="loop tests repeatedly")
385 harness.add_argument('--random', action="store_true",
385 harness.add_argument('--random', action="store_true",
386 help='run tests in random order')
386 help='run tests in random order')
387 harness.add_argument('--order-by-runtime', action="store_true",
387 harness.add_argument('--order-by-runtime', action="store_true",
388 help='run slowest tests first, according to .testtimes')
388 help='run slowest tests first, according to .testtimes')
389 harness.add_argument("-p", "--port", type=int,
389 harness.add_argument("-p", "--port", type=int,
390 help="port on which servers should listen"
390 help="port on which servers should listen"
391 " (default: $%s or %d)" % defaults['port'])
391 " (default: $%s or %d)" % defaults['port'])
392 harness.add_argument('--profile-runner', action='store_true',
392 harness.add_argument('--profile-runner', action='store_true',
393 help='run statprof on run-tests')
393 help='run statprof on run-tests')
394 harness.add_argument("-R", "--restart", action="store_true",
394 harness.add_argument("-R", "--restart", action="store_true",
395 help="restart at last error")
395 help="restart at last error")
396 harness.add_argument("--runs-per-test", type=int, dest="runs_per_test",
396 harness.add_argument("--runs-per-test", type=int, dest="runs_per_test",
397 help="run each test N times (default=1)", default=1)
397 help="run each test N times (default=1)", default=1)
398 harness.add_argument("--shell",
398 harness.add_argument("--shell",
399 help="shell to use (default: $%s or %s)" % defaults['shell'])
399 help="shell to use (default: $%s or %s)" % defaults['shell'])
400 harness.add_argument('--showchannels', action='store_true',
400 harness.add_argument('--showchannels', action='store_true',
401 help='show scheduling channels')
401 help='show scheduling channels')
402 harness.add_argument("--slowtimeout", type=int,
402 harness.add_argument("--slowtimeout", type=int,
403 help="kill errant slow tests after SLOWTIMEOUT seconds"
403 help="kill errant slow tests after SLOWTIMEOUT seconds"
404 " (default: $%s or %d)" % defaults['slowtimeout'])
404 " (default: $%s or %d)" % defaults['slowtimeout'])
405 harness.add_argument("-t", "--timeout", type=int,
405 harness.add_argument("-t", "--timeout", type=int,
406 help="kill errant tests after TIMEOUT seconds"
406 help="kill errant tests after TIMEOUT seconds"
407 " (default: $%s or %d)" % defaults['timeout'])
407 " (default: $%s or %d)" % defaults['timeout'])
408 harness.add_argument("--tmpdir",
408 harness.add_argument("--tmpdir",
409 help="run tests in the given temporary directory"
409 help="run tests in the given temporary directory"
410 " (implies --keep-tmpdir)")
410 " (implies --keep-tmpdir)")
411 harness.add_argument("-v", "--verbose", action="store_true",
411 harness.add_argument("-v", "--verbose", action="store_true",
412 help="output verbose messages")
412 help="output verbose messages")
413
413
414 hgconf = parser.add_argument_group('Mercurial Configuration')
414 hgconf = parser.add_argument_group('Mercurial Configuration')
415 hgconf.add_argument("--chg", action="store_true",
415 hgconf.add_argument("--chg", action="store_true",
416 help="install and use chg wrapper in place of hg")
416 help="install and use chg wrapper in place of hg")
417 hgconf.add_argument("--compiler",
417 hgconf.add_argument("--compiler",
418 help="compiler to build with")
418 help="compiler to build with")
419 hgconf.add_argument('--extra-config-opt', action="append", default=[],
419 hgconf.add_argument('--extra-config-opt', action="append", default=[],
420 help='set the given config opt in the test hgrc')
420 help='set the given config opt in the test hgrc')
421 hgconf.add_argument("-l", "--local", action="store_true",
421 hgconf.add_argument("-l", "--local", action="store_true",
422 help="shortcut for --with-hg=<testdir>/../hg, "
422 help="shortcut for --with-hg=<testdir>/../hg, "
423 "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set")
423 "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set")
424 hgconf.add_argument("--ipv6", action="store_true",
424 hgconf.add_argument("--ipv6", action="store_true",
425 help="prefer IPv6 to IPv4 for network related tests")
425 help="prefer IPv6 to IPv4 for network related tests")
426 hgconf.add_argument("--pure", action="store_true",
426 hgconf.add_argument("--pure", action="store_true",
427 help="use pure Python code instead of C extensions")
427 help="use pure Python code instead of C extensions")
428 hgconf.add_argument("-3", "--py3-warnings", action="store_true",
428 hgconf.add_argument("-3", "--py3-warnings", action="store_true",
429 help="enable Py3k warnings on Python 2.7+")
429 help="enable Py3k warnings on Python 2.7+")
430 hgconf.add_argument("--with-chg", metavar="CHG",
430 hgconf.add_argument("--with-chg", metavar="CHG",
431 help="use specified chg wrapper in place of hg")
431 help="use specified chg wrapper in place of hg")
432 hgconf.add_argument("--with-hg",
432 hgconf.add_argument("--with-hg",
433 metavar="HG",
433 metavar="HG",
434 help="test using specified hg script rather than a "
434 help="test using specified hg script rather than a "
435 "temporary installation")
435 "temporary installation")
436
436
437 reporting = parser.add_argument_group('Results Reporting')
437 reporting = parser.add_argument_group('Results Reporting')
438 reporting.add_argument("-C", "--annotate", action="store_true",
438 reporting.add_argument("-C", "--annotate", action="store_true",
439 help="output files annotated with coverage")
439 help="output files annotated with coverage")
440 reporting.add_argument("--color", choices=["always", "auto", "never"],
440 reporting.add_argument("--color", choices=["always", "auto", "never"],
441 default=os.environ.get('HGRUNTESTSCOLOR', 'auto'),
441 default=os.environ.get('HGRUNTESTSCOLOR', 'auto'),
442 help="colorisation: always|auto|never (default: auto)")
442 help="colorisation: always|auto|never (default: auto)")
443 reporting.add_argument("-c", "--cover", action="store_true",
443 reporting.add_argument("-c", "--cover", action="store_true",
444 help="print a test coverage report")
444 help="print a test coverage report")
445 reporting.add_argument('--exceptions', action='store_true',
445 reporting.add_argument('--exceptions', action='store_true',
446 help='log all exceptions and generate an exception report')
446 help='log all exceptions and generate an exception report')
447 reporting.add_argument("-H", "--htmlcov", action="store_true",
447 reporting.add_argument("-H", "--htmlcov", action="store_true",
448 help="create an HTML report of the coverage of the files")
448 help="create an HTML report of the coverage of the files")
449 reporting.add_argument("--json", action="store_true",
449 reporting.add_argument("--json", action="store_true",
450 help="store test result data in 'report.json' file")
450 help="store test result data in 'report.json' file")
451 reporting.add_argument("--outputdir",
451 reporting.add_argument("--outputdir",
452 help="directory to write error logs to (default=test directory)")
452 help="directory to write error logs to (default=test directory)")
453 reporting.add_argument("-n", "--nodiff", action="store_true",
453 reporting.add_argument("-n", "--nodiff", action="store_true",
454 help="skip showing test changes")
454 help="skip showing test changes")
455 reporting.add_argument("-S", "--noskips", action="store_true",
455 reporting.add_argument("-S", "--noskips", action="store_true",
456 help="don't report skip tests verbosely")
456 help="don't report skip tests verbosely")
457 reporting.add_argument("--time", action="store_true",
457 reporting.add_argument("--time", action="store_true",
458 help="time how long each test takes")
458 help="time how long each test takes")
459 reporting.add_argument("--view",
459 reporting.add_argument("--view",
460 help="external diff viewer")
460 help="external diff viewer")
461 reporting.add_argument("--xunit",
461 reporting.add_argument("--xunit",
462 help="record xunit results at specified path")
462 help="record xunit results at specified path")
463
463
464 for option, (envvar, default) in defaults.items():
464 for option, (envvar, default) in defaults.items():
465 defaults[option] = type(default)(os.environ.get(envvar, default))
465 defaults[option] = type(default)(os.environ.get(envvar, default))
466 parser.set_defaults(**defaults)
466 parser.set_defaults(**defaults)
467
467
468 return parser
468 return parser
469
469
470 def parseargs(args, parser):
470 def parseargs(args, parser):
471 """Parse arguments with our OptionParser and validate results."""
471 """Parse arguments with our OptionParser and validate results."""
472 options = parser.parse_args(args)
472 options = parser.parse_args(args)
473
473
474 # jython is always pure
474 # jython is always pure
475 if 'java' in sys.platform or '__pypy__' in sys.modules:
475 if 'java' in sys.platform or '__pypy__' in sys.modules:
476 options.pure = True
476 options.pure = True
477
477
478 if options.with_hg:
478 if options.with_hg:
479 options.with_hg = canonpath(_bytespath(options.with_hg))
479 options.with_hg = canonpath(_bytespath(options.with_hg))
480 if not (os.path.isfile(options.with_hg) and
480 if not (os.path.isfile(options.with_hg) and
481 os.access(options.with_hg, os.X_OK)):
481 os.access(options.with_hg, os.X_OK)):
482 parser.error('--with-hg must specify an executable hg script')
482 parser.error('--with-hg must specify an executable hg script')
483 if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']:
483 if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']:
484 sys.stderr.write('warning: --with-hg should specify an hg script\n')
484 sys.stderr.write('warning: --with-hg should specify an hg script\n')
485 sys.stderr.flush()
485 sys.stderr.flush()
486 if options.local:
486 if options.local:
487 testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0])))
487 testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0])))
488 reporootdir = os.path.dirname(testdir)
488 reporootdir = os.path.dirname(testdir)
489 pathandattrs = [(b'hg', 'with_hg')]
489 pathandattrs = [(b'hg', 'with_hg')]
490 if options.chg:
490 if options.chg:
491 pathandattrs.append((b'contrib/chg/chg', 'with_chg'))
491 pathandattrs.append((b'contrib/chg/chg', 'with_chg'))
492 for relpath, attr in pathandattrs:
492 for relpath, attr in pathandattrs:
493 binpath = os.path.join(reporootdir, relpath)
493 binpath = os.path.join(reporootdir, relpath)
494 if os.name != 'nt' and not os.access(binpath, os.X_OK):
494 if os.name != 'nt' and not os.access(binpath, os.X_OK):
495 parser.error('--local specified, but %r not found or '
495 parser.error('--local specified, but %r not found or '
496 'not executable' % binpath)
496 'not executable' % binpath)
497 setattr(options, attr, binpath)
497 setattr(options, attr, binpath)
498
498
499 if (options.chg or options.with_chg) and os.name == 'nt':
499 if (options.chg or options.with_chg) and os.name == 'nt':
500 parser.error('chg does not work on %s' % os.name)
500 parser.error('chg does not work on %s' % os.name)
501 if options.with_chg:
501 if options.with_chg:
502 options.chg = False # no installation to temporary location
502 options.chg = False # no installation to temporary location
503 options.with_chg = canonpath(_bytespath(options.with_chg))
503 options.with_chg = canonpath(_bytespath(options.with_chg))
504 if not (os.path.isfile(options.with_chg) and
504 if not (os.path.isfile(options.with_chg) and
505 os.access(options.with_chg, os.X_OK)):
505 os.access(options.with_chg, os.X_OK)):
506 parser.error('--with-chg must specify a chg executable')
506 parser.error('--with-chg must specify a chg executable')
507 if options.chg and options.with_hg:
507 if options.chg and options.with_hg:
508 # chg shares installation location with hg
508 # chg shares installation location with hg
509 parser.error('--chg does not work when --with-hg is specified '
509 parser.error('--chg does not work when --with-hg is specified '
510 '(use --with-chg instead)')
510 '(use --with-chg instead)')
511
511
512 if options.color == 'always' and not pygmentspresent:
512 if options.color == 'always' and not pygmentspresent:
513 sys.stderr.write('warning: --color=always ignored because '
513 sys.stderr.write('warning: --color=always ignored because '
514 'pygments is not installed\n')
514 'pygments is not installed\n')
515
515
516 if options.bisect_repo and not options.known_good_rev:
516 if options.bisect_repo and not options.known_good_rev:
517 parser.error("--bisect-repo cannot be used without --known-good-rev")
517 parser.error("--bisect-repo cannot be used without --known-good-rev")
518
518
519 global useipv6
519 global useipv6
520 if options.ipv6:
520 if options.ipv6:
521 useipv6 = checksocketfamily('AF_INET6')
521 useipv6 = checksocketfamily('AF_INET6')
522 else:
522 else:
523 # only use IPv6 if IPv4 is unavailable and IPv6 is available
523 # only use IPv6 if IPv4 is unavailable and IPv6 is available
524 useipv6 = ((not checksocketfamily('AF_INET'))
524 useipv6 = ((not checksocketfamily('AF_INET'))
525 and checksocketfamily('AF_INET6'))
525 and checksocketfamily('AF_INET6'))
526
526
527 options.anycoverage = options.cover or options.annotate or options.htmlcov
527 options.anycoverage = options.cover or options.annotate or options.htmlcov
528 if options.anycoverage:
528 if options.anycoverage:
529 try:
529 try:
530 import coverage
530 import coverage
531 covver = version.StrictVersion(coverage.__version__).version
531 covver = version.StrictVersion(coverage.__version__).version
532 if covver < (3, 3):
532 if covver < (3, 3):
533 parser.error('coverage options require coverage 3.3 or later')
533 parser.error('coverage options require coverage 3.3 or later')
534 except ImportError:
534 except ImportError:
535 parser.error('coverage options now require the coverage package')
535 parser.error('coverage options now require the coverage package')
536
536
537 if options.anycoverage and options.local:
537 if options.anycoverage and options.local:
538 # this needs some path mangling somewhere, I guess
538 # this needs some path mangling somewhere, I guess
539 parser.error("sorry, coverage options do not work when --local "
539 parser.error("sorry, coverage options do not work when --local "
540 "is specified")
540 "is specified")
541
541
542 if options.anycoverage and options.with_hg:
542 if options.anycoverage and options.with_hg:
543 parser.error("sorry, coverage options do not work when --with-hg "
543 parser.error("sorry, coverage options do not work when --with-hg "
544 "is specified")
544 "is specified")
545
545
546 global verbose
546 global verbose
547 if options.verbose:
547 if options.verbose:
548 verbose = ''
548 verbose = ''
549
549
550 if options.tmpdir:
550 if options.tmpdir:
551 options.tmpdir = canonpath(options.tmpdir)
551 options.tmpdir = canonpath(options.tmpdir)
552
552
553 if options.jobs < 1:
553 if options.jobs < 1:
554 parser.error('--jobs must be positive')
554 parser.error('--jobs must be positive')
555 if options.interactive and options.debug:
555 if options.interactive and options.debug:
556 parser.error("-i/--interactive and -d/--debug are incompatible")
556 parser.error("-i/--interactive and -d/--debug are incompatible")
557 if options.debug:
557 if options.debug:
558 if options.timeout != defaults['timeout']:
558 if options.timeout != defaults['timeout']:
559 sys.stderr.write(
559 sys.stderr.write(
560 'warning: --timeout option ignored with --debug\n')
560 'warning: --timeout option ignored with --debug\n')
561 if options.slowtimeout != defaults['slowtimeout']:
561 if options.slowtimeout != defaults['slowtimeout']:
562 sys.stderr.write(
562 sys.stderr.write(
563 'warning: --slowtimeout option ignored with --debug\n')
563 'warning: --slowtimeout option ignored with --debug\n')
564 options.timeout = 0
564 options.timeout = 0
565 options.slowtimeout = 0
565 options.slowtimeout = 0
566 if options.py3_warnings:
566 if options.py3_warnings:
567 if PYTHON3:
567 if PYTHON3:
568 parser.error(
568 parser.error(
569 '--py3-warnings can only be used on Python 2.7')
569 '--py3-warnings can only be used on Python 2.7')
570
570
571 if options.blacklist:
571 if options.blacklist:
572 options.blacklist = parselistfiles(options.blacklist, 'blacklist')
572 options.blacklist = parselistfiles(options.blacklist, 'blacklist')
573 if options.whitelist:
573 if options.whitelist:
574 options.whitelisted = parselistfiles(options.whitelist, 'whitelist')
574 options.whitelisted = parselistfiles(options.whitelist, 'whitelist')
575 else:
575 else:
576 options.whitelisted = {}
576 options.whitelisted = {}
577
577
578 if options.showchannels:
578 if options.showchannels:
579 options.nodiff = True
579 options.nodiff = True
580
580
581 return options
581 return options
582
582
583 def rename(src, dst):
583 def rename(src, dst):
584 """Like os.rename(), trade atomicity and opened files friendliness
584 """Like os.rename(), trade atomicity and opened files friendliness
585 for existing destination support.
585 for existing destination support.
586 """
586 """
587 shutil.copy(src, dst)
587 shutil.copy(src, dst)
588 os.remove(src)
588 os.remove(src)
589
589
590 def makecleanable(path):
590 def makecleanable(path):
591 """Try to fix directory permission recursively so that the entire tree
591 """Try to fix directory permission recursively so that the entire tree
592 can be deleted"""
592 can be deleted"""
593 for dirpath, dirnames, _filenames in os.walk(path, topdown=True):
593 for dirpath, dirnames, _filenames in os.walk(path, topdown=True):
594 for d in dirnames:
594 for d in dirnames:
595 p = os.path.join(dirpath, d)
595 p = os.path.join(dirpath, d)
596 try:
596 try:
597 os.chmod(p, os.stat(p).st_mode & 0o777 | 0o700) # chmod u+rwx
597 os.chmod(p, os.stat(p).st_mode & 0o777 | 0o700) # chmod u+rwx
598 except OSError:
598 except OSError:
599 pass
599 pass
600
600
601 _unified_diff = difflib.unified_diff
601 _unified_diff = difflib.unified_diff
602 if PYTHON3:
602 if PYTHON3:
603 import functools
603 import functools
604 _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)
604 _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)
605
605
606 def getdiff(expected, output, ref, err):
606 def getdiff(expected, output, ref, err):
607 servefail = False
607 servefail = False
608 lines = []
608 lines = []
609 for line in _unified_diff(expected, output, ref, err):
609 for line in _unified_diff(expected, output, ref, err):
610 if line.startswith(b'+++') or line.startswith(b'---'):
610 if line.startswith(b'+++') or line.startswith(b'---'):
611 line = line.replace(b'\\', b'/')
611 line = line.replace(b'\\', b'/')
612 if line.endswith(b' \n'):
612 if line.endswith(b' \n'):
613 line = line[:-2] + b'\n'
613 line = line[:-2] + b'\n'
614 lines.append(line)
614 lines.append(line)
615 if not servefail and line.startswith(
615 if not servefail and line.startswith(
616 b'+ abort: child process failed to start'):
616 b'+ abort: child process failed to start'):
617 servefail = True
617 servefail = True
618
618
619 return servefail, lines
619 return servefail, lines
620
620
621 verbose = False
621 verbose = False
622 def vlog(*msg):
622 def vlog(*msg):
623 """Log only when in verbose mode."""
623 """Log only when in verbose mode."""
624 if verbose is False:
624 if verbose is False:
625 return
625 return
626
626
627 return log(*msg)
627 return log(*msg)
628
628
629 # Bytes that break XML even in a CDATA block: control characters 0-31
629 # Bytes that break XML even in a CDATA block: control characters 0-31
630 # sans \t, \n and \r
630 # sans \t, \n and \r
631 CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")
631 CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")
632
632
633 # Match feature conditionalized output lines in the form, capturing the feature
633 # Match feature conditionalized output lines in the form, capturing the feature
634 # list in group 2, and the preceeding line output in group 1:
634 # list in group 2, and the preceeding line output in group 1:
635 #
635 #
636 # output..output (feature !)\n
636 # output..output (feature !)\n
637 optline = re.compile(b'(.*) \((.+?) !\)\n$')
637 optline = re.compile(b'(.*) \((.+?) !\)\n$')
638
638
639 def cdatasafe(data):
639 def cdatasafe(data):
640 """Make a string safe to include in a CDATA block.
640 """Make a string safe to include in a CDATA block.
641
641
642 Certain control characters are illegal in a CDATA block, and
642 Certain control characters are illegal in a CDATA block, and
643 there's no way to include a ]]> in a CDATA either. This function
643 there's no way to include a ]]> in a CDATA either. This function
644 replaces illegal bytes with ? and adds a space between the ]] so
644 replaces illegal bytes with ? and adds a space between the ]] so
645 that it won't break the CDATA block.
645 that it won't break the CDATA block.
646 """
646 """
647 return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')
647 return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')
648
648
649 def log(*msg):
649 def log(*msg):
650 """Log something to stdout.
650 """Log something to stdout.
651
651
652 Arguments are strings to print.
652 Arguments are strings to print.
653 """
653 """
654 with iolock:
654 with iolock:
655 if verbose:
655 if verbose:
656 print(verbose, end=' ')
656 print(verbose, end=' ')
657 for m in msg:
657 for m in msg:
658 print(m, end=' ')
658 print(m, end=' ')
659 print()
659 print()
660 sys.stdout.flush()
660 sys.stdout.flush()
661
661
662 def highlightdiff(line, color):
662 def highlightdiff(line, color):
663 if not color:
663 if not color:
664 return line
664 return line
665 assert pygmentspresent
665 assert pygmentspresent
666 return pygments.highlight(line.decode('latin1'), difflexer,
666 return pygments.highlight(line.decode('latin1'), difflexer,
667 terminal256formatter).encode('latin1')
667 terminal256formatter).encode('latin1')
668
668
669 def highlightmsg(msg, color):
669 def highlightmsg(msg, color):
670 if not color:
670 if not color:
671 return msg
671 return msg
672 assert pygmentspresent
672 assert pygmentspresent
673 return pygments.highlight(msg, runnerlexer, runnerformatter)
673 return pygments.highlight(msg, runnerlexer, runnerformatter)
674
674
675 def terminate(proc):
675 def terminate(proc):
676 """Terminate subprocess"""
676 """Terminate subprocess"""
677 vlog('# Terminating process %d' % proc.pid)
677 vlog('# Terminating process %d' % proc.pid)
678 try:
678 try:
679 proc.terminate()
679 proc.terminate()
680 except OSError:
680 except OSError:
681 pass
681 pass
682
682
683 def killdaemons(pidfile):
683 def killdaemons(pidfile):
684 import killdaemons as killmod
684 import killdaemons as killmod
685 return killmod.killdaemons(pidfile, tryhard=False, remove=True,
685 return killmod.killdaemons(pidfile, tryhard=False, remove=True,
686 logfn=vlog)
686 logfn=vlog)
687
687
688 class Test(unittest.TestCase):
688 class Test(unittest.TestCase):
689 """Encapsulates a single, runnable test.
689 """Encapsulates a single, runnable test.
690
690
691 While this class conforms to the unittest.TestCase API, it differs in that
691 While this class conforms to the unittest.TestCase API, it differs in that
692 instances need to be instantiated manually. (Typically, unittest.TestCase
692 instances need to be instantiated manually. (Typically, unittest.TestCase
693 classes are instantiated automatically by scanning modules.)
693 classes are instantiated automatically by scanning modules.)
694 """
694 """
695
695
696 # Status code reserved for skipped tests (used by hghave).
696 # Status code reserved for skipped tests (used by hghave).
697 SKIPPED_STATUS = 80
697 SKIPPED_STATUS = 80
698
698
699 def __init__(self, path, outputdir, tmpdir, keeptmpdir=False,
699 def __init__(self, path, outputdir, tmpdir, keeptmpdir=False,
700 debug=False,
700 debug=False,
701 first=False,
701 first=False,
702 timeout=None,
702 timeout=None,
703 startport=None, extraconfigopts=None,
703 startport=None, extraconfigopts=None,
704 py3warnings=False, shell=None, hgcommand=None,
704 py3warnings=False, shell=None, hgcommand=None,
705 slowtimeout=None, usechg=False,
705 slowtimeout=None, usechg=False,
706 useipv6=False):
706 useipv6=False):
707 """Create a test from parameters.
707 """Create a test from parameters.
708
708
709 path is the full path to the file defining the test.
709 path is the full path to the file defining the test.
710
710
711 tmpdir is the main temporary directory to use for this test.
711 tmpdir is the main temporary directory to use for this test.
712
712
713 keeptmpdir determines whether to keep the test's temporary directory
713 keeptmpdir determines whether to keep the test's temporary directory
714 after execution. It defaults to removal (False).
714 after execution. It defaults to removal (False).
715
715
716 debug mode will make the test execute verbosely, with unfiltered
716 debug mode will make the test execute verbosely, with unfiltered
717 output.
717 output.
718
718
719 timeout controls the maximum run time of the test. It is ignored when
719 timeout controls the maximum run time of the test. It is ignored when
720 debug is True. See slowtimeout for tests with #require slow.
720 debug is True. See slowtimeout for tests with #require slow.
721
721
722 slowtimeout overrides timeout if the test has #require slow.
722 slowtimeout overrides timeout if the test has #require slow.
723
723
724 startport controls the starting port number to use for this test. Each
724 startport controls the starting port number to use for this test. Each
725 test will reserve 3 port numbers for execution. It is the caller's
725 test will reserve 3 port numbers for execution. It is the caller's
726 responsibility to allocate a non-overlapping port range to Test
726 responsibility to allocate a non-overlapping port range to Test
727 instances.
727 instances.
728
728
729 extraconfigopts is an iterable of extra hgrc config options. Values
729 extraconfigopts is an iterable of extra hgrc config options. Values
730 must have the form "key=value" (something understood by hgrc). Values
730 must have the form "key=value" (something understood by hgrc). Values
731 of the form "foo.key=value" will result in "[foo] key=value".
731 of the form "foo.key=value" will result in "[foo] key=value".
732
732
733 py3warnings enables Py3k warnings.
733 py3warnings enables Py3k warnings.
734
734
735 shell is the shell to execute tests in.
735 shell is the shell to execute tests in.
736 """
736 """
737 if timeout is None:
737 if timeout is None:
738 timeout = defaults['timeout']
738 timeout = defaults['timeout']
739 if startport is None:
739 if startport is None:
740 startport = defaults['port']
740 startport = defaults['port']
741 if slowtimeout is None:
741 if slowtimeout is None:
742 slowtimeout = defaults['slowtimeout']
742 slowtimeout = defaults['slowtimeout']
743 self.path = path
743 self.path = path
744 self.bname = os.path.basename(path)
744 self.bname = os.path.basename(path)
745 self.name = _strpath(self.bname)
745 self.name = _strpath(self.bname)
746 self._testdir = os.path.dirname(path)
746 self._testdir = os.path.dirname(path)
747 self._outputdir = outputdir
747 self._outputdir = outputdir
748 self._tmpname = os.path.basename(path)
748 self._tmpname = os.path.basename(path)
749 self.errpath = os.path.join(self._outputdir, b'%s.err' % self.bname)
749 self.errpath = os.path.join(self._outputdir, b'%s.err' % self.bname)
750
750
751 self._threadtmp = tmpdir
751 self._threadtmp = tmpdir
752 self._keeptmpdir = keeptmpdir
752 self._keeptmpdir = keeptmpdir
753 self._debug = debug
753 self._debug = debug
754 self._first = first
754 self._first = first
755 self._timeout = timeout
755 self._timeout = timeout
756 self._slowtimeout = slowtimeout
756 self._slowtimeout = slowtimeout
757 self._startport = startport
757 self._startport = startport
758 self._extraconfigopts = extraconfigopts or []
758 self._extraconfigopts = extraconfigopts or []
759 self._py3warnings = py3warnings
759 self._py3warnings = py3warnings
760 self._shell = _bytespath(shell)
760 self._shell = _bytespath(shell)
761 self._hgcommand = hgcommand or b'hg'
761 self._hgcommand = hgcommand or b'hg'
762 self._usechg = usechg
762 self._usechg = usechg
763 self._useipv6 = useipv6
763 self._useipv6 = useipv6
764
764
765 self._aborted = False
765 self._aborted = False
766 self._daemonpids = []
766 self._daemonpids = []
767 self._finished = None
767 self._finished = None
768 self._ret = None
768 self._ret = None
769 self._out = None
769 self._out = None
770 self._skipped = None
770 self._skipped = None
771 self._testtmp = None
771 self._testtmp = None
772 self._chgsockdir = None
772 self._chgsockdir = None
773
773
774 self._refout = self.readrefout()
774 self._refout = self.readrefout()
775
775
776 def readrefout(self):
776 def readrefout(self):
777 """read reference output"""
777 """read reference output"""
778 # If we're not in --debug mode and reference output file exists,
778 # If we're not in --debug mode and reference output file exists,
779 # check test output against it.
779 # check test output against it.
780 if self._debug:
780 if self._debug:
781 return None # to match "out is None"
781 return None # to match "out is None"
782 elif os.path.exists(self.refpath):
782 elif os.path.exists(self.refpath):
783 with open(self.refpath, 'rb') as f:
783 with open(self.refpath, 'rb') as f:
784 return f.read().splitlines(True)
784 return f.read().splitlines(True)
785 else:
785 else:
786 return []
786 return []
787
787
788 # needed to get base class __repr__ running
788 # needed to get base class __repr__ running
789 @property
789 @property
790 def _testMethodName(self):
790 def _testMethodName(self):
791 return self.name
791 return self.name
792
792
793 def __str__(self):
793 def __str__(self):
794 return self.name
794 return self.name
795
795
796 def shortDescription(self):
796 def shortDescription(self):
797 return self.name
797 return self.name
798
798
799 def setUp(self):
799 def setUp(self):
800 """Tasks to perform before run()."""
800 """Tasks to perform before run()."""
801 self._finished = False
801 self._finished = False
802 self._ret = None
802 self._ret = None
803 self._out = None
803 self._out = None
804 self._skipped = None
804 self._skipped = None
805
805
806 try:
806 try:
807 os.mkdir(self._threadtmp)
807 os.mkdir(self._threadtmp)
808 except OSError as e:
808 except OSError as e:
809 if e.errno != errno.EEXIST:
809 if e.errno != errno.EEXIST:
810 raise
810 raise
811
811
812 name = self._tmpname
812 name = self._tmpname
813 self._testtmp = os.path.join(self._threadtmp, name)
813 self._testtmp = os.path.join(self._threadtmp, name)
814 os.mkdir(self._testtmp)
814 os.mkdir(self._testtmp)
815
815
816 # Remove any previous output files.
816 # Remove any previous output files.
817 if os.path.exists(self.errpath):
817 if os.path.exists(self.errpath):
818 try:
818 try:
819 os.remove(self.errpath)
819 os.remove(self.errpath)
820 except OSError as e:
820 except OSError as e:
821 # We might have raced another test to clean up a .err
821 # We might have raced another test to clean up a .err
822 # file, so ignore ENOENT when removing a previous .err
822 # file, so ignore ENOENT when removing a previous .err
823 # file.
823 # file.
824 if e.errno != errno.ENOENT:
824 if e.errno != errno.ENOENT:
825 raise
825 raise
826
826
827 if self._usechg:
827 if self._usechg:
828 self._chgsockdir = os.path.join(self._threadtmp,
828 self._chgsockdir = os.path.join(self._threadtmp,
829 b'%s.chgsock' % name)
829 b'%s.chgsock' % name)
830 os.mkdir(self._chgsockdir)
830 os.mkdir(self._chgsockdir)
831
831
832 def run(self, result):
832 def run(self, result):
833 """Run this test and report results against a TestResult instance."""
833 """Run this test and report results against a TestResult instance."""
834 # This function is extremely similar to unittest.TestCase.run(). Once
834 # This function is extremely similar to unittest.TestCase.run(). Once
835 # we require Python 2.7 (or at least its version of unittest), this
835 # we require Python 2.7 (or at least its version of unittest), this
836 # function can largely go away.
836 # function can largely go away.
837 self._result = result
837 self._result = result
838 result.startTest(self)
838 result.startTest(self)
839 try:
839 try:
840 try:
840 try:
841 self.setUp()
841 self.setUp()
842 except (KeyboardInterrupt, SystemExit):
842 except (KeyboardInterrupt, SystemExit):
843 self._aborted = True
843 self._aborted = True
844 raise
844 raise
845 except Exception:
845 except Exception:
846 result.addError(self, sys.exc_info())
846 result.addError(self, sys.exc_info())
847 return
847 return
848
848
849 success = False
849 success = False
850 try:
850 try:
851 self.runTest()
851 self.runTest()
852 except KeyboardInterrupt:
852 except KeyboardInterrupt:
853 self._aborted = True
853 self._aborted = True
854 raise
854 raise
855 except unittest.SkipTest as e:
855 except unittest.SkipTest as e:
856 result.addSkip(self, str(e))
856 result.addSkip(self, str(e))
857 # The base class will have already counted this as a
857 # The base class will have already counted this as a
858 # test we "ran", but we want to exclude skipped tests
858 # test we "ran", but we want to exclude skipped tests
859 # from those we count towards those run.
859 # from those we count towards those run.
860 result.testsRun -= 1
860 result.testsRun -= 1
861 except self.failureException as e:
861 except self.failureException as e:
862 # This differs from unittest in that we don't capture
862 # This differs from unittest in that we don't capture
863 # the stack trace. This is for historical reasons and
863 # the stack trace. This is for historical reasons and
864 # this decision could be revisited in the future,
864 # this decision could be revisited in the future,
865 # especially for PythonTest instances.
865 # especially for PythonTest instances.
866 if result.addFailure(self, str(e)):
866 if result.addFailure(self, str(e)):
867 success = True
867 success = True
868 except Exception:
868 except Exception:
869 result.addError(self, sys.exc_info())
869 result.addError(self, sys.exc_info())
870 else:
870 else:
871 success = True
871 success = True
872
872
873 try:
873 try:
874 self.tearDown()
874 self.tearDown()
875 except (KeyboardInterrupt, SystemExit):
875 except (KeyboardInterrupt, SystemExit):
876 self._aborted = True
876 self._aborted = True
877 raise
877 raise
878 except Exception:
878 except Exception:
879 result.addError(self, sys.exc_info())
879 result.addError(self, sys.exc_info())
880 success = False
880 success = False
881
881
882 if success:
882 if success:
883 result.addSuccess(self)
883 result.addSuccess(self)
884 finally:
884 finally:
885 result.stopTest(self, interrupted=self._aborted)
885 result.stopTest(self, interrupted=self._aborted)
886
886
887 def runTest(self):
887 def runTest(self):
888 """Run this test instance.
888 """Run this test instance.
889
889
890 This will return a tuple describing the result of the test.
890 This will return a tuple describing the result of the test.
891 """
891 """
892 env = self._getenv()
892 env = self._getenv()
893 self._genrestoreenv(env)
893 self._genrestoreenv(env)
894 self._daemonpids.append(env['DAEMON_PIDS'])
894 self._daemonpids.append(env['DAEMON_PIDS'])
895 self._createhgrc(env['HGRCPATH'])
895 self._createhgrc(env['HGRCPATH'])
896
896
897 vlog('# Test', self.name)
897 vlog('# Test', self.name)
898
898
899 ret, out = self._run(env)
899 ret, out = self._run(env)
900 self._finished = True
900 self._finished = True
901 self._ret = ret
901 self._ret = ret
902 self._out = out
902 self._out = out
903
903
904 def describe(ret):
904 def describe(ret):
905 if ret < 0:
905 if ret < 0:
906 return 'killed by signal: %d' % -ret
906 return 'killed by signal: %d' % -ret
907 return 'returned error code %d' % ret
907 return 'returned error code %d' % ret
908
908
909 self._skipped = False
909 self._skipped = False
910
910
911 if ret == self.SKIPPED_STATUS:
911 if ret == self.SKIPPED_STATUS:
912 if out is None: # Debug mode, nothing to parse.
912 if out is None: # Debug mode, nothing to parse.
913 missing = ['unknown']
913 missing = ['unknown']
914 failed = None
914 failed = None
915 else:
915 else:
916 missing, failed = TTest.parsehghaveoutput(out)
916 missing, failed = TTest.parsehghaveoutput(out)
917
917
918 if not missing:
918 if not missing:
919 missing = ['skipped']
919 missing = ['skipped']
920
920
921 if failed:
921 if failed:
922 self.fail('hg have failed checking for %s' % failed[-1])
922 self.fail('hg have failed checking for %s' % failed[-1])
923 else:
923 else:
924 self._skipped = True
924 self._skipped = True
925 raise unittest.SkipTest(missing[-1])
925 raise unittest.SkipTest(missing[-1])
926 elif ret == 'timeout':
926 elif ret == 'timeout':
927 self.fail('timed out')
927 self.fail('timed out')
928 elif ret is False:
928 elif ret is False:
929 self.fail('no result code from test')
929 self.fail('no result code from test')
930 elif out != self._refout:
930 elif out != self._refout:
931 # Diff generation may rely on written .err file.
931 # Diff generation may rely on written .err file.
932 if (ret != 0 or out != self._refout) and not self._skipped \
932 if (ret != 0 or out != self._refout) and not self._skipped \
933 and not self._debug:
933 and not self._debug:
934 with open(self.errpath, 'wb') as f:
934 with open(self.errpath, 'wb') as f:
935 for line in out:
935 for line in out:
936 f.write(line)
936 f.write(line)
937
937
938 # The result object handles diff calculation for us.
938 # The result object handles diff calculation for us.
939 with firstlock:
939 with firstlock:
940 if self._result.addOutputMismatch(self, ret, out, self._refout):
940 if self._result.addOutputMismatch(self, ret, out, self._refout):
941 # change was accepted, skip failing
941 # change was accepted, skip failing
942 return
942 return
943 if self._first:
943 if self._first:
944 global firsterror
944 global firsterror
945 firsterror = True
945 firsterror = True
946
946
947 if ret:
947 if ret:
948 msg = 'output changed and ' + describe(ret)
948 msg = 'output changed and ' + describe(ret)
949 else:
949 else:
950 msg = 'output changed'
950 msg = 'output changed'
951
951
952 self.fail(msg)
952 self.fail(msg)
953 elif ret:
953 elif ret:
954 self.fail(describe(ret))
954 self.fail(describe(ret))
955
955
956 def tearDown(self):
956 def tearDown(self):
957 """Tasks to perform after run()."""
957 """Tasks to perform after run()."""
958 for entry in self._daemonpids:
958 for entry in self._daemonpids:
959 killdaemons(entry)
959 killdaemons(entry)
960 self._daemonpids = []
960 self._daemonpids = []
961
961
962 if self._keeptmpdir:
962 if self._keeptmpdir:
963 log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' %
963 log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' %
964 (self._testtmp.decode('utf-8'),
964 (self._testtmp.decode('utf-8'),
965 self._threadtmp.decode('utf-8')))
965 self._threadtmp.decode('utf-8')))
966 else:
966 else:
967 try:
967 try:
968 shutil.rmtree(self._testtmp)
968 shutil.rmtree(self._testtmp)
969 except OSError:
969 except OSError:
970 # unreadable directory may be left in $TESTTMP; fix permission
970 # unreadable directory may be left in $TESTTMP; fix permission
971 # and try again
971 # and try again
972 makecleanable(self._testtmp)
972 makecleanable(self._testtmp)
973 shutil.rmtree(self._testtmp, True)
973 shutil.rmtree(self._testtmp, True)
974 shutil.rmtree(self._threadtmp, True)
974 shutil.rmtree(self._threadtmp, True)
975
975
976 if self._usechg:
976 if self._usechg:
977 # chgservers will stop automatically after they find the socket
977 # chgservers will stop automatically after they find the socket
978 # files are deleted
978 # files are deleted
979 shutil.rmtree(self._chgsockdir, True)
979 shutil.rmtree(self._chgsockdir, True)
980
980
981 if (self._ret != 0 or self._out != self._refout) and not self._skipped \
981 if (self._ret != 0 or self._out != self._refout) and not self._skipped \
982 and not self._debug and self._out:
982 and not self._debug and self._out:
983 with open(self.errpath, 'wb') as f:
983 with open(self.errpath, 'wb') as f:
984 for line in self._out:
984 for line in self._out:
985 f.write(line)
985 f.write(line)
986
986
987 vlog("# Ret was:", self._ret, '(%s)' % self.name)
987 vlog("# Ret was:", self._ret, '(%s)' % self.name)
988
988
989 def _run(self, env):
989 def _run(self, env):
990 # This should be implemented in child classes to run tests.
990 # This should be implemented in child classes to run tests.
991 raise unittest.SkipTest('unknown test type')
991 raise unittest.SkipTest('unknown test type')
992
992
993 def abort(self):
993 def abort(self):
994 """Terminate execution of this test."""
994 """Terminate execution of this test."""
995 self._aborted = True
995 self._aborted = True
996
996
997 def _portmap(self, i):
997 def _portmap(self, i):
998 offset = b'' if i == 0 else b'%d' % i
998 offset = b'' if i == 0 else b'%d' % i
999 return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset)
999 return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset)
1000
1000
1001 def _getreplacements(self):
1001 def _getreplacements(self):
1002 """Obtain a mapping of text replacements to apply to test output.
1002 """Obtain a mapping of text replacements to apply to test output.
1003
1003
1004 Test output needs to be normalized so it can be compared to expected
1004 Test output needs to be normalized so it can be compared to expected
1005 output. This function defines how some of that normalization will
1005 output. This function defines how some of that normalization will
1006 occur.
1006 occur.
1007 """
1007 """
1008 r = [
1008 r = [
1009 # This list should be parallel to defineport in _getenv
1009 # This list should be parallel to defineport in _getenv
1010 self._portmap(0),
1010 self._portmap(0),
1011 self._portmap(1),
1011 self._portmap(1),
1012 self._portmap(2),
1012 self._portmap(2),
1013 (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'),
1013 (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'),
1014 (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'),
1014 (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'),
1015 ]
1015 ]
1016 r.append((self._escapepath(self._testtmp), b'$TESTTMP'))
1016 r.append((self._escapepath(self._testtmp), b'$TESTTMP'))
1017
1017
1018 replacementfile = os.path.join(self._testdir, b'common-pattern.py')
1018 replacementfile = os.path.join(self._testdir, b'common-pattern.py')
1019
1019
1020 if os.path.exists(replacementfile):
1020 if os.path.exists(replacementfile):
1021 data = {}
1021 data = {}
1022 with open(replacementfile, mode='rb') as source:
1022 with open(replacementfile, mode='rb') as source:
1023 # the intermediate 'compile' step help with debugging
1023 # the intermediate 'compile' step help with debugging
1024 code = compile(source.read(), replacementfile, 'exec')
1024 code = compile(source.read(), replacementfile, 'exec')
1025 exec(code, data)
1025 exec(code, data)
1026 for value in data.get('substitutions', ()):
1026 for value in data.get('substitutions', ()):
1027 if len(value) != 2:
1027 if len(value) != 2:
1028 msg = 'malformatted substitution in %s: %r'
1028 msg = 'malformatted substitution in %s: %r'
1029 msg %= (replacementfile, value)
1029 msg %= (replacementfile, value)
1030 raise ValueError(msg)
1030 raise ValueError(msg)
1031 r.append(value)
1031 r.append(value)
1032 return r
1032 return r
1033
1033
1034 def _escapepath(self, p):
1034 def _escapepath(self, p):
1035 if os.name == 'nt':
1035 if os.name == 'nt':
1036 return (
1036 return (
1037 (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or
1037 (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or
1038 c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c
1038 c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c
1039 for c in [p[i:i + 1] for i in range(len(p))]))
1039 for c in [p[i:i + 1] for i in range(len(p))]))
1040 )
1040 )
1041 else:
1041 else:
1042 return re.escape(p)
1042 return re.escape(p)
1043
1043
1044 def _localip(self):
1044 def _localip(self):
1045 if self._useipv6:
1045 if self._useipv6:
1046 return b'::1'
1046 return b'::1'
1047 else:
1047 else:
1048 return b'127.0.0.1'
1048 return b'127.0.0.1'
1049
1049
1050 def _genrestoreenv(self, testenv):
1050 def _genrestoreenv(self, testenv):
1051 """Generate a script that can be used by tests to restore the original
1051 """Generate a script that can be used by tests to restore the original
1052 environment."""
1052 environment."""
1053 # Put the restoreenv script inside self._threadtmp
1053 # Put the restoreenv script inside self._threadtmp
1054 scriptpath = os.path.join(self._threadtmp, b'restoreenv.sh')
1054 scriptpath = os.path.join(self._threadtmp, b'restoreenv.sh')
1055 testenv['HGTEST_RESTOREENV'] = _strpath(scriptpath)
1055 testenv['HGTEST_RESTOREENV'] = _strpath(scriptpath)
1056
1056
1057 # Only restore environment variable names that the shell allows
1057 # Only restore environment variable names that the shell allows
1058 # us to export.
1058 # us to export.
1059 name_regex = re.compile('^[a-zA-Z][a-zA-Z0-9_]*$')
1059 name_regex = re.compile('^[a-zA-Z][a-zA-Z0-9_]*$')
1060
1060
1061 # Do not restore these variables; otherwise tests would fail.
1061 # Do not restore these variables; otherwise tests would fail.
1062 reqnames = {'PYTHON', 'TESTDIR', 'TESTTMP'}
1062 reqnames = {'PYTHON', 'TESTDIR', 'TESTTMP'}
1063
1063
1064 with open(scriptpath, 'w') as envf:
1064 with open(scriptpath, 'w') as envf:
1065 for name, value in origenviron.items():
1065 for name, value in origenviron.items():
1066 if not name_regex.match(name):
1066 if not name_regex.match(name):
1067 # Skip environment variables with unusual names not
1067 # Skip environment variables with unusual names not
1068 # allowed by most shells.
1068 # allowed by most shells.
1069 continue
1069 continue
1070 if name in reqnames:
1070 if name in reqnames:
1071 continue
1071 continue
1072 envf.write('%s=%s\n' % (name, shellquote(value)))
1072 envf.write('%s=%s\n' % (name, shellquote(value)))
1073
1073
1074 for name in testenv:
1074 for name in testenv:
1075 if name in origenviron or name in reqnames:
1075 if name in origenviron or name in reqnames:
1076 continue
1076 continue
1077 envf.write('unset %s\n' % (name,))
1077 envf.write('unset %s\n' % (name,))
1078
1078
1079 def _getenv(self):
1079 def _getenv(self):
1080 """Obtain environment variables to use during test execution."""
1080 """Obtain environment variables to use during test execution."""
1081 def defineport(i):
1081 def defineport(i):
1082 offset = '' if i == 0 else '%s' % i
1082 offset = '' if i == 0 else '%s' % i
1083 env["HGPORT%s" % offset] = '%s' % (self._startport + i)
1083 env["HGPORT%s" % offset] = '%s' % (self._startport + i)
1084 env = os.environ.copy()
1084 env = os.environ.copy()
1085 env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or ''
1085 env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or ''
1086 env['HGEMITWARNINGS'] = '1'
1086 env['HGEMITWARNINGS'] = '1'
1087 env['TESTTMP'] = _strpath(self._testtmp)
1087 env['TESTTMP'] = _strpath(self._testtmp)
1088 env['TESTNAME'] = self.name
1088 env['TESTNAME'] = self.name
1089 env['HOME'] = _strpath(self._testtmp)
1089 env['HOME'] = _strpath(self._testtmp)
1090 # This number should match portneeded in _getport
1090 # This number should match portneeded in _getport
1091 for port in xrange(3):
1091 for port in xrange(3):
1092 # This list should be parallel to _portmap in _getreplacements
1092 # This list should be parallel to _portmap in _getreplacements
1093 defineport(port)
1093 defineport(port)
1094 env["HGRCPATH"] = _strpath(os.path.join(self._threadtmp, b'.hgrc'))
1094 env["HGRCPATH"] = _strpath(os.path.join(self._threadtmp, b'.hgrc'))
1095 env["DAEMON_PIDS"] = _strpath(os.path.join(self._threadtmp,
1095 env["DAEMON_PIDS"] = _strpath(os.path.join(self._threadtmp,
1096 b'daemon.pids'))
1096 b'daemon.pids'))
1097 env["HGEDITOR"] = ('"' + sys.executable + '"'
1097 env["HGEDITOR"] = ('"' + sys.executable + '"'
1098 + ' -c "import sys; sys.exit(0)"')
1098 + ' -c "import sys; sys.exit(0)"')
1099 env["HGUSER"] = "test"
1099 env["HGUSER"] = "test"
1100 env["HGENCODING"] = "ascii"
1100 env["HGENCODING"] = "ascii"
1101 env["HGENCODINGMODE"] = "strict"
1101 env["HGENCODINGMODE"] = "strict"
1102 env["HGHOSTNAME"] = "test-hostname"
1102 env["HGHOSTNAME"] = "test-hostname"
1103 env['HGIPV6'] = str(int(self._useipv6))
1103 env['HGIPV6'] = str(int(self._useipv6))
1104 # See contrib/catapipe.py for how to use this functionality.
1104 # See contrib/catapipe.py for how to use this functionality.
1105 if 'HGTESTCATAPULTSERVERPIPE' not in env:
1105 if 'HGTESTCATAPULTSERVERPIPE' not in env:
1106 # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the
1106 # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the
1107 # non-test one in as a default, otherwise set to devnull
1107 # non-test one in as a default, otherwise set to devnull
1108 env['HGTESTCATAPULTSERVERPIPE'] = \
1108 env['HGTESTCATAPULTSERVERPIPE'] = \
1109 env.get('HGCATAPULTSERVERPIPE', os.devnull)
1109 env.get('HGCATAPULTSERVERPIPE', os.devnull)
1110
1110
1111 extraextensions = []
1111 extraextensions = []
1112 for opt in self._extraconfigopts:
1112 for opt in self._extraconfigopts:
1113 section, key = opt.encode('utf-8').split(b'.', 1)
1113 section, key = opt.encode('utf-8').split(b'.', 1)
1114 if section != 'extensions':
1114 if section != 'extensions':
1115 continue
1115 continue
1116 name = key.split(b'=', 1)[0]
1116 name = key.split(b'=', 1)[0]
1117 extraextensions.append(name)
1117 extraextensions.append(name)
1118
1118
1119 if extraextensions:
1119 if extraextensions:
1120 env['HGTESTEXTRAEXTENSIONS'] = b' '.join(extraextensions)
1120 env['HGTESTEXTRAEXTENSIONS'] = b' '.join(extraextensions)
1121
1121
1122 # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw
1122 # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw
1123 # IP addresses.
1123 # IP addresses.
1124 env['LOCALIP'] = _strpath(self._localip())
1124 env['LOCALIP'] = _strpath(self._localip())
1125
1125
1126 # This has the same effect as Py_LegacyWindowsStdioFlag in exewrapper.c,
1126 # This has the same effect as Py_LegacyWindowsStdioFlag in exewrapper.c,
1127 # but this is needed for testing python instances like dummyssh,
1127 # but this is needed for testing python instances like dummyssh,
1128 # dummysmtpd.py, and dumbhttp.py.
1128 # dummysmtpd.py, and dumbhttp.py.
1129 if PYTHON3 and os.name == 'nt':
1129 if PYTHON3 and os.name == 'nt':
1130 env['PYTHONLEGACYWINDOWSSTDIO'] = '1'
1130 env['PYTHONLEGACYWINDOWSSTDIO'] = '1'
1131
1131
1132 # Reset some environment variables to well-known values so that
1132 # Reset some environment variables to well-known values so that
1133 # the tests produce repeatable output.
1133 # the tests produce repeatable output.
1134 env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'
1134 env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'
1135 env['TZ'] = 'GMT'
1135 env['TZ'] = 'GMT'
1136 env["EMAIL"] = "Foo Bar <foo.bar@example.com>"
1136 env["EMAIL"] = "Foo Bar <foo.bar@example.com>"
1137 env['COLUMNS'] = '80'
1137 env['COLUMNS'] = '80'
1138 env['TERM'] = 'xterm'
1138 env['TERM'] = 'xterm'
1139
1139
1140 dropped = [
1140 dropped = [
1141 'CDPATH',
1141 'CDPATH',
1142 'CHGDEBUG',
1142 'CHGDEBUG',
1143 'EDITOR',
1143 'EDITOR',
1144 'GREP_OPTIONS',
1144 'GREP_OPTIONS',
1145 'HG',
1145 'HG',
1146 'HGMERGE',
1146 'HGMERGE',
1147 'HGPLAIN',
1147 'HGPLAIN',
1148 'HGPLAINEXCEPT',
1148 'HGPLAINEXCEPT',
1149 'HGPROF',
1149 'HGPROF',
1150 'http_proxy',
1150 'http_proxy',
1151 'no_proxy',
1151 'no_proxy',
1152 'NO_PROXY',
1152 'NO_PROXY',
1153 'PAGER',
1153 'PAGER',
1154 'VISUAL',
1154 'VISUAL',
1155 ]
1155 ]
1156
1156
1157 for k in dropped:
1157 for k in dropped:
1158 if k in env:
1158 if k in env:
1159 del env[k]
1159 del env[k]
1160
1160
1161 # unset env related to hooks
1161 # unset env related to hooks
1162 for k in list(env):
1162 for k in list(env):
1163 if k.startswith('HG_'):
1163 if k.startswith('HG_'):
1164 del env[k]
1164 del env[k]
1165
1165
1166 if self._usechg:
1166 if self._usechg:
1167 env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server')
1167 env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server')
1168
1168
1169 return env
1169 return env
1170
1170
1171 def _createhgrc(self, path):
1171 def _createhgrc(self, path):
1172 """Create an hgrc file for this test."""
1172 """Create an hgrc file for this test."""
1173 with open(path, 'wb') as hgrc:
1173 with open(path, 'wb') as hgrc:
1174 hgrc.write(b'[ui]\n')
1174 hgrc.write(b'[ui]\n')
1175 hgrc.write(b'slash = True\n')
1175 hgrc.write(b'slash = True\n')
1176 hgrc.write(b'interactive = False\n')
1176 hgrc.write(b'interactive = False\n')
1177 hgrc.write(b'merge = internal:merge\n')
1177 hgrc.write(b'merge = internal:merge\n')
1178 hgrc.write(b'mergemarkers = detailed\n')
1178 hgrc.write(b'mergemarkers = detailed\n')
1179 hgrc.write(b'promptecho = True\n')
1179 hgrc.write(b'promptecho = True\n')
1180 hgrc.write(b'[defaults]\n')
1180 hgrc.write(b'[defaults]\n')
1181 hgrc.write(b'[devel]\n')
1181 hgrc.write(b'[devel]\n')
1182 hgrc.write(b'all-warnings = true\n')
1182 hgrc.write(b'all-warnings = true\n')
1183 hgrc.write(b'default-date = 0 0\n')
1183 hgrc.write(b'default-date = 0 0\n')
1184 hgrc.write(b'[largefiles]\n')
1184 hgrc.write(b'[largefiles]\n')
1185 hgrc.write(b'usercache = %s\n' %
1185 hgrc.write(b'usercache = %s\n' %
1186 (os.path.join(self._testtmp, b'.cache/largefiles')))
1186 (os.path.join(self._testtmp, b'.cache/largefiles')))
1187 hgrc.write(b'[lfs]\n')
1187 hgrc.write(b'[lfs]\n')
1188 hgrc.write(b'usercache = %s\n' %
1188 hgrc.write(b'usercache = %s\n' %
1189 (os.path.join(self._testtmp, b'.cache/lfs')))
1189 (os.path.join(self._testtmp, b'.cache/lfs')))
1190 hgrc.write(b'[web]\n')
1190 hgrc.write(b'[web]\n')
1191 hgrc.write(b'address = localhost\n')
1191 hgrc.write(b'address = localhost\n')
1192 hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii'))
1192 hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii'))
1193 hgrc.write(b'server-header = testing stub value\n')
1193 hgrc.write(b'server-header = testing stub value\n')
1194
1194
1195 for opt in self._extraconfigopts:
1195 for opt in self._extraconfigopts:
1196 section, key = opt.encode('utf-8').split(b'.', 1)
1196 section, key = opt.encode('utf-8').split(b'.', 1)
1197 assert b'=' in key, ('extra config opt %s must '
1197 assert b'=' in key, ('extra config opt %s must '
1198 'have an = for assignment' % opt)
1198 'have an = for assignment' % opt)
1199 hgrc.write(b'[%s]\n%s\n' % (section, key))
1199 hgrc.write(b'[%s]\n%s\n' % (section, key))
1200
1200
1201 def fail(self, msg):
1201 def fail(self, msg):
1202 # unittest differentiates between errored and failed.
1202 # unittest differentiates between errored and failed.
1203 # Failed is denoted by AssertionError (by default at least).
1203 # Failed is denoted by AssertionError (by default at least).
1204 raise AssertionError(msg)
1204 raise AssertionError(msg)
1205
1205
1206 def _runcommand(self, cmd, env, normalizenewlines=False):
1206 def _runcommand(self, cmd, env, normalizenewlines=False):
1207 """Run command in a sub-process, capturing the output (stdout and
1207 """Run command in a sub-process, capturing the output (stdout and
1208 stderr).
1208 stderr).
1209
1209
1210 Return a tuple (exitcode, output). output is None in debug mode.
1210 Return a tuple (exitcode, output). output is None in debug mode.
1211 """
1211 """
1212 if self._debug:
1212 if self._debug:
1213 proc = subprocess.Popen(_strpath(cmd), shell=True,
1213 proc = subprocess.Popen(_strpath(cmd), shell=True,
1214 cwd=_strpath(self._testtmp),
1214 cwd=_strpath(self._testtmp),
1215 env=env)
1215 env=env)
1216 ret = proc.wait()
1216 ret = proc.wait()
1217 return (ret, None)
1217 return (ret, None)
1218
1218
1219 proc = Popen4(cmd, self._testtmp, self._timeout, env)
1219 proc = Popen4(cmd, self._testtmp, self._timeout, env)
1220 def cleanup():
1220 def cleanup():
1221 terminate(proc)
1221 terminate(proc)
1222 ret = proc.wait()
1222 ret = proc.wait()
1223 if ret == 0:
1223 if ret == 0:
1224 ret = signal.SIGTERM << 8
1224 ret = signal.SIGTERM << 8
1225 killdaemons(env['DAEMON_PIDS'])
1225 killdaemons(env['DAEMON_PIDS'])
1226 return ret
1226 return ret
1227
1227
1228 output = b''
1228 output = b''
1229 proc.tochild.close()
1229 proc.tochild.close()
1230
1230
1231 try:
1231 try:
1232 output = proc.fromchild.read()
1232 output = proc.fromchild.read()
1233 except KeyboardInterrupt:
1233 except KeyboardInterrupt:
1234 vlog('# Handling keyboard interrupt')
1234 vlog('# Handling keyboard interrupt')
1235 cleanup()
1235 cleanup()
1236 raise
1236 raise
1237
1237
1238 ret = proc.wait()
1238 ret = proc.wait()
1239 if wifexited(ret):
1239 if wifexited(ret):
1240 ret = os.WEXITSTATUS(ret)
1240 ret = os.WEXITSTATUS(ret)
1241
1241
1242 if proc.timeout:
1242 if proc.timeout:
1243 ret = 'timeout'
1243 ret = 'timeout'
1244
1244
1245 if ret:
1245 if ret:
1246 killdaemons(env['DAEMON_PIDS'])
1246 killdaemons(env['DAEMON_PIDS'])
1247
1247
1248 for s, r in self._getreplacements():
1248 for s, r in self._getreplacements():
1249 output = re.sub(s, r, output)
1249 output = re.sub(s, r, output)
1250
1250
1251 if normalizenewlines:
1251 if normalizenewlines:
1252 output = output.replace(b'\r\n', b'\n')
1252 output = output.replace(b'\r\n', b'\n')
1253
1253
1254 return ret, output.splitlines(True)
1254 return ret, output.splitlines(True)
1255
1255
1256 class PythonTest(Test):
1256 class PythonTest(Test):
1257 """A Python-based test."""
1257 """A Python-based test."""
1258
1258
1259 @property
1259 @property
1260 def refpath(self):
1260 def refpath(self):
1261 return os.path.join(self._testdir, b'%s.out' % self.bname)
1261 return os.path.join(self._testdir, b'%s.out' % self.bname)
1262
1262
1263 def _run(self, env):
1263 def _run(self, env):
1264 py3switch = self._py3warnings and b' -3' or b''
1264 py3switch = self._py3warnings and b' -3' or b''
1265 # Quote the python(3) executable for Windows
1265 # Quote the python(3) executable for Windows
1266 cmd = b'"%s"%s "%s"' % (PYTHON, py3switch, self.path)
1266 cmd = b'"%s"%s "%s"' % (PYTHON, py3switch, self.path)
1267 vlog("# Running", cmd)
1267 vlog("# Running", cmd)
1268 normalizenewlines = os.name == 'nt'
1268 normalizenewlines = os.name == 'nt'
1269 result = self._runcommand(cmd, env,
1269 result = self._runcommand(cmd, env,
1270 normalizenewlines=normalizenewlines)
1270 normalizenewlines=normalizenewlines)
1271 if self._aborted:
1271 if self._aborted:
1272 raise KeyboardInterrupt()
1272 raise KeyboardInterrupt()
1273
1273
1274 return result
1274 return result
1275
1275
1276 # Some glob patterns apply only in some circumstances, so the script
1276 # Some glob patterns apply only in some circumstances, so the script
1277 # might want to remove (glob) annotations that otherwise should be
1277 # might want to remove (glob) annotations that otherwise should be
1278 # retained.
1278 # retained.
1279 checkcodeglobpats = [
1279 checkcodeglobpats = [
1280 # On Windows it looks like \ doesn't require a (glob), but we know
1280 # On Windows it looks like \ doesn't require a (glob), but we know
1281 # better.
1281 # better.
1282 re.compile(br'^pushing to \$TESTTMP/.*[^)]$'),
1282 re.compile(br'^pushing to \$TESTTMP/.*[^)]$'),
1283 re.compile(br'^moving \S+/.*[^)]$'),
1283 re.compile(br'^moving \S+/.*[^)]$'),
1284 re.compile(br'^pulling from \$TESTTMP/.*[^)]$'),
1284 re.compile(br'^pulling from \$TESTTMP/.*[^)]$'),
1285 # Not all platforms have 127.0.0.1 as loopback (though most do),
1285 # Not all platforms have 127.0.0.1 as loopback (though most do),
1286 # so we always glob that too.
1286 # so we always glob that too.
1287 re.compile(br'.*\$LOCALIP.*$'),
1287 re.compile(br'.*\$LOCALIP.*$'),
1288 ]
1288 ]
1289
1289
1290 bchr = chr
1290 bchr = chr
1291 if PYTHON3:
1291 if PYTHON3:
1292 bchr = lambda x: bytes([x])
1292 bchr = lambda x: bytes([x])
1293
1293
1294 class TTest(Test):
1294 class TTest(Test):
1295 """A "t test" is a test backed by a .t file."""
1295 """A "t test" is a test backed by a .t file."""
1296
1296
1297 SKIPPED_PREFIX = b'skipped: '
1297 SKIPPED_PREFIX = b'skipped: '
1298 FAILED_PREFIX = b'hghave check failed: '
1298 FAILED_PREFIX = b'hghave check failed: '
1299 NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
1299 NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
1300
1300
1301 ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
1301 ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
1302 ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256))
1302 ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256))
1303 ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
1303 ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
1304
1304
1305 def __init__(self, path, *args, **kwds):
1305 def __init__(self, path, *args, **kwds):
1306 # accept an extra "case" parameter
1306 # accept an extra "case" parameter
1307 case = kwds.pop('case', [])
1307 case = kwds.pop('case', [])
1308 self._case = case
1308 self._case = case
1309 self._allcases = {x for y in parsettestcases(path) for x in y}
1309 self._allcases = {x for y in parsettestcases(path) for x in y}
1310 super(TTest, self).__init__(path, *args, **kwds)
1310 super(TTest, self).__init__(path, *args, **kwds)
1311 if case:
1311 if case:
1312 casepath = b'#'.join(case)
1312 casepath = b'#'.join(case)
1313 self.name = '%s#%s' % (self.name, _strpath(casepath))
1313 self.name = '%s#%s' % (self.name, _strpath(casepath))
1314 self.errpath = b'%s#%s.err' % (self.errpath[:-4], casepath)
1314 self.errpath = b'%s#%s.err' % (self.errpath[:-4], casepath)
1315 self._tmpname += b'-%s' % casepath
1315 self._tmpname += b'-%s' % casepath
1316 self._have = {}
1316 self._have = {}
1317
1317
1318 @property
1318 @property
1319 def refpath(self):
1319 def refpath(self):
1320 return os.path.join(self._testdir, self.bname)
1320 return os.path.join(self._testdir, self.bname)
1321
1321
1322 def _run(self, env):
1322 def _run(self, env):
1323 with open(self.path, 'rb') as f:
1323 with open(self.path, 'rb') as f:
1324 lines = f.readlines()
1324 lines = f.readlines()
1325
1325
1326 # .t file is both reference output and the test input, keep reference
1326 # .t file is both reference output and the test input, keep reference
1327 # output updated with the the test input. This avoids some race
1327 # output updated with the the test input. This avoids some race
1328 # conditions where the reference output does not match the actual test.
1328 # conditions where the reference output does not match the actual test.
1329 if self._refout is not None:
1329 if self._refout is not None:
1330 self._refout = lines
1330 self._refout = lines
1331
1331
1332 salt, script, after, expected = self._parsetest(lines)
1332 salt, script, after, expected = self._parsetest(lines)
1333
1333
1334 # Write out the generated script.
1334 # Write out the generated script.
1335 fname = b'%s.sh' % self._testtmp
1335 fname = b'%s.sh' % self._testtmp
1336 with open(fname, 'wb') as f:
1336 with open(fname, 'wb') as f:
1337 for l in script:
1337 for l in script:
1338 f.write(l)
1338 f.write(l)
1339
1339
1340 cmd = b'%s "%s"' % (self._shell, fname)
1340 cmd = b'%s "%s"' % (self._shell, fname)
1341 vlog("# Running", cmd)
1341 vlog("# Running", cmd)
1342
1342
1343 exitcode, output = self._runcommand(cmd, env)
1343 exitcode, output = self._runcommand(cmd, env)
1344
1344
1345 if self._aborted:
1345 if self._aborted:
1346 raise KeyboardInterrupt()
1346 raise KeyboardInterrupt()
1347
1347
1348 # Do not merge output if skipped. Return hghave message instead.
1348 # Do not merge output if skipped. Return hghave message instead.
1349 # Similarly, with --debug, output is None.
1349 # Similarly, with --debug, output is None.
1350 if exitcode == self.SKIPPED_STATUS or output is None:
1350 if exitcode == self.SKIPPED_STATUS or output is None:
1351 return exitcode, output
1351 return exitcode, output
1352
1352
1353 return self._processoutput(exitcode, output, salt, after, expected)
1353 return self._processoutput(exitcode, output, salt, after, expected)
1354
1354
1355 def _hghave(self, reqs):
1355 def _hghave(self, reqs):
1356 allreqs = b' '.join(reqs)
1356 allreqs = b' '.join(reqs)
1357 if allreqs in self._have:
1357 if allreqs in self._have:
1358 return self._have.get(allreqs)
1358 return self._have.get(allreqs)
1359
1359
1360 # TODO do something smarter when all other uses of hghave are gone.
1360 # TODO do something smarter when all other uses of hghave are gone.
1361 runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__)))
1361 runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__)))
1362 tdir = runtestdir.replace(b'\\', b'/')
1362 tdir = runtestdir.replace(b'\\', b'/')
1363 proc = Popen4(b'%s -c "%s/hghave %s"' %
1363 proc = Popen4(b'%s -c "%s/hghave %s"' %
1364 (self._shell, tdir, allreqs),
1364 (self._shell, tdir, allreqs),
1365 self._testtmp, 0, self._getenv())
1365 self._testtmp, 0, self._getenv())
1366 stdout, stderr = proc.communicate()
1366 stdout, stderr = proc.communicate()
1367 ret = proc.wait()
1367 ret = proc.wait()
1368 if wifexited(ret):
1368 if wifexited(ret):
1369 ret = os.WEXITSTATUS(ret)
1369 ret = os.WEXITSTATUS(ret)
1370 if ret == 2:
1370 if ret == 2:
1371 print(stdout.decode('utf-8'))
1371 print(stdout.decode('utf-8'))
1372 sys.exit(1)
1372 sys.exit(1)
1373
1373
1374 if ret != 0:
1374 if ret != 0:
1375 self._have[allreqs] = (False, stdout)
1375 self._have[allreqs] = (False, stdout)
1376 return False, stdout
1376 return False, stdout
1377
1377
1378 if b'slow' in reqs:
1378 if b'slow' in reqs:
1379 self._timeout = self._slowtimeout
1379 self._timeout = self._slowtimeout
1380
1380
1381 self._have[allreqs] = (True, None)
1381 self._have[allreqs] = (True, None)
1382 return True, None
1382 return True, None
1383
1383
1384 def _iftest(self, args):
1384 def _iftest(self, args):
1385 # implements "#if"
1385 # implements "#if"
1386 reqs = []
1386 reqs = []
1387 for arg in args:
1387 for arg in args:
1388 if arg.startswith(b'no-') and arg[3:] in self._allcases:
1388 if arg.startswith(b'no-') and arg[3:] in self._allcases:
1389 if arg[3:] in self._case:
1389 if arg[3:] in self._case:
1390 return False
1390 return False
1391 elif arg in self._allcases:
1391 elif arg in self._allcases:
1392 if arg not in self._case:
1392 if arg not in self._case:
1393 return False
1393 return False
1394 else:
1394 else:
1395 reqs.append(arg)
1395 reqs.append(arg)
1396 return self._hghave(reqs)[0]
1396 return self._hghave(reqs)[0]
1397
1397
1398 def _parsetest(self, lines):
1398 def _parsetest(self, lines):
1399 # We generate a shell script which outputs unique markers to line
1399 # We generate a shell script which outputs unique markers to line
1400 # up script results with our source. These markers include input
1400 # up script results with our source. These markers include input
1401 # line number and the last return code.
1401 # line number and the last return code.
1402 salt = b"SALT%d" % time.time()
1402 salt = b"SALT%d" % time.time()
1403 def addsalt(line, inpython):
1403 def addsalt(line, inpython):
1404 if inpython:
1404 if inpython:
1405 script.append(b'%s %d 0\n' % (salt, line))
1405 script.append(b'%s %d 0\n' % (salt, line))
1406 else:
1406 else:
1407 script.append(b'echo %s %d $?\n' % (salt, line))
1407 script.append(b'echo %s %d $?\n' % (salt, line))
1408 activetrace = []
1408 activetrace = []
1409 session = str(uuid.uuid4())
1409 session = str(uuid.uuid4())
1410 if PYTHON3:
1410 if PYTHON3:
1411 session = session.encode('ascii')
1411 session = session.encode('ascii')
1412 hgcatapult = os.getenv('HGTESTCATAPULTSERVERPIPE')
1412 hgcatapult = os.getenv('HGTESTCATAPULTSERVERPIPE')
1413 def toggletrace(cmd=None):
1413 def toggletrace(cmd=None):
1414 if not hgcatapult or hgcatapult == os.devnull:
1414 if not hgcatapult or hgcatapult == os.devnull:
1415 return
1415 return
1416
1416
1417 if activetrace:
1417 if activetrace:
1418 script.append(
1418 script.append(
1419 b'echo END %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % (
1419 b'echo END %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % (
1420 session, activetrace[0]))
1420 session, activetrace[0]))
1421 if cmd is None:
1421 if cmd is None:
1422 return
1422 return
1423
1423
1424 if isinstance(cmd, str):
1424 if isinstance(cmd, str):
1425 quoted = shellquote(cmd.strip())
1425 quoted = shellquote(cmd.strip())
1426 else:
1426 else:
1427 quoted = shellquote(cmd.strip().decode('utf8')).encode('utf8')
1427 quoted = shellquote(cmd.strip().decode('utf8')).encode('utf8')
1428 quoted = quoted.replace(b'\\', b'\\\\')
1428 quoted = quoted.replace(b'\\', b'\\\\')
1429 script.append(
1429 script.append(
1430 b'echo START %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % (
1430 b'echo START %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % (
1431 session, quoted))
1431 session, quoted))
1432 activetrace[0:] = [quoted]
1432 activetrace[0:] = [quoted]
1433
1433
1434 script = []
1434 script = []
1435
1435
1436 # After we run the shell script, we re-unify the script output
1436 # After we run the shell script, we re-unify the script output
1437 # with non-active parts of the source, with synchronization by our
1437 # with non-active parts of the source, with synchronization by our
1438 # SALT line number markers. The after table contains the non-active
1438 # SALT line number markers. The after table contains the non-active
1439 # components, ordered by line number.
1439 # components, ordered by line number.
1440 after = {}
1440 after = {}
1441
1441
1442 # Expected shell script output.
1442 # Expected shell script output.
1443 expected = {}
1443 expected = {}
1444
1444
1445 pos = prepos = -1
1445 pos = prepos = -1
1446
1446
1447 # True or False when in a true or false conditional section
1447 # True or False when in a true or false conditional section
1448 skipping = None
1448 skipping = None
1449
1449
1450 # We keep track of whether or not we're in a Python block so we
1450 # We keep track of whether or not we're in a Python block so we
1451 # can generate the surrounding doctest magic.
1451 # can generate the surrounding doctest magic.
1452 inpython = False
1452 inpython = False
1453
1453
1454 if self._debug:
1454 if self._debug:
1455 script.append(b'set -x\n')
1455 script.append(b'set -x\n')
1456 if self._hgcommand != b'hg':
1456 if self._hgcommand != b'hg':
1457 script.append(b'alias hg="%s"\n' % self._hgcommand)
1457 script.append(b'alias hg="%s"\n' % self._hgcommand)
1458 if os.getenv('MSYSTEM'):
1458 if os.getenv('MSYSTEM'):
1459 script.append(b'alias pwd="pwd -W"\n')
1459 script.append(b'alias pwd="pwd -W"\n')
1460
1460
1461 if hgcatapult and hgcatapult != os.devnull:
1461 if hgcatapult and hgcatapult != os.devnull:
1462 # Kludge: use a while loop to keep the pipe from getting
1462 # Kludge: use a while loop to keep the pipe from getting
1463 # closed by our echo commands. The still-running file gets
1463 # closed by our echo commands. The still-running file gets
1464 # reaped at the end of the script, which causes the while
1464 # reaped at the end of the script, which causes the while
1465 # loop to exit and closes the pipe. Sigh.
1465 # loop to exit and closes the pipe. Sigh.
1466 script.append(
1466 script.append(
1467 b'rtendtracing() {\n'
1467 b'rtendtracing() {\n'
1468 b' echo END %(session)s %(name)s >> %(catapult)s\n'
1468 b' echo END %(session)s %(name)s >> %(catapult)s\n'
1469 b' rm -f "$TESTTMP/.still-running"\n'
1469 b' rm -f "$TESTTMP/.still-running"\n'
1470 b'}\n'
1470 b'}\n'
1471 b'trap "rtendtracing" 0\n'
1471 b'trap "rtendtracing" 0\n'
1472 b'touch "$TESTTMP/.still-running"\n'
1472 b'touch "$TESTTMP/.still-running"\n'
1473 b'while [ -f "$TESTTMP/.still-running" ]; do sleep 1; done '
1473 b'while [ -f "$TESTTMP/.still-running" ]; do sleep 1; done '
1474 b'> %(catapult)s &\n'
1474 b'> %(catapult)s &\n'
1475 b'HGCATAPULTSESSION=%(session)s ; export HGCATAPULTSESSION\n'
1475 b'HGCATAPULTSESSION=%(session)s ; export HGCATAPULTSESSION\n'
1476 b'echo START %(session)s %(name)s >> %(catapult)s\n'
1476 b'echo START %(session)s %(name)s >> %(catapult)s\n'
1477 % {
1477 % {
1478 'name': self.name,
1478 'name': self.name,
1479 'session': session,
1479 'session': session,
1480 'catapult': hgcatapult,
1480 'catapult': hgcatapult,
1481 }
1481 }
1482 )
1482 )
1483
1483
1484 if self._case:
1484 if self._case:
1485 casestr = b'#'.join(self._case)
1485 casestr = b'#'.join(self._case)
1486 if isinstance(self._case, str):
1486 if isinstance(self._case, str):
1487 quoted = shellquote(casestr)
1487 quoted = shellquote(casestr)
1488 else:
1488 else:
1489 quoted = shellquote(casestr.decode('utf8')).encode('utf8')
1489 quoted = shellquote(casestr.decode('utf8')).encode('utf8')
1490 script.append(b'TESTCASE=%s\n' % quoted)
1490 script.append(b'TESTCASE=%s\n' % quoted)
1491 script.append(b'export TESTCASE\n')
1491 script.append(b'export TESTCASE\n')
1492
1492
1493 n = 0
1493 n = 0
1494 for n, l in enumerate(lines):
1494 for n, l in enumerate(lines):
1495 if not l.endswith(b'\n'):
1495 if not l.endswith(b'\n'):
1496 l += b'\n'
1496 l += b'\n'
1497 if l.startswith(b'#require'):
1497 if l.startswith(b'#require'):
1498 lsplit = l.split()
1498 lsplit = l.split()
1499 if len(lsplit) < 2 or lsplit[0] != b'#require':
1499 if len(lsplit) < 2 or lsplit[0] != b'#require':
1500 after.setdefault(pos, []).append(' !!! invalid #require\n')
1500 after.setdefault(pos, []).append(' !!! invalid #require\n')
1501 if not skipping:
1501 if not skipping:
1502 haveresult, message = self._hghave(lsplit[1:])
1502 haveresult, message = self._hghave(lsplit[1:])
1503 if not haveresult:
1503 if not haveresult:
1504 script = [b'echo "%s"\nexit 80\n' % message]
1504 script = [b'echo "%s"\nexit 80\n' % message]
1505 break
1505 break
1506 after.setdefault(pos, []).append(l)
1506 after.setdefault(pos, []).append(l)
1507 elif l.startswith(b'#if'):
1507 elif l.startswith(b'#if'):
1508 lsplit = l.split()
1508 lsplit = l.split()
1509 if len(lsplit) < 2 or lsplit[0] != b'#if':
1509 if len(lsplit) < 2 or lsplit[0] != b'#if':
1510 after.setdefault(pos, []).append(' !!! invalid #if\n')
1510 after.setdefault(pos, []).append(' !!! invalid #if\n')
1511 if skipping is not None:
1511 if skipping is not None:
1512 after.setdefault(pos, []).append(' !!! nested #if\n')
1512 after.setdefault(pos, []).append(' !!! nested #if\n')
1513 skipping = not self._iftest(lsplit[1:])
1513 skipping = not self._iftest(lsplit[1:])
1514 after.setdefault(pos, []).append(l)
1514 after.setdefault(pos, []).append(l)
1515 elif l.startswith(b'#else'):
1515 elif l.startswith(b'#else'):
1516 if skipping is None:
1516 if skipping is None:
1517 after.setdefault(pos, []).append(' !!! missing #if\n')
1517 after.setdefault(pos, []).append(' !!! missing #if\n')
1518 skipping = not skipping
1518 skipping = not skipping
1519 after.setdefault(pos, []).append(l)
1519 after.setdefault(pos, []).append(l)
1520 elif l.startswith(b'#endif'):
1520 elif l.startswith(b'#endif'):
1521 if skipping is None:
1521 if skipping is None:
1522 after.setdefault(pos, []).append(' !!! missing #if\n')
1522 after.setdefault(pos, []).append(' !!! missing #if\n')
1523 skipping = None
1523 skipping = None
1524 after.setdefault(pos, []).append(l)
1524 after.setdefault(pos, []).append(l)
1525 elif skipping:
1525 elif skipping:
1526 after.setdefault(pos, []).append(l)
1526 after.setdefault(pos, []).append(l)
1527 elif l.startswith(b' >>> '): # python inlines
1527 elif l.startswith(b' >>> '): # python inlines
1528 after.setdefault(pos, []).append(l)
1528 after.setdefault(pos, []).append(l)
1529 prepos = pos
1529 prepos = pos
1530 pos = n
1530 pos = n
1531 if not inpython:
1531 if not inpython:
1532 # We've just entered a Python block. Add the header.
1532 # We've just entered a Python block. Add the header.
1533 inpython = True
1533 inpython = True
1534 addsalt(prepos, False) # Make sure we report the exit code.
1534 addsalt(prepos, False) # Make sure we report the exit code.
1535 script.append(b'"%s" -m heredoctest <<EOF\n' % PYTHON)
1535 script.append(b'"%s" -m heredoctest <<EOF\n' % PYTHON)
1536 addsalt(n, True)
1536 addsalt(n, True)
1537 script.append(l[2:])
1537 script.append(l[2:])
1538 elif l.startswith(b' ... '): # python inlines
1538 elif l.startswith(b' ... '): # python inlines
1539 after.setdefault(prepos, []).append(l)
1539 after.setdefault(prepos, []).append(l)
1540 script.append(l[2:])
1540 script.append(l[2:])
1541 elif l.startswith(b' $ '): # commands
1541 elif l.startswith(b' $ '): # commands
1542 if inpython:
1542 if inpython:
1543 script.append(b'EOF\n')
1543 script.append(b'EOF\n')
1544 inpython = False
1544 inpython = False
1545 after.setdefault(pos, []).append(l)
1545 after.setdefault(pos, []).append(l)
1546 prepos = pos
1546 prepos = pos
1547 pos = n
1547 pos = n
1548 addsalt(n, False)
1548 addsalt(n, False)
1549 rawcmd = l[4:]
1549 rawcmd = l[4:]
1550 cmd = rawcmd.split()
1550 cmd = rawcmd.split()
1551 toggletrace(rawcmd)
1551 toggletrace(rawcmd)
1552 if len(cmd) == 2 and cmd[0] == b'cd':
1552 if len(cmd) == 2 and cmd[0] == b'cd':
1553 l = b' $ cd %s || exit 1\n' % cmd[1]
1553 l = b' $ cd %s || exit 1\n' % cmd[1]
1554 script.append(rawcmd)
1554 script.append(rawcmd)
1555 elif l.startswith(b' > '): # continuations
1555 elif l.startswith(b' > '): # continuations
1556 after.setdefault(prepos, []).append(l)
1556 after.setdefault(prepos, []).append(l)
1557 script.append(l[4:])
1557 script.append(l[4:])
1558 elif l.startswith(b' '): # results
1558 elif l.startswith(b' '): # results
1559 # Queue up a list of expected results.
1559 # Queue up a list of expected results.
1560 expected.setdefault(pos, []).append(l[2:])
1560 expected.setdefault(pos, []).append(l[2:])
1561 else:
1561 else:
1562 if inpython:
1562 if inpython:
1563 script.append(b'EOF\n')
1563 script.append(b'EOF\n')
1564 inpython = False
1564 inpython = False
1565 # Non-command/result. Queue up for merged output.
1565 # Non-command/result. Queue up for merged output.
1566 after.setdefault(pos, []).append(l)
1566 after.setdefault(pos, []).append(l)
1567
1567
1568 if inpython:
1568 if inpython:
1569 script.append(b'EOF\n')
1569 script.append(b'EOF\n')
1570 if skipping is not None:
1570 if skipping is not None:
1571 after.setdefault(pos, []).append(' !!! missing #endif\n')
1571 after.setdefault(pos, []).append(' !!! missing #endif\n')
1572 addsalt(n + 1, False)
1572 addsalt(n + 1, False)
1573 # Need to end any current per-command trace
1573 # Need to end any current per-command trace
1574 if activetrace:
1574 if activetrace:
1575 toggletrace()
1575 toggletrace()
1576 return salt, script, after, expected
1576 return salt, script, after, expected
1577
1577
1578 def _processoutput(self, exitcode, output, salt, after, expected):
1578 def _processoutput(self, exitcode, output, salt, after, expected):
1579 # Merge the script output back into a unified test.
1579 # Merge the script output back into a unified test.
1580 warnonly = 1 # 1: not yet; 2: yes; 3: for sure not
1580 warnonly = 1 # 1: not yet; 2: yes; 3: for sure not
1581 if exitcode != 0:
1581 if exitcode != 0:
1582 warnonly = 3
1582 warnonly = 3
1583
1583
1584 pos = -1
1584 pos = -1
1585 postout = []
1585 postout = []
1586 for l in output:
1586 for l in output:
1587 lout, lcmd = l, None
1587 lout, lcmd = l, None
1588 if salt in l:
1588 if salt in l:
1589 lout, lcmd = l.split(salt, 1)
1589 lout, lcmd = l.split(salt, 1)
1590
1590
1591 while lout:
1591 while lout:
1592 if not lout.endswith(b'\n'):
1592 if not lout.endswith(b'\n'):
1593 lout += b' (no-eol)\n'
1593 lout += b' (no-eol)\n'
1594
1594
1595 # Find the expected output at the current position.
1595 # Find the expected output at the current position.
1596 els = [None]
1596 els = [None]
1597 if expected.get(pos, None):
1597 if expected.get(pos, None):
1598 els = expected[pos]
1598 els = expected[pos]
1599
1599
1600 optional = []
1600 optional = []
1601 for i, el in enumerate(els):
1601 for i, el in enumerate(els):
1602 r = False
1602 r = False
1603 if el:
1603 if el:
1604 r, exact = self.linematch(el, lout)
1604 r, exact = self.linematch(el, lout)
1605 if isinstance(r, str):
1605 if isinstance(r, str):
1606 if r == '-glob':
1606 if r == '-glob':
1607 lout = ''.join(el.rsplit(' (glob)', 1))
1607 lout = ''.join(el.rsplit(' (glob)', 1))
1608 r = '' # Warn only this line.
1608 r = '' # Warn only this line.
1609 elif r == "retry":
1609 elif r == "retry":
1610 postout.append(b' ' + el)
1610 postout.append(b' ' + el)
1611 else:
1611 else:
1612 log('\ninfo, unknown linematch result: %r\n' % r)
1612 log('\ninfo, unknown linematch result: %r\n' % r)
1613 r = False
1613 r = False
1614 if r:
1614 if r:
1615 els.pop(i)
1615 els.pop(i)
1616 break
1616 break
1617 if el:
1617 if el:
1618 if el.endswith(b" (?)\n"):
1618 if el.endswith(b" (?)\n"):
1619 optional.append(i)
1619 optional.append(i)
1620 else:
1620 else:
1621 m = optline.match(el)
1621 m = optline.match(el)
1622 if m:
1622 if m:
1623 conditions = [
1623 conditions = [
1624 c for c in m.group(2).split(b' ')]
1624 c for c in m.group(2).split(b' ')]
1625
1625
1626 if not self._iftest(conditions):
1626 if not self._iftest(conditions):
1627 optional.append(i)
1627 optional.append(i)
1628 if exact:
1628 if exact:
1629 # Don't allow line to be matches against a later
1629 # Don't allow line to be matches against a later
1630 # line in the output
1630 # line in the output
1631 els.pop(i)
1631 els.pop(i)
1632 break
1632 break
1633
1633
1634 if r:
1634 if r:
1635 if r == "retry":
1635 if r == "retry":
1636 continue
1636 continue
1637 # clean up any optional leftovers
1637 # clean up any optional leftovers
1638 for i in optional:
1638 for i in optional:
1639 postout.append(b' ' + els[i])
1639 postout.append(b' ' + els[i])
1640 for i in reversed(optional):
1640 for i in reversed(optional):
1641 del els[i]
1641 del els[i]
1642 postout.append(b' ' + el)
1642 postout.append(b' ' + el)
1643 else:
1643 else:
1644 if self.NEEDESCAPE(lout):
1644 if self.NEEDESCAPE(lout):
1645 lout = TTest._stringescape(b'%s (esc)\n' %
1645 lout = TTest._stringescape(b'%s (esc)\n' %
1646 lout.rstrip(b'\n'))
1646 lout.rstrip(b'\n'))
1647 postout.append(b' ' + lout) # Let diff deal with it.
1647 postout.append(b' ' + lout) # Let diff deal with it.
1648 if r != '': # If line failed.
1648 if r != '': # If line failed.
1649 warnonly = 3 # for sure not
1649 warnonly = 3 # for sure not
1650 elif warnonly == 1: # Is "not yet" and line is warn only.
1650 elif warnonly == 1: # Is "not yet" and line is warn only.
1651 warnonly = 2 # Yes do warn.
1651 warnonly = 2 # Yes do warn.
1652 break
1652 break
1653 else:
1653 else:
1654 # clean up any optional leftovers
1654 # clean up any optional leftovers
1655 while expected.get(pos, None):
1655 while expected.get(pos, None):
1656 el = expected[pos].pop(0)
1656 el = expected[pos].pop(0)
1657 if el:
1657 if el:
1658 if not el.endswith(b" (?)\n"):
1658 if not el.endswith(b" (?)\n"):
1659 m = optline.match(el)
1659 m = optline.match(el)
1660 if m:
1660 if m:
1661 conditions = [c for c in m.group(2).split(b' ')]
1661 conditions = [c for c in m.group(2).split(b' ')]
1662
1662
1663 if self._iftest(conditions):
1663 if self._iftest(conditions):
1664 # Don't append as optional line
1664 # Don't append as optional line
1665 continue
1665 continue
1666 else:
1666 else:
1667 continue
1667 continue
1668 postout.append(b' ' + el)
1668 postout.append(b' ' + el)
1669
1669
1670 if lcmd:
1670 if lcmd:
1671 # Add on last return code.
1671 # Add on last return code.
1672 ret = int(lcmd.split()[1])
1672 ret = int(lcmd.split()[1])
1673 if ret != 0:
1673 if ret != 0:
1674 postout.append(b' [%d]\n' % ret)
1674 postout.append(b' [%d]\n' % ret)
1675 if pos in after:
1675 if pos in after:
1676 # Merge in non-active test bits.
1676 # Merge in non-active test bits.
1677 postout += after.pop(pos)
1677 postout += after.pop(pos)
1678 pos = int(lcmd.split()[0])
1678 pos = int(lcmd.split()[0])
1679
1679
1680 if pos in after:
1680 if pos in after:
1681 postout += after.pop(pos)
1681 postout += after.pop(pos)
1682
1682
1683 if warnonly == 2:
1683 if warnonly == 2:
1684 exitcode = False # Set exitcode to warned.
1684 exitcode = False # Set exitcode to warned.
1685
1685
1686 return exitcode, postout
1686 return exitcode, postout
1687
1687
1688 @staticmethod
1688 @staticmethod
1689 def rematch(el, l):
1689 def rematch(el, l):
1690 try:
1690 try:
1691 el = b'(?:' + el + b')'
1691 el = b'(?:' + el + b')'
1692 # use \Z to ensure that the regex matches to the end of the string
1692 # use \Z to ensure that the regex matches to the end of the string
1693 if os.name == 'nt':
1693 if os.name == 'nt':
1694 return re.match(el + br'\r?\n\Z', l)
1694 return re.match(el + br'\r?\n\Z', l)
1695 return re.match(el + br'\n\Z', l)
1695 return re.match(el + br'\n\Z', l)
1696 except re.error:
1696 except re.error:
1697 # el is an invalid regex
1697 # el is an invalid regex
1698 return False
1698 return False
1699
1699
1700 @staticmethod
1700 @staticmethod
1701 def globmatch(el, l):
1701 def globmatch(el, l):
1702 # The only supported special characters are * and ? plus / which also
1702 # The only supported special characters are * and ? plus / which also
1703 # matches \ on windows. Escaping of these characters is supported.
1703 # matches \ on windows. Escaping of these characters is supported.
1704 if el + b'\n' == l:
1704 if el + b'\n' == l:
1705 if os.altsep:
1705 if os.altsep:
1706 # matching on "/" is not needed for this line
1706 # matching on "/" is not needed for this line
1707 for pat in checkcodeglobpats:
1707 for pat in checkcodeglobpats:
1708 if pat.match(el):
1708 if pat.match(el):
1709 return True
1709 return True
1710 return b'-glob'
1710 return b'-glob'
1711 return True
1711 return True
1712 el = el.replace(b'$LOCALIP', b'*')
1712 el = el.replace(b'$LOCALIP', b'*')
1713 i, n = 0, len(el)
1713 i, n = 0, len(el)
1714 res = b''
1714 res = b''
1715 while i < n:
1715 while i < n:
1716 c = el[i:i + 1]
1716 c = el[i:i + 1]
1717 i += 1
1717 i += 1
1718 if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/':
1718 if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/':
1719 res += el[i - 1:i + 1]
1719 res += el[i - 1:i + 1]
1720 i += 1
1720 i += 1
1721 elif c == b'*':
1721 elif c == b'*':
1722 res += b'.*'
1722 res += b'.*'
1723 elif c == b'?':
1723 elif c == b'?':
1724 res += b'.'
1724 res += b'.'
1725 elif c == b'/' and os.altsep:
1725 elif c == b'/' and os.altsep:
1726 res += b'[/\\\\]'
1726 res += b'[/\\\\]'
1727 else:
1727 else:
1728 res += re.escape(c)
1728 res += re.escape(c)
1729 return TTest.rematch(res, l)
1729 return TTest.rematch(res, l)
1730
1730
1731 def linematch(self, el, l):
1731 def linematch(self, el, l):
1732 if el == l: # perfect match (fast)
1732 if el == l: # perfect match (fast)
1733 return True, True
1733 return True, True
1734 retry = False
1734 retry = False
1735 if el.endswith(b" (?)\n"):
1735 if el.endswith(b" (?)\n"):
1736 retry = "retry"
1736 retry = "retry"
1737 el = el[:-5] + b"\n"
1737 el = el[:-5] + b"\n"
1738 else:
1738 else:
1739 m = optline.match(el)
1739 m = optline.match(el)
1740 if m:
1740 if m:
1741 conditions = [c for c in m.group(2).split(b' ')]
1741 conditions = [c for c in m.group(2).split(b' ')]
1742
1742
1743 el = m.group(1) + b"\n"
1743 el = m.group(1) + b"\n"
1744 if not self._iftest(conditions):
1744 if not self._iftest(conditions):
1745 retry = "retry" # Not required by listed features
1745 retry = "retry" # Not required by listed features
1746
1746
1747 if el.endswith(b" (esc)\n"):
1747 if el.endswith(b" (esc)\n"):
1748 if PYTHON3:
1748 if PYTHON3:
1749 el = el[:-7].decode('unicode_escape') + '\n'
1749 el = el[:-7].decode('unicode_escape') + '\n'
1750 el = el.encode('utf-8')
1750 el = el.encode('utf-8')
1751 else:
1751 else:
1752 el = el[:-7].decode('string-escape') + '\n'
1752 el = el[:-7].decode('string-escape') + '\n'
1753 if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:
1753 if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:
1754 return True, True
1754 return True, True
1755 if el.endswith(b" (re)\n"):
1755 if el.endswith(b" (re)\n"):
1756 return (TTest.rematch(el[:-6], l) or retry), False
1756 return (TTest.rematch(el[:-6], l) or retry), False
1757 if el.endswith(b" (glob)\n"):
1757 if el.endswith(b" (glob)\n"):
1758 # ignore '(glob)' added to l by 'replacements'
1758 # ignore '(glob)' added to l by 'replacements'
1759 if l.endswith(b" (glob)\n"):
1759 if l.endswith(b" (glob)\n"):
1760 l = l[:-8] + b"\n"
1760 l = l[:-8] + b"\n"
1761 return (TTest.globmatch(el[:-8], l) or retry), False
1761 return (TTest.globmatch(el[:-8], l) or retry), False
1762 if os.altsep:
1762 if os.altsep:
1763 _l = l.replace(b'\\', b'/')
1763 _l = l.replace(b'\\', b'/')
1764 if el == _l or os.name == 'nt' and el[:-1] + b'\r\n' == _l:
1764 if el == _l or os.name == 'nt' and el[:-1] + b'\r\n' == _l:
1765 return True, True
1765 return True, True
1766 return retry, True
1766 return retry, True
1767
1767
1768 @staticmethod
1768 @staticmethod
1769 def parsehghaveoutput(lines):
1769 def parsehghaveoutput(lines):
1770 '''Parse hghave log lines.
1770 '''Parse hghave log lines.
1771
1771
1772 Return tuple of lists (missing, failed):
1772 Return tuple of lists (missing, failed):
1773 * the missing/unknown features
1773 * the missing/unknown features
1774 * the features for which existence check failed'''
1774 * the features for which existence check failed'''
1775 missing = []
1775 missing = []
1776 failed = []
1776 failed = []
1777 for line in lines:
1777 for line in lines:
1778 if line.startswith(TTest.SKIPPED_PREFIX):
1778 if line.startswith(TTest.SKIPPED_PREFIX):
1779 line = line.splitlines()[0]
1779 line = line.splitlines()[0]
1780 missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8'))
1780 missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8'))
1781 elif line.startswith(TTest.FAILED_PREFIX):
1781 elif line.startswith(TTest.FAILED_PREFIX):
1782 line = line.splitlines()[0]
1782 line = line.splitlines()[0]
1783 failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8'))
1783 failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8'))
1784
1784
1785 return missing, failed
1785 return missing, failed
1786
1786
1787 @staticmethod
1787 @staticmethod
1788 def _escapef(m):
1788 def _escapef(m):
1789 return TTest.ESCAPEMAP[m.group(0)]
1789 return TTest.ESCAPEMAP[m.group(0)]
1790
1790
1791 @staticmethod
1791 @staticmethod
1792 def _stringescape(s):
1792 def _stringescape(s):
1793 return TTest.ESCAPESUB(TTest._escapef, s)
1793 return TTest.ESCAPESUB(TTest._escapef, s)
1794
1794
1795 iolock = threading.RLock()
1795 iolock = threading.RLock()
1796 firstlock = threading.RLock()
1796 firstlock = threading.RLock()
1797 firsterror = False
1797 firsterror = False
1798
1798
1799 class TestResult(unittest._TextTestResult):
1799 class TestResult(unittest._TextTestResult):
1800 """Holds results when executing via unittest."""
1800 """Holds results when executing via unittest."""
1801 # Don't worry too much about accessing the non-public _TextTestResult.
1801 # Don't worry too much about accessing the non-public _TextTestResult.
1802 # It is relatively common in Python testing tools.
1802 # It is relatively common in Python testing tools.
1803 def __init__(self, options, *args, **kwargs):
1803 def __init__(self, options, *args, **kwargs):
1804 super(TestResult, self).__init__(*args, **kwargs)
1804 super(TestResult, self).__init__(*args, **kwargs)
1805
1805
1806 self._options = options
1806 self._options = options
1807
1807
1808 # unittest.TestResult didn't have skipped until 2.7. We need to
1808 # unittest.TestResult didn't have skipped until 2.7. We need to
1809 # polyfill it.
1809 # polyfill it.
1810 self.skipped = []
1810 self.skipped = []
1811
1811
1812 # We have a custom "ignored" result that isn't present in any Python
1812 # We have a custom "ignored" result that isn't present in any Python
1813 # unittest implementation. It is very similar to skipped. It may make
1813 # unittest implementation. It is very similar to skipped. It may make
1814 # sense to map it into skip some day.
1814 # sense to map it into skip some day.
1815 self.ignored = []
1815 self.ignored = []
1816
1816
1817 self.times = []
1817 self.times = []
1818 self._firststarttime = None
1818 self._firststarttime = None
1819 # Data stored for the benefit of generating xunit reports.
1819 # Data stored for the benefit of generating xunit reports.
1820 self.successes = []
1820 self.successes = []
1821 self.faildata = {}
1821 self.faildata = {}
1822
1822
1823 if options.color == 'auto':
1823 if options.color == 'auto':
1824 self.color = pygmentspresent and self.stream.isatty()
1824 self.color = pygmentspresent and self.stream.isatty()
1825 elif options.color == 'never':
1825 elif options.color == 'never':
1826 self.color = False
1826 self.color = False
1827 else: # 'always', for testing purposes
1827 else: # 'always', for testing purposes
1828 self.color = pygmentspresent
1828 self.color = pygmentspresent
1829
1829
1830 def onStart(self, test):
1830 def onStart(self, test):
1831 """ Can be overriden by custom TestResult
1831 """ Can be overriden by custom TestResult
1832 """
1832 """
1833
1833
1834 def onEnd(self):
1834 def onEnd(self):
1835 """ Can be overriden by custom TestResult
1835 """ Can be overriden by custom TestResult
1836 """
1836 """
1837
1837
1838 def addFailure(self, test, reason):
1838 def addFailure(self, test, reason):
1839 self.failures.append((test, reason))
1839 self.failures.append((test, reason))
1840
1840
1841 if self._options.first:
1841 if self._options.first:
1842 self.stop()
1842 self.stop()
1843 else:
1843 else:
1844 with iolock:
1844 with iolock:
1845 if reason == "timed out":
1845 if reason == "timed out":
1846 self.stream.write('t')
1846 self.stream.write('t')
1847 else:
1847 else:
1848 if not self._options.nodiff:
1848 if not self._options.nodiff:
1849 self.stream.write('\n')
1849 self.stream.write('\n')
1850 # Exclude the '\n' from highlighting to lex correctly
1850 # Exclude the '\n' from highlighting to lex correctly
1851 formatted = 'ERROR: %s output changed\n' % test
1851 formatted = 'ERROR: %s output changed\n' % test
1852 self.stream.write(highlightmsg(formatted, self.color))
1852 self.stream.write(highlightmsg(formatted, self.color))
1853 self.stream.write('!')
1853 self.stream.write('!')
1854
1854
1855 self.stream.flush()
1855 self.stream.flush()
1856
1856
1857 def addSuccess(self, test):
1857 def addSuccess(self, test):
1858 with iolock:
1858 with iolock:
1859 super(TestResult, self).addSuccess(test)
1859 super(TestResult, self).addSuccess(test)
1860 self.successes.append(test)
1860 self.successes.append(test)
1861
1861
1862 def addError(self, test, err):
1862 def addError(self, test, err):
1863 super(TestResult, self).addError(test, err)
1863 super(TestResult, self).addError(test, err)
1864 if self._options.first:
1864 if self._options.first:
1865 self.stop()
1865 self.stop()
1866
1866
1867 # Polyfill.
1867 # Polyfill.
1868 def addSkip(self, test, reason):
1868 def addSkip(self, test, reason):
1869 self.skipped.append((test, reason))
1869 self.skipped.append((test, reason))
1870 with iolock:
1870 with iolock:
1871 if self.showAll:
1871 if self.showAll:
1872 self.stream.writeln('skipped %s' % reason)
1872 self.stream.writeln('skipped %s' % reason)
1873 else:
1873 else:
1874 self.stream.write('s')
1874 self.stream.write('s')
1875 self.stream.flush()
1875 self.stream.flush()
1876
1876
1877 def addIgnore(self, test, reason):
1877 def addIgnore(self, test, reason):
1878 self.ignored.append((test, reason))
1878 self.ignored.append((test, reason))
1879 with iolock:
1879 with iolock:
1880 if self.showAll:
1880 if self.showAll:
1881 self.stream.writeln('ignored %s' % reason)
1881 self.stream.writeln('ignored %s' % reason)
1882 else:
1882 else:
1883 if reason not in ('not retesting', "doesn't match keyword"):
1883 if reason not in ('not retesting', "doesn't match keyword"):
1884 self.stream.write('i')
1884 self.stream.write('i')
1885 else:
1885 else:
1886 self.testsRun += 1
1886 self.testsRun += 1
1887 self.stream.flush()
1887 self.stream.flush()
1888
1888
1889 def addOutputMismatch(self, test, ret, got, expected):
1889 def addOutputMismatch(self, test, ret, got, expected):
1890 """Record a mismatch in test output for a particular test."""
1890 """Record a mismatch in test output for a particular test."""
1891 if self.shouldStop or firsterror:
1891 if self.shouldStop or firsterror:
1892 # don't print, some other test case already failed and
1892 # don't print, some other test case already failed and
1893 # printed, we're just stale and probably failed due to our
1893 # printed, we're just stale and probably failed due to our
1894 # temp dir getting cleaned up.
1894 # temp dir getting cleaned up.
1895 return
1895 return
1896
1896
1897 accepted = False
1897 accepted = False
1898 lines = []
1898 lines = []
1899
1899
1900 with iolock:
1900 with iolock:
1901 if self._options.nodiff:
1901 if self._options.nodiff:
1902 pass
1902 pass
1903 elif self._options.view:
1903 elif self._options.view:
1904 v = self._options.view
1904 v = self._options.view
1905 os.system(r"%s %s %s" %
1905 os.system(r"%s %s %s" %
1906 (v, _strpath(test.refpath), _strpath(test.errpath)))
1906 (v, _strpath(test.refpath), _strpath(test.errpath)))
1907 else:
1907 else:
1908 servefail, lines = getdiff(expected, got,
1908 servefail, lines = getdiff(expected, got,
1909 test.refpath, test.errpath)
1909 test.refpath, test.errpath)
1910 self.stream.write('\n')
1910 self.stream.write('\n')
1911 for line in lines:
1911 for line in lines:
1912 line = highlightdiff(line, self.color)
1912 line = highlightdiff(line, self.color)
1913 if PYTHON3:
1913 if PYTHON3:
1914 self.stream.flush()
1914 self.stream.flush()
1915 self.stream.buffer.write(line)
1915 self.stream.buffer.write(line)
1916 self.stream.buffer.flush()
1916 self.stream.buffer.flush()
1917 else:
1917 else:
1918 self.stream.write(line)
1918 self.stream.write(line)
1919 self.stream.flush()
1919 self.stream.flush()
1920
1920
1921 if servefail:
1921 if servefail:
1922 raise test.failureException(
1922 raise test.failureException(
1923 'server failed to start (HGPORT=%s)' % test._startport)
1923 'server failed to start (HGPORT=%s)' % test._startport)
1924
1924
1925 # handle interactive prompt without releasing iolock
1925 # handle interactive prompt without releasing iolock
1926 if self._options.interactive:
1926 if self._options.interactive:
1927 if test.readrefout() != expected:
1927 if test.readrefout() != expected:
1928 self.stream.write(
1928 self.stream.write(
1929 'Reference output has changed (run again to prompt '
1929 'Reference output has changed (run again to prompt '
1930 'changes)')
1930 'changes)')
1931 else:
1931 else:
1932 self.stream.write('Accept this change? [n] ')
1932 self.stream.write('Accept this change? [n] ')
1933 self.stream.flush()
1933 self.stream.flush()
1934 answer = sys.stdin.readline().strip()
1934 answer = sys.stdin.readline().strip()
1935 if answer.lower() in ('y', 'yes'):
1935 if answer.lower() in ('y', 'yes'):
1936 if test.path.endswith(b'.t'):
1936 if test.path.endswith(b'.t'):
1937 rename(test.errpath, test.path)
1937 rename(test.errpath, test.path)
1938 else:
1938 else:
1939 rename(test.errpath, '%s.out' % test.path)
1939 rename(test.errpath, '%s.out' % test.path)
1940 accepted = True
1940 accepted = True
1941 if not accepted:
1941 if not accepted:
1942 self.faildata[test.name] = b''.join(lines)
1942 self.faildata[test.name] = b''.join(lines)
1943
1943
1944 return accepted
1944 return accepted
1945
1945
1946 def startTest(self, test):
1946 def startTest(self, test):
1947 super(TestResult, self).startTest(test)
1947 super(TestResult, self).startTest(test)
1948
1948
1949 # os.times module computes the user time and system time spent by
1949 # os.times module computes the user time and system time spent by
1950 # child's processes along with real elapsed time taken by a process.
1950 # child's processes along with real elapsed time taken by a process.
1951 # This module has one limitation. It can only work for Linux user
1951 # This module has one limitation. It can only work for Linux user
1952 # and not for Windows.
1952 # and not for Windows.
1953 test.started = os.times()
1953 test.started = os.times()
1954 if self._firststarttime is None: # thread racy but irrelevant
1954 if self._firststarttime is None: # thread racy but irrelevant
1955 self._firststarttime = test.started[4]
1955 self._firststarttime = test.started[4]
1956
1956
1957 def stopTest(self, test, interrupted=False):
1957 def stopTest(self, test, interrupted=False):
1958 super(TestResult, self).stopTest(test)
1958 super(TestResult, self).stopTest(test)
1959
1959
1960 test.stopped = os.times()
1960 test.stopped = os.times()
1961
1961
1962 starttime = test.started
1962 starttime = test.started
1963 endtime = test.stopped
1963 endtime = test.stopped
1964 origin = self._firststarttime
1964 origin = self._firststarttime
1965 self.times.append((test.name,
1965 self.times.append((test.name,
1966 endtime[2] - starttime[2], # user space CPU time
1966 endtime[2] - starttime[2], # user space CPU time
1967 endtime[3] - starttime[3], # sys space CPU time
1967 endtime[3] - starttime[3], # sys space CPU time
1968 endtime[4] - starttime[4], # real time
1968 endtime[4] - starttime[4], # real time
1969 starttime[4] - origin, # start date in run context
1969 starttime[4] - origin, # start date in run context
1970 endtime[4] - origin, # end date in run context
1970 endtime[4] - origin, # end date in run context
1971 ))
1971 ))
1972
1972
1973 if interrupted:
1973 if interrupted:
1974 with iolock:
1974 with iolock:
1975 self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % (
1975 self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % (
1976 test.name, self.times[-1][3]))
1976 test.name, self.times[-1][3]))
1977
1977
1978 def getTestResult():
1978 def getTestResult():
1979 """
1979 """
1980 Returns the relevant test result
1980 Returns the relevant test result
1981 """
1981 """
1982 if "CUSTOM_TEST_RESULT" in os.environ:
1982 if "CUSTOM_TEST_RESULT" in os.environ:
1983 testresultmodule = __import__(os.environ["CUSTOM_TEST_RESULT"])
1983 testresultmodule = __import__(os.environ["CUSTOM_TEST_RESULT"])
1984 return testresultmodule.TestResult
1984 return testresultmodule.TestResult
1985 else:
1985 else:
1986 return TestResult
1986 return TestResult
1987
1987
1988 class TestSuite(unittest.TestSuite):
1988 class TestSuite(unittest.TestSuite):
1989 """Custom unittest TestSuite that knows how to execute Mercurial tests."""
1989 """Custom unittest TestSuite that knows how to execute Mercurial tests."""
1990
1990
1991 def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None,
1991 def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None,
1992 retest=False, keywords=None, loop=False, runs_per_test=1,
1992 retest=False, keywords=None, loop=False, runs_per_test=1,
1993 loadtest=None, showchannels=False,
1993 loadtest=None, showchannels=False,
1994 *args, **kwargs):
1994 *args, **kwargs):
1995 """Create a new instance that can run tests with a configuration.
1995 """Create a new instance that can run tests with a configuration.
1996
1996
1997 testdir specifies the directory where tests are executed from. This
1997 testdir specifies the directory where tests are executed from. This
1998 is typically the ``tests`` directory from Mercurial's source
1998 is typically the ``tests`` directory from Mercurial's source
1999 repository.
1999 repository.
2000
2000
2001 jobs specifies the number of jobs to run concurrently. Each test
2001 jobs specifies the number of jobs to run concurrently. Each test
2002 executes on its own thread. Tests actually spawn new processes, so
2002 executes on its own thread. Tests actually spawn new processes, so
2003 state mutation should not be an issue.
2003 state mutation should not be an issue.
2004
2004
2005 If there is only one job, it will use the main thread.
2005 If there is only one job, it will use the main thread.
2006
2006
2007 whitelist and blacklist denote tests that have been whitelisted and
2007 whitelist and blacklist denote tests that have been whitelisted and
2008 blacklisted, respectively. These arguments don't belong in TestSuite.
2008 blacklisted, respectively. These arguments don't belong in TestSuite.
2009 Instead, whitelist and blacklist should be handled by the thing that
2009 Instead, whitelist and blacklist should be handled by the thing that
2010 populates the TestSuite with tests. They are present to preserve
2010 populates the TestSuite with tests. They are present to preserve
2011 backwards compatible behavior which reports skipped tests as part
2011 backwards compatible behavior which reports skipped tests as part
2012 of the results.
2012 of the results.
2013
2013
2014 retest denotes whether to retest failed tests. This arguably belongs
2014 retest denotes whether to retest failed tests. This arguably belongs
2015 outside of TestSuite.
2015 outside of TestSuite.
2016
2016
2017 keywords denotes key words that will be used to filter which tests
2017 keywords denotes key words that will be used to filter which tests
2018 to execute. This arguably belongs outside of TestSuite.
2018 to execute. This arguably belongs outside of TestSuite.
2019
2019
2020 loop denotes whether to loop over tests forever.
2020 loop denotes whether to loop over tests forever.
2021 """
2021 """
2022 super(TestSuite, self).__init__(*args, **kwargs)
2022 super(TestSuite, self).__init__(*args, **kwargs)
2023
2023
2024 self._jobs = jobs
2024 self._jobs = jobs
2025 self._whitelist = whitelist
2025 self._whitelist = whitelist
2026 self._blacklist = blacklist
2026 self._blacklist = blacklist
2027 self._retest = retest
2027 self._retest = retest
2028 self._keywords = keywords
2028 self._keywords = keywords
2029 self._loop = loop
2029 self._loop = loop
2030 self._runs_per_test = runs_per_test
2030 self._runs_per_test = runs_per_test
2031 self._loadtest = loadtest
2031 self._loadtest = loadtest
2032 self._showchannels = showchannels
2032 self._showchannels = showchannels
2033
2033
2034 def run(self, result):
2034 def run(self, result):
2035 # We have a number of filters that need to be applied. We do this
2035 # We have a number of filters that need to be applied. We do this
2036 # here instead of inside Test because it makes the running logic for
2036 # here instead of inside Test because it makes the running logic for
2037 # Test simpler.
2037 # Test simpler.
2038 tests = []
2038 tests = []
2039 num_tests = [0]
2039 num_tests = [0]
2040 for test in self._tests:
2040 for test in self._tests:
2041 def get():
2041 def get():
2042 num_tests[0] += 1
2042 num_tests[0] += 1
2043 if getattr(test, 'should_reload', False):
2043 if getattr(test, 'should_reload', False):
2044 return self._loadtest(test, num_tests[0])
2044 return self._loadtest(test, num_tests[0])
2045 return test
2045 return test
2046 if not os.path.exists(test.path):
2046 if not os.path.exists(test.path):
2047 result.addSkip(test, "Doesn't exist")
2047 result.addSkip(test, "Doesn't exist")
2048 continue
2048 continue
2049
2049
2050 if not (self._whitelist and test.bname in self._whitelist):
2050 if not (self._whitelist and test.bname in self._whitelist):
2051 if self._blacklist and test.bname in self._blacklist:
2051 if self._blacklist and test.bname in self._blacklist:
2052 result.addSkip(test, 'blacklisted')
2052 result.addSkip(test, 'blacklisted')
2053 continue
2053 continue
2054
2054
2055 if self._retest and not os.path.exists(test.errpath):
2055 if self._retest and not os.path.exists(test.errpath):
2056 result.addIgnore(test, 'not retesting')
2056 result.addIgnore(test, 'not retesting')
2057 continue
2057 continue
2058
2058
2059 if self._keywords:
2059 if self._keywords:
2060 with open(test.path, 'rb') as f:
2060 with open(test.path, 'rb') as f:
2061 t = f.read().lower() + test.bname.lower()
2061 t = f.read().lower() + test.bname.lower()
2062 ignored = False
2062 ignored = False
2063 for k in self._keywords.lower().split():
2063 for k in self._keywords.lower().split():
2064 if k not in t:
2064 if k not in t:
2065 result.addIgnore(test, "doesn't match keyword")
2065 result.addIgnore(test, "doesn't match keyword")
2066 ignored = True
2066 ignored = True
2067 break
2067 break
2068
2068
2069 if ignored:
2069 if ignored:
2070 continue
2070 continue
2071 for _ in xrange(self._runs_per_test):
2071 for _ in xrange(self._runs_per_test):
2072 tests.append(get())
2072 tests.append(get())
2073
2073
2074 runtests = list(tests)
2074 runtests = list(tests)
2075 done = queue.Queue()
2075 done = queue.Queue()
2076 running = 0
2076 running = 0
2077
2077
2078 channels = [""] * self._jobs
2078 channels = [""] * self._jobs
2079
2079
2080 def job(test, result):
2080 def job(test, result):
2081 for n, v in enumerate(channels):
2081 for n, v in enumerate(channels):
2082 if not v:
2082 if not v:
2083 channel = n
2083 channel = n
2084 break
2084 break
2085 else:
2085 else:
2086 raise ValueError('Could not find output channel')
2086 raise ValueError('Could not find output channel')
2087 channels[channel] = "=" + test.name[5:].split(".")[0]
2087 channels[channel] = "=" + test.name[5:].split(".")[0]
2088 try:
2088 try:
2089 test(result)
2089 test(result)
2090 done.put(None)
2090 done.put(None)
2091 except KeyboardInterrupt:
2091 except KeyboardInterrupt:
2092 pass
2092 pass
2093 except: # re-raises
2093 except: # re-raises
2094 done.put(('!', test, 'run-test raised an error, see traceback'))
2094 done.put(('!', test, 'run-test raised an error, see traceback'))
2095 raise
2095 raise
2096 finally:
2096 finally:
2097 try:
2097 try:
2098 channels[channel] = ''
2098 channels[channel] = ''
2099 except IndexError:
2099 except IndexError:
2100 pass
2100 pass
2101
2101
2102 def stat():
2102 def stat():
2103 count = 0
2103 count = 0
2104 while channels:
2104 while channels:
2105 d = '\n%03s ' % count
2105 d = '\n%03s ' % count
2106 for n, v in enumerate(channels):
2106 for n, v in enumerate(channels):
2107 if v:
2107 if v:
2108 d += v[0]
2108 d += v[0]
2109 channels[n] = v[1:] or '.'
2109 channels[n] = v[1:] or '.'
2110 else:
2110 else:
2111 d += ' '
2111 d += ' '
2112 d += ' '
2112 d += ' '
2113 with iolock:
2113 with iolock:
2114 sys.stdout.write(d + ' ')
2114 sys.stdout.write(d + ' ')
2115 sys.stdout.flush()
2115 sys.stdout.flush()
2116 for x in xrange(10):
2116 for x in xrange(10):
2117 if channels:
2117 if channels:
2118 time.sleep(.1)
2118 time.sleep(.1)
2119 count += 1
2119 count += 1
2120
2120
2121 stoppedearly = False
2121 stoppedearly = False
2122
2122
2123 if self._showchannels:
2123 if self._showchannels:
2124 statthread = threading.Thread(target=stat, name="stat")
2124 statthread = threading.Thread(target=stat, name="stat")
2125 statthread.start()
2125 statthread.start()
2126
2126
2127 try:
2127 try:
2128 while tests or running:
2128 while tests or running:
2129 if not done.empty() or running == self._jobs or not tests:
2129 if not done.empty() or running == self._jobs or not tests:
2130 try:
2130 try:
2131 done.get(True, 1)
2131 done.get(True, 1)
2132 running -= 1
2132 running -= 1
2133 if result and result.shouldStop:
2133 if result and result.shouldStop:
2134 stoppedearly = True
2134 stoppedearly = True
2135 break
2135 break
2136 except queue.Empty:
2136 except queue.Empty:
2137 continue
2137 continue
2138 if tests and not running == self._jobs:
2138 if tests and not running == self._jobs:
2139 test = tests.pop(0)
2139 test = tests.pop(0)
2140 if self._loop:
2140 if self._loop:
2141 if getattr(test, 'should_reload', False):
2141 if getattr(test, 'should_reload', False):
2142 num_tests[0] += 1
2142 num_tests[0] += 1
2143 tests.append(
2143 tests.append(
2144 self._loadtest(test, num_tests[0]))
2144 self._loadtest(test, num_tests[0]))
2145 else:
2145 else:
2146 tests.append(test)
2146 tests.append(test)
2147 if self._jobs == 1:
2147 if self._jobs == 1:
2148 job(test, result)
2148 job(test, result)
2149 else:
2149 else:
2150 t = threading.Thread(target=job, name=test.name,
2150 t = threading.Thread(target=job, name=test.name,
2151 args=(test, result))
2151 args=(test, result))
2152 t.start()
2152 t.start()
2153 running += 1
2153 running += 1
2154
2154
2155 # If we stop early we still need to wait on started tests to
2155 # If we stop early we still need to wait on started tests to
2156 # finish. Otherwise, there is a race between the test completing
2156 # finish. Otherwise, there is a race between the test completing
2157 # and the test's cleanup code running. This could result in the
2157 # and the test's cleanup code running. This could result in the
2158 # test reporting incorrect.
2158 # test reporting incorrect.
2159 if stoppedearly:
2159 if stoppedearly:
2160 while running:
2160 while running:
2161 try:
2161 try:
2162 done.get(True, 1)
2162 done.get(True, 1)
2163 running -= 1
2163 running -= 1
2164 except queue.Empty:
2164 except queue.Empty:
2165 continue
2165 continue
2166 except KeyboardInterrupt:
2166 except KeyboardInterrupt:
2167 for test in runtests:
2167 for test in runtests:
2168 test.abort()
2168 test.abort()
2169
2169
2170 channels = []
2170 channels = []
2171
2171
2172 return result
2172 return result
2173
2173
2174 # Save the most recent 5 wall-clock runtimes of each test to a
2174 # Save the most recent 5 wall-clock runtimes of each test to a
2175 # human-readable text file named .testtimes. Tests are sorted
2175 # human-readable text file named .testtimes. Tests are sorted
2176 # alphabetically, while times for each test are listed from oldest to
2176 # alphabetically, while times for each test are listed from oldest to
2177 # newest.
2177 # newest.
2178
2178
2179 def loadtimes(outputdir):
2179 def loadtimes(outputdir):
2180 times = []
2180 times = []
2181 try:
2181 try:
2182 with open(os.path.join(outputdir, b'.testtimes')) as fp:
2182 with open(os.path.join(outputdir, b'.testtimes')) as fp:
2183 for line in fp:
2183 for line in fp:
2184 m = re.match('(.*?) ([0-9. ]+)', line)
2184 m = re.match('(.*?) ([0-9. ]+)', line)
2185 times.append((m.group(1),
2185 times.append((m.group(1),
2186 [float(t) for t in m.group(2).split()]))
2186 [float(t) for t in m.group(2).split()]))
2187 except IOError as err:
2187 except IOError as err:
2188 if err.errno != errno.ENOENT:
2188 if err.errno != errno.ENOENT:
2189 raise
2189 raise
2190 return times
2190 return times
2191
2191
2192 def savetimes(outputdir, result):
2192 def savetimes(outputdir, result):
2193 saved = dict(loadtimes(outputdir))
2193 saved = dict(loadtimes(outputdir))
2194 maxruns = 5
2194 maxruns = 5
2195 skipped = set([str(t[0]) for t in result.skipped])
2195 skipped = set([str(t[0]) for t in result.skipped])
2196 for tdata in result.times:
2196 for tdata in result.times:
2197 test, real = tdata[0], tdata[3]
2197 test, real = tdata[0], tdata[3]
2198 if test not in skipped:
2198 if test not in skipped:
2199 ts = saved.setdefault(test, [])
2199 ts = saved.setdefault(test, [])
2200 ts.append(real)
2200 ts.append(real)
2201 ts[:] = ts[-maxruns:]
2201 ts[:] = ts[-maxruns:]
2202
2202
2203 fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes',
2203 fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes',
2204 dir=outputdir, text=True)
2204 dir=outputdir, text=True)
2205 with os.fdopen(fd, 'w') as fp:
2205 with os.fdopen(fd, 'w') as fp:
2206 for name, ts in sorted(saved.items()):
2206 for name, ts in sorted(saved.items()):
2207 fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts])))
2207 fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts])))
2208 timepath = os.path.join(outputdir, b'.testtimes')
2208 timepath = os.path.join(outputdir, b'.testtimes')
2209 try:
2209 try:
2210 os.unlink(timepath)
2210 os.unlink(timepath)
2211 except OSError:
2211 except OSError:
2212 pass
2212 pass
2213 try:
2213 try:
2214 os.rename(tmpname, timepath)
2214 os.rename(tmpname, timepath)
2215 except OSError:
2215 except OSError:
2216 pass
2216 pass
2217
2217
2218 class TextTestRunner(unittest.TextTestRunner):
2218 class TextTestRunner(unittest.TextTestRunner):
2219 """Custom unittest test runner that uses appropriate settings."""
2219 """Custom unittest test runner that uses appropriate settings."""
2220
2220
2221 def __init__(self, runner, *args, **kwargs):
2221 def __init__(self, runner, *args, **kwargs):
2222 super(TextTestRunner, self).__init__(*args, **kwargs)
2222 super(TextTestRunner, self).__init__(*args, **kwargs)
2223
2223
2224 self._runner = runner
2224 self._runner = runner
2225
2225
2226 self._result = getTestResult()(self._runner.options, self.stream,
2226 self._result = getTestResult()(self._runner.options, self.stream,
2227 self.descriptions, self.verbosity)
2227 self.descriptions, self.verbosity)
2228
2228
2229 def listtests(self, test):
2229 def listtests(self, test):
2230 test = sorted(test, key=lambda t: t.name)
2230 test = sorted(test, key=lambda t: t.name)
2231
2231
2232 self._result.onStart(test)
2232 self._result.onStart(test)
2233
2233
2234 for t in test:
2234 for t in test:
2235 print(t.name)
2235 print(t.name)
2236 self._result.addSuccess(t)
2236 self._result.addSuccess(t)
2237
2237
2238 if self._runner.options.xunit:
2238 if self._runner.options.xunit:
2239 with open(self._runner.options.xunit, "wb") as xuf:
2239 with open(self._runner.options.xunit, "wb") as xuf:
2240 self._writexunit(self._result, xuf)
2240 self._writexunit(self._result, xuf)
2241
2241
2242 if self._runner.options.json:
2242 if self._runner.options.json:
2243 jsonpath = os.path.join(self._runner._outputdir, b'report.json')
2243 jsonpath = os.path.join(self._runner._outputdir, b'report.json')
2244 with open(jsonpath, 'w') as fp:
2244 with open(jsonpath, 'w') as fp:
2245 self._writejson(self._result, fp)
2245 self._writejson(self._result, fp)
2246
2246
2247 return self._result
2247 return self._result
2248
2248
2249 def run(self, test):
2249 def run(self, test):
2250 self._result.onStart(test)
2250 self._result.onStart(test)
2251 test(self._result)
2251 test(self._result)
2252
2252
2253 failed = len(self._result.failures)
2253 failed = len(self._result.failures)
2254 skipped = len(self._result.skipped)
2254 skipped = len(self._result.skipped)
2255 ignored = len(self._result.ignored)
2255 ignored = len(self._result.ignored)
2256
2256
2257 with iolock:
2257 with iolock:
2258 self.stream.writeln('')
2258 self.stream.writeln('')
2259
2259
2260 if not self._runner.options.noskips:
2260 if not self._runner.options.noskips:
2261 for test, msg in self._result.skipped:
2261 for test, msg in self._result.skipped:
2262 formatted = 'Skipped %s: %s\n' % (test.name, msg)
2262 formatted = 'Skipped %s: %s\n' % (test.name, msg)
2263 msg = highlightmsg(formatted, self._result.color)
2263 msg = highlightmsg(formatted, self._result.color)
2264 self.stream.write(msg)
2264 self.stream.write(msg)
2265 for test, msg in self._result.failures:
2265 for test, msg in self._result.failures:
2266 formatted = 'Failed %s: %s\n' % (test.name, msg)
2266 formatted = 'Failed %s: %s\n' % (test.name, msg)
2267 self.stream.write(highlightmsg(formatted, self._result.color))
2267 self.stream.write(highlightmsg(formatted, self._result.color))
2268 for test, msg in self._result.errors:
2268 for test, msg in self._result.errors:
2269 self.stream.writeln('Errored %s: %s' % (test.name, msg))
2269 self.stream.writeln('Errored %s: %s' % (test.name, msg))
2270
2270
2271 if self._runner.options.xunit:
2271 if self._runner.options.xunit:
2272 with open(self._runner.options.xunit, "wb") as xuf:
2272 with open(self._runner.options.xunit, "wb") as xuf:
2273 self._writexunit(self._result, xuf)
2273 self._writexunit(self._result, xuf)
2274
2274
2275 if self._runner.options.json:
2275 if self._runner.options.json:
2276 jsonpath = os.path.join(self._runner._outputdir, b'report.json')
2276 jsonpath = os.path.join(self._runner._outputdir, b'report.json')
2277 with open(jsonpath, 'w') as fp:
2277 with open(jsonpath, 'w') as fp:
2278 self._writejson(self._result, fp)
2278 self._writejson(self._result, fp)
2279
2279
2280 self._runner._checkhglib('Tested')
2280 self._runner._checkhglib('Tested')
2281
2281
2282 savetimes(self._runner._outputdir, self._result)
2282 savetimes(self._runner._outputdir, self._result)
2283
2283
2284 if failed and self._runner.options.known_good_rev:
2284 if failed and self._runner.options.known_good_rev:
2285 self._bisecttests(t for t, m in self._result.failures)
2285 self._bisecttests(t for t, m in self._result.failures)
2286 self.stream.writeln(
2286 self.stream.writeln(
2287 '# Ran %d tests, %d skipped, %d failed.'
2287 '# Ran %d tests, %d skipped, %d failed.'
2288 % (self._result.testsRun, skipped + ignored, failed))
2288 % (self._result.testsRun, skipped + ignored, failed))
2289 if failed:
2289 if failed:
2290 self.stream.writeln('python hash seed: %s' %
2290 self.stream.writeln('python hash seed: %s' %
2291 os.environ['PYTHONHASHSEED'])
2291 os.environ['PYTHONHASHSEED'])
2292 if self._runner.options.time:
2292 if self._runner.options.time:
2293 self.printtimes(self._result.times)
2293 self.printtimes(self._result.times)
2294
2294
2295 if self._runner.options.exceptions:
2295 if self._runner.options.exceptions:
2296 exceptions = aggregateexceptions(
2296 exceptions = aggregateexceptions(
2297 os.path.join(self._runner._outputdir, b'exceptions'))
2297 os.path.join(self._runner._outputdir, b'exceptions'))
2298
2298
2299 self.stream.writeln('Exceptions Report:')
2299 self.stream.writeln('Exceptions Report:')
2300 self.stream.writeln('%d total from %d frames' %
2300 self.stream.writeln('%d total from %d frames' %
2301 (exceptions['total'],
2301 (exceptions['total'],
2302 len(exceptions['exceptioncounts'])))
2302 len(exceptions['exceptioncounts'])))
2303 combined = exceptions['combined']
2303 combined = exceptions['combined']
2304 for key in sorted(combined, key=combined.get, reverse=True):
2304 for key in sorted(combined, key=combined.get, reverse=True):
2305 frame, line, exc = key
2305 frame, line, exc = key
2306 totalcount, testcount, leastcount, leasttest = combined[key]
2306 totalcount, testcount, leastcount, leasttest = combined[key]
2307
2307
2308 self.stream.writeln('%d (%d tests)\t%s: %s (%s - %d total)'
2308 self.stream.writeln('%d (%d tests)\t%s: %s (%s - %d total)'
2309 % (totalcount,
2309 % (totalcount,
2310 testcount,
2310 testcount,
2311 frame, exc,
2311 frame, exc,
2312 leasttest, leastcount))
2312 leasttest, leastcount))
2313
2313
2314 self.stream.flush()
2314 self.stream.flush()
2315
2315
2316 return self._result
2316 return self._result
2317
2317
2318 def _bisecttests(self, tests):
2318 def _bisecttests(self, tests):
2319 bisectcmd = ['hg', 'bisect']
2319 bisectcmd = ['hg', 'bisect']
2320 bisectrepo = self._runner.options.bisect_repo
2320 bisectrepo = self._runner.options.bisect_repo
2321 if bisectrepo:
2321 if bisectrepo:
2322 bisectcmd.extend(['-R', os.path.abspath(bisectrepo)])
2322 bisectcmd.extend(['-R', os.path.abspath(bisectrepo)])
2323 def pread(args):
2323 def pread(args):
2324 env = os.environ.copy()
2324 env = os.environ.copy()
2325 env['HGPLAIN'] = '1'
2325 env['HGPLAIN'] = '1'
2326 p = subprocess.Popen(args, stderr=subprocess.STDOUT,
2326 p = subprocess.Popen(args, stderr=subprocess.STDOUT,
2327 stdout=subprocess.PIPE, env=env)
2327 stdout=subprocess.PIPE, env=env)
2328 data = p.stdout.read()
2328 data = p.stdout.read()
2329 p.wait()
2329 p.wait()
2330 return data
2330 return data
2331 for test in tests:
2331 for test in tests:
2332 pread(bisectcmd + ['--reset']),
2332 pread(bisectcmd + ['--reset']),
2333 pread(bisectcmd + ['--bad', '.'])
2333 pread(bisectcmd + ['--bad', '.'])
2334 pread(bisectcmd + ['--good', self._runner.options.known_good_rev])
2334 pread(bisectcmd + ['--good', self._runner.options.known_good_rev])
2335 # TODO: we probably need to forward more options
2335 # TODO: we probably need to forward more options
2336 # that alter hg's behavior inside the tests.
2336 # that alter hg's behavior inside the tests.
2337 opts = ''
2337 opts = ''
2338 withhg = self._runner.options.with_hg
2338 withhg = self._runner.options.with_hg
2339 if withhg:
2339 if withhg:
2340 opts += ' --with-hg=%s ' % shellquote(_strpath(withhg))
2340 opts += ' --with-hg=%s ' % shellquote(_strpath(withhg))
2341 rtc = '%s %s %s %s' % (sys.executable, sys.argv[0], opts,
2341 rtc = '%s %s %s %s' % (sys.executable, sys.argv[0], opts,
2342 test)
2342 test)
2343 data = pread(bisectcmd + ['--command', rtc])
2343 data = pread(bisectcmd + ['--command', rtc])
2344 m = re.search(
2344 m = re.search(
2345 (br'\nThe first (?P<goodbad>bad|good) revision '
2345 (br'\nThe first (?P<goodbad>bad|good) revision '
2346 br'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n'
2346 br'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n'
2347 br'summary: +(?P<summary>[^\n]+)\n'),
2347 br'summary: +(?P<summary>[^\n]+)\n'),
2348 data, (re.MULTILINE | re.DOTALL))
2348 data, (re.MULTILINE | re.DOTALL))
2349 if m is None:
2349 if m is None:
2350 self.stream.writeln(
2350 self.stream.writeln(
2351 'Failed to identify failure point for %s' % test)
2351 'Failed to identify failure point for %s' % test)
2352 continue
2352 continue
2353 dat = m.groupdict()
2353 dat = m.groupdict()
2354 verb = 'broken' if dat['goodbad'] == b'bad' else 'fixed'
2354 verb = 'broken' if dat['goodbad'] == b'bad' else 'fixed'
2355 self.stream.writeln(
2355 self.stream.writeln(
2356 '%s %s by %s (%s)' % (
2356 '%s %s by %s (%s)' % (
2357 test, verb, dat['node'].decode('ascii'),
2357 test, verb, dat['node'].decode('ascii'),
2358 dat['summary'].decode('utf8', 'ignore')))
2358 dat['summary'].decode('utf8', 'ignore')))
2359
2359
2360 def printtimes(self, times):
2360 def printtimes(self, times):
2361 # iolock held by run
2361 # iolock held by run
2362 self.stream.writeln('# Producing time report')
2362 self.stream.writeln('# Producing time report')
2363 times.sort(key=lambda t: (t[3]))
2363 times.sort(key=lambda t: (t[3]))
2364 cols = '%7.3f %7.3f %7.3f %7.3f %7.3f %s'
2364 cols = '%7.3f %7.3f %7.3f %7.3f %7.3f %s'
2365 self.stream.writeln('%-7s %-7s %-7s %-7s %-7s %s' %
2365 self.stream.writeln('%-7s %-7s %-7s %-7s %-7s %s' %
2366 ('start', 'end', 'cuser', 'csys', 'real', 'Test'))
2366 ('start', 'end', 'cuser', 'csys', 'real', 'Test'))
2367 for tdata in times:
2367 for tdata in times:
2368 test = tdata[0]
2368 test = tdata[0]
2369 cuser, csys, real, start, end = tdata[1:6]
2369 cuser, csys, real, start, end = tdata[1:6]
2370 self.stream.writeln(cols % (start, end, cuser, csys, real, test))
2370 self.stream.writeln(cols % (start, end, cuser, csys, real, test))
2371
2371
2372 @staticmethod
2372 @staticmethod
2373 def _writexunit(result, outf):
2373 def _writexunit(result, outf):
2374 # See http://llg.cubic.org/docs/junit/ for a reference.
2374 # See http://llg.cubic.org/docs/junit/ for a reference.
2375 timesd = dict((t[0], t[3]) for t in result.times)
2375 timesd = dict((t[0], t[3]) for t in result.times)
2376 doc = minidom.Document()
2376 doc = minidom.Document()
2377 s = doc.createElement('testsuite')
2377 s = doc.createElement('testsuite')
2378 s.setAttribute('name', 'run-tests')
2378 s.setAttribute('name', 'run-tests')
2379 s.setAttribute('tests', str(result.testsRun))
2379 s.setAttribute('tests', str(result.testsRun))
2380 s.setAttribute('errors', "0") # TODO
2380 s.setAttribute('errors', "0") # TODO
2381 s.setAttribute('failures', str(len(result.failures)))
2381 s.setAttribute('failures', str(len(result.failures)))
2382 s.setAttribute('skipped', str(len(result.skipped) +
2382 s.setAttribute('skipped', str(len(result.skipped) +
2383 len(result.ignored)))
2383 len(result.ignored)))
2384 doc.appendChild(s)
2384 doc.appendChild(s)
2385 for tc in result.successes:
2385 for tc in result.successes:
2386 t = doc.createElement('testcase')
2386 t = doc.createElement('testcase')
2387 t.setAttribute('name', tc.name)
2387 t.setAttribute('name', tc.name)
2388 tctime = timesd.get(tc.name)
2388 tctime = timesd.get(tc.name)
2389 if tctime is not None:
2389 if tctime is not None:
2390 t.setAttribute('time', '%.3f' % tctime)
2390 t.setAttribute('time', '%.3f' % tctime)
2391 s.appendChild(t)
2391 s.appendChild(t)
2392 for tc, err in sorted(result.faildata.items()):
2392 for tc, err in sorted(result.faildata.items()):
2393 t = doc.createElement('testcase')
2393 t = doc.createElement('testcase')
2394 t.setAttribute('name', tc)
2394 t.setAttribute('name', tc)
2395 tctime = timesd.get(tc)
2395 tctime = timesd.get(tc)
2396 if tctime is not None:
2396 if tctime is not None:
2397 t.setAttribute('time', '%.3f' % tctime)
2397 t.setAttribute('time', '%.3f' % tctime)
2398 # createCDATASection expects a unicode or it will
2398 # createCDATASection expects a unicode or it will
2399 # convert using default conversion rules, which will
2399 # convert using default conversion rules, which will
2400 # fail if string isn't ASCII.
2400 # fail if string isn't ASCII.
2401 err = cdatasafe(err).decode('utf-8', 'replace')
2401 err = cdatasafe(err).decode('utf-8', 'replace')
2402 cd = doc.createCDATASection(err)
2402 cd = doc.createCDATASection(err)
2403 # Use 'failure' here instead of 'error' to match errors = 0,
2403 # Use 'failure' here instead of 'error' to match errors = 0,
2404 # failures = len(result.failures) in the testsuite element.
2404 # failures = len(result.failures) in the testsuite element.
2405 failelem = doc.createElement('failure')
2405 failelem = doc.createElement('failure')
2406 failelem.setAttribute('message', 'output changed')
2406 failelem.setAttribute('message', 'output changed')
2407 failelem.setAttribute('type', 'output-mismatch')
2407 failelem.setAttribute('type', 'output-mismatch')
2408 failelem.appendChild(cd)
2408 failelem.appendChild(cd)
2409 t.appendChild(failelem)
2409 t.appendChild(failelem)
2410 s.appendChild(t)
2410 s.appendChild(t)
2411 for tc, message in result.skipped:
2411 for tc, message in result.skipped:
2412 # According to the schema, 'skipped' has no attributes. So store
2412 # According to the schema, 'skipped' has no attributes. So store
2413 # the skip message as a text node instead.
2413 # the skip message as a text node instead.
2414 t = doc.createElement('testcase')
2414 t = doc.createElement('testcase')
2415 t.setAttribute('name', tc.name)
2415 t.setAttribute('name', tc.name)
2416 binmessage = message.encode('utf-8')
2416 binmessage = message.encode('utf-8')
2417 message = cdatasafe(binmessage).decode('utf-8', 'replace')
2417 message = cdatasafe(binmessage).decode('utf-8', 'replace')
2418 cd = doc.createCDATASection(message)
2418 cd = doc.createCDATASection(message)
2419 skipelem = doc.createElement('skipped')
2419 skipelem = doc.createElement('skipped')
2420 skipelem.appendChild(cd)
2420 skipelem.appendChild(cd)
2421 t.appendChild(skipelem)
2421 t.appendChild(skipelem)
2422 s.appendChild(t)
2422 s.appendChild(t)
2423 outf.write(doc.toprettyxml(indent=' ', encoding='utf-8'))
2423 outf.write(doc.toprettyxml(indent=' ', encoding='utf-8'))
2424
2424
2425 @staticmethod
2425 @staticmethod
2426 def _writejson(result, outf):
2426 def _writejson(result, outf):
2427 timesd = {}
2427 timesd = {}
2428 for tdata in result.times:
2428 for tdata in result.times:
2429 test = tdata[0]
2429 test = tdata[0]
2430 timesd[test] = tdata[1:]
2430 timesd[test] = tdata[1:]
2431
2431
2432 outcome = {}
2432 outcome = {}
2433 groups = [('success', ((tc, None)
2433 groups = [('success', ((tc, None)
2434 for tc in result.successes)),
2434 for tc in result.successes)),
2435 ('failure', result.failures),
2435 ('failure', result.failures),
2436 ('skip', result.skipped)]
2436 ('skip', result.skipped)]
2437 for res, testcases in groups:
2437 for res, testcases in groups:
2438 for tc, __ in testcases:
2438 for tc, __ in testcases:
2439 if tc.name in timesd:
2439 if tc.name in timesd:
2440 diff = result.faildata.get(tc.name, b'')
2440 diff = result.faildata.get(tc.name, b'')
2441 try:
2441 try:
2442 diff = diff.decode('unicode_escape')
2442 diff = diff.decode('unicode_escape')
2443 except UnicodeDecodeError as e:
2443 except UnicodeDecodeError as e:
2444 diff = '%r decoding diff, sorry' % e
2444 diff = '%r decoding diff, sorry' % e
2445 tres = {'result': res,
2445 tres = {'result': res,
2446 'time': ('%0.3f' % timesd[tc.name][2]),
2446 'time': ('%0.3f' % timesd[tc.name][2]),
2447 'cuser': ('%0.3f' % timesd[tc.name][0]),
2447 'cuser': ('%0.3f' % timesd[tc.name][0]),
2448 'csys': ('%0.3f' % timesd[tc.name][1]),
2448 'csys': ('%0.3f' % timesd[tc.name][1]),
2449 'start': ('%0.3f' % timesd[tc.name][3]),
2449 'start': ('%0.3f' % timesd[tc.name][3]),
2450 'end': ('%0.3f' % timesd[tc.name][4]),
2450 'end': ('%0.3f' % timesd[tc.name][4]),
2451 'diff': diff,
2451 'diff': diff,
2452 }
2452 }
2453 else:
2453 else:
2454 # blacklisted test
2454 # blacklisted test
2455 tres = {'result': res}
2455 tres = {'result': res}
2456
2456
2457 outcome[tc.name] = tres
2457 outcome[tc.name] = tres
2458 jsonout = json.dumps(outcome, sort_keys=True, indent=4,
2458 jsonout = json.dumps(outcome, sort_keys=True, indent=4,
2459 separators=(',', ': '))
2459 separators=(',', ': '))
2460 outf.writelines(("testreport =", jsonout))
2460 outf.writelines(("testreport =", jsonout))
2461
2461
2462 def sorttests(testdescs, previoustimes, shuffle=False):
2462 def sorttests(testdescs, previoustimes, shuffle=False):
2463 """Do an in-place sort of tests."""
2463 """Do an in-place sort of tests."""
2464 if shuffle:
2464 if shuffle:
2465 random.shuffle(testdescs)
2465 random.shuffle(testdescs)
2466 return
2466 return
2467
2467
2468 if previoustimes:
2468 if previoustimes:
2469 def sortkey(f):
2469 def sortkey(f):
2470 f = f['path']
2470 f = f['path']
2471 if f in previoustimes:
2471 if f in previoustimes:
2472 # Use most recent time as estimate
2472 # Use most recent time as estimate
2473 return -previoustimes[f][-1]
2473 return -previoustimes[f][-1]
2474 else:
2474 else:
2475 # Default to a rather arbitrary value of 1 second for new tests
2475 # Default to a rather arbitrary value of 1 second for new tests
2476 return -1.0
2476 return -1.0
2477 else:
2477 else:
2478 # keywords for slow tests
2478 # keywords for slow tests
2479 slow = {b'svn': 10,
2479 slow = {b'svn': 10,
2480 b'cvs': 10,
2480 b'cvs': 10,
2481 b'hghave': 10,
2481 b'hghave': 10,
2482 b'largefiles-update': 10,
2482 b'largefiles-update': 10,
2483 b'run-tests': 10,
2483 b'run-tests': 10,
2484 b'corruption': 10,
2484 b'corruption': 10,
2485 b'race': 10,
2485 b'race': 10,
2486 b'i18n': 10,
2486 b'i18n': 10,
2487 b'check': 100,
2487 b'check': 100,
2488 b'gendoc': 100,
2488 b'gendoc': 100,
2489 b'contrib-perf': 200,
2489 b'contrib-perf': 200,
2490 }
2490 }
2491 perf = {}
2491 perf = {}
2492
2492
2493 def sortkey(f):
2493 def sortkey(f):
2494 # run largest tests first, as they tend to take the longest
2494 # run largest tests first, as they tend to take the longest
2495 f = f['path']
2495 f = f['path']
2496 try:
2496 try:
2497 return perf[f]
2497 return perf[f]
2498 except KeyError:
2498 except KeyError:
2499 try:
2499 try:
2500 val = -os.stat(f).st_size
2500 val = -os.stat(f).st_size
2501 except OSError as e:
2501 except OSError as e:
2502 if e.errno != errno.ENOENT:
2502 if e.errno != errno.ENOENT:
2503 raise
2503 raise
2504 perf[f] = -1e9 # file does not exist, tell early
2504 perf[f] = -1e9 # file does not exist, tell early
2505 return -1e9
2505 return -1e9
2506 for kw, mul in slow.items():
2506 for kw, mul in slow.items():
2507 if kw in f:
2507 if kw in f:
2508 val *= mul
2508 val *= mul
2509 if f.endswith(b'.py'):
2509 if f.endswith(b'.py'):
2510 val /= 10.0
2510 val /= 10.0
2511 perf[f] = val / 1000.0
2511 perf[f] = val / 1000.0
2512 return perf[f]
2512 return perf[f]
2513
2513
2514 testdescs.sort(key=sortkey)
2514 testdescs.sort(key=sortkey)
2515
2515
2516 class TestRunner(object):
2516 class TestRunner(object):
2517 """Holds context for executing tests.
2517 """Holds context for executing tests.
2518
2518
2519 Tests rely on a lot of state. This object holds it for them.
2519 Tests rely on a lot of state. This object holds it for them.
2520 """
2520 """
2521
2521
2522 # Programs required to run tests.
2522 # Programs required to run tests.
2523 REQUIREDTOOLS = [
2523 REQUIREDTOOLS = [
2524 b'diff',
2524 b'diff',
2525 b'grep',
2525 b'grep',
2526 b'unzip',
2526 b'unzip',
2527 b'gunzip',
2527 b'gunzip',
2528 b'bunzip2',
2528 b'bunzip2',
2529 b'sed',
2529 b'sed',
2530 ]
2530 ]
2531
2531
2532 # Maps file extensions to test class.
2532 # Maps file extensions to test class.
2533 TESTTYPES = [
2533 TESTTYPES = [
2534 (b'.py', PythonTest),
2534 (b'.py', PythonTest),
2535 (b'.t', TTest),
2535 (b'.t', TTest),
2536 ]
2536 ]
2537
2537
2538 def __init__(self):
2538 def __init__(self):
2539 self.options = None
2539 self.options = None
2540 self._hgroot = None
2540 self._hgroot = None
2541 self._testdir = None
2541 self._testdir = None
2542 self._outputdir = None
2542 self._outputdir = None
2543 self._hgtmp = None
2543 self._hgtmp = None
2544 self._installdir = None
2544 self._installdir = None
2545 self._bindir = None
2545 self._bindir = None
2546 self._tmpbinddir = None
2546 self._tmpbinddir = None
2547 self._pythondir = None
2547 self._pythondir = None
2548 self._coveragefile = None
2548 self._coveragefile = None
2549 self._createdfiles = []
2549 self._createdfiles = []
2550 self._hgcommand = None
2550 self._hgcommand = None
2551 self._hgpath = None
2551 self._hgpath = None
2552 self._portoffset = 0
2552 self._portoffset = 0
2553 self._ports = {}
2553 self._ports = {}
2554
2554
2555 def run(self, args, parser=None):
2555 def run(self, args, parser=None):
2556 """Run the test suite."""
2556 """Run the test suite."""
2557 oldmask = os.umask(0o22)
2557 oldmask = os.umask(0o22)
2558 try:
2558 try:
2559 parser = parser or getparser()
2559 parser = parser or getparser()
2560 options = parseargs(args, parser)
2560 options = parseargs(args, parser)
2561 tests = [_bytespath(a) for a in options.tests]
2561 tests = [_bytespath(a) for a in options.tests]
2562 if options.test_list is not None:
2562 if options.test_list is not None:
2563 for listfile in options.test_list:
2563 for listfile in options.test_list:
2564 with open(listfile, 'rb') as f:
2564 with open(listfile, 'rb') as f:
2565 tests.extend(t for t in f.read().splitlines() if t)
2565 tests.extend(t for t in f.read().splitlines() if t)
2566 self.options = options
2566 self.options = options
2567
2567
2568 self._checktools()
2568 self._checktools()
2569 testdescs = self.findtests(tests)
2569 testdescs = self.findtests(tests)
2570 if options.profile_runner:
2570 if options.profile_runner:
2571 import statprof
2571 import statprof
2572 statprof.start()
2572 statprof.start()
2573 result = self._run(testdescs)
2573 result = self._run(testdescs)
2574 if options.profile_runner:
2574 if options.profile_runner:
2575 statprof.stop()
2575 statprof.stop()
2576 statprof.display()
2576 statprof.display()
2577 return result
2577 return result
2578
2578
2579 finally:
2579 finally:
2580 os.umask(oldmask)
2580 os.umask(oldmask)
2581
2581
2582 def _run(self, testdescs):
2582 def _run(self, testdescs):
2583 testdir = getcwdb()
2583 testdir = getcwdb()
2584 self._testdir = osenvironb[b'TESTDIR'] = getcwdb()
2584 self._testdir = osenvironb[b'TESTDIR'] = getcwdb()
2585 # assume all tests in same folder for now
2585 # assume all tests in same folder for now
2586 if testdescs:
2586 if testdescs:
2587 pathname = os.path.dirname(testdescs[0]['path'])
2587 pathname = os.path.dirname(testdescs[0]['path'])
2588 if pathname:
2588 if pathname:
2589 testdir = os.path.join(testdir, pathname)
2589 testdir = os.path.join(testdir, pathname)
2590 self._testdir = osenvironb[b'TESTDIR'] = testdir
2590 self._testdir = osenvironb[b'TESTDIR'] = testdir
2591 if self.options.outputdir:
2591 if self.options.outputdir:
2592 self._outputdir = canonpath(_bytespath(self.options.outputdir))
2592 self._outputdir = canonpath(_bytespath(self.options.outputdir))
2593 else:
2593 else:
2594 self._outputdir = getcwdb()
2594 self._outputdir = getcwdb()
2595 if testdescs and pathname:
2595 if testdescs and pathname:
2596 self._outputdir = os.path.join(self._outputdir, pathname)
2596 self._outputdir = os.path.join(self._outputdir, pathname)
2597 previoustimes = {}
2597 previoustimes = {}
2598 if self.options.order_by_runtime:
2598 if self.options.order_by_runtime:
2599 previoustimes = dict(loadtimes(self._outputdir))
2599 previoustimes = dict(loadtimes(self._outputdir))
2600 sorttests(testdescs, previoustimes, shuffle=self.options.random)
2600 sorttests(testdescs, previoustimes, shuffle=self.options.random)
2601
2601
2602 if 'PYTHONHASHSEED' not in os.environ:
2602 if 'PYTHONHASHSEED' not in os.environ:
2603 # use a random python hash seed all the time
2603 # use a random python hash seed all the time
2604 # we do the randomness ourself to know what seed is used
2604 # we do the randomness ourself to know what seed is used
2605 os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))
2605 os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))
2606
2606
2607 if self.options.tmpdir:
2607 if self.options.tmpdir:
2608 self.options.keep_tmpdir = True
2608 self.options.keep_tmpdir = True
2609 tmpdir = _bytespath(self.options.tmpdir)
2609 tmpdir = _bytespath(self.options.tmpdir)
2610 if os.path.exists(tmpdir):
2610 if os.path.exists(tmpdir):
2611 # Meaning of tmpdir has changed since 1.3: we used to create
2611 # Meaning of tmpdir has changed since 1.3: we used to create
2612 # HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if
2612 # HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if
2613 # tmpdir already exists.
2613 # tmpdir already exists.
2614 print("error: temp dir %r already exists" % tmpdir)
2614 print("error: temp dir %r already exists" % tmpdir)
2615 return 1
2615 return 1
2616
2616
2617 os.makedirs(tmpdir)
2617 os.makedirs(tmpdir)
2618 else:
2618 else:
2619 d = None
2619 d = None
2620 if os.name == 'nt':
2620 if os.name == 'nt':
2621 # without this, we get the default temp dir location, but
2621 # without this, we get the default temp dir location, but
2622 # in all lowercase, which causes troubles with paths (issue3490)
2622 # in all lowercase, which causes troubles with paths (issue3490)
2623 d = osenvironb.get(b'TMP', None)
2623 d = osenvironb.get(b'TMP', None)
2624 tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d)
2624 tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d)
2625
2625
2626 self._hgtmp = osenvironb[b'HGTMP'] = (
2626 self._hgtmp = osenvironb[b'HGTMP'] = (
2627 os.path.realpath(tmpdir))
2627 os.path.realpath(tmpdir))
2628
2628
2629 if self.options.with_hg:
2629 if self.options.with_hg:
2630 self._installdir = None
2630 self._installdir = None
2631 whg = self.options.with_hg
2631 whg = self.options.with_hg
2632 self._bindir = os.path.dirname(os.path.realpath(whg))
2632 self._bindir = os.path.dirname(os.path.realpath(whg))
2633 assert isinstance(self._bindir, bytes)
2633 assert isinstance(self._bindir, bytes)
2634 self._hgcommand = os.path.basename(whg)
2634 self._hgcommand = os.path.basename(whg)
2635 self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')
2635 self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')
2636 os.makedirs(self._tmpbindir)
2636 os.makedirs(self._tmpbindir)
2637
2637
2638 normbin = os.path.normpath(os.path.abspath(whg))
2638 normbin = os.path.normpath(os.path.abspath(whg))
2639 normbin = normbin.replace(os.sep.encode('ascii'), b'/')
2639 normbin = normbin.replace(os.sep.encode('ascii'), b'/')
2640
2640
2641 # Other Python scripts in the test harness need to
2641 # Other Python scripts in the test harness need to
2642 # `import mercurial`. If `hg` is a Python script, we assume
2642 # `import mercurial`. If `hg` is a Python script, we assume
2643 # the Mercurial modules are relative to its path and tell the tests
2643 # the Mercurial modules are relative to its path and tell the tests
2644 # to load Python modules from its directory.
2644 # to load Python modules from its directory.
2645 with open(whg, 'rb') as fh:
2645 with open(whg, 'rb') as fh:
2646 initial = fh.read(1024)
2646 initial = fh.read(1024)
2647
2647
2648 if re.match(b'#!.*python', initial):
2648 if re.match(b'#!.*python', initial):
2649 self._pythondir = self._bindir
2649 self._pythondir = self._bindir
2650 # If it looks like our in-repo Rust binary, use the source root.
2650 # If it looks like our in-repo Rust binary, use the source root.
2651 # This is a bit hacky. But rhg is still not supported outside the
2651 # This is a bit hacky. But rhg is still not supported outside the
2652 # source directory. So until it is, do the simple thing.
2652 # source directory. So until it is, do the simple thing.
2653 elif re.search(b'/rust/target/[^/]+/hg', normbin):
2653 elif re.search(b'/rust/target/[^/]+/hg', normbin):
2654 self._pythondir = os.path.dirname(self._testdir)
2654 self._pythondir = os.path.dirname(self._testdir)
2655 # Fall back to the legacy behavior.
2655 # Fall back to the legacy behavior.
2656 else:
2656 else:
2657 self._pythondir = self._bindir
2657 self._pythondir = self._bindir
2658
2658
2659 else:
2659 else:
2660 self._installdir = os.path.join(self._hgtmp, b"install")
2660 self._installdir = os.path.join(self._hgtmp, b"install")
2661 self._bindir = os.path.join(self._installdir, b"bin")
2661 self._bindir = os.path.join(self._installdir, b"bin")
2662 self._hgcommand = b'hg'
2662 self._hgcommand = b'hg'
2663 self._tmpbindir = self._bindir
2663 self._tmpbindir = self._bindir
2664 self._pythondir = os.path.join(self._installdir, b"lib", b"python")
2664 self._pythondir = os.path.join(self._installdir, b"lib", b"python")
2665
2665
2666 # Force the use of hg.exe instead of relying on MSYS to recognize hg is
2666 # Force the use of hg.exe instead of relying on MSYS to recognize hg is
2667 # a python script and feed it to python.exe. Legacy stdio is force
2667 # a python script and feed it to python.exe. Legacy stdio is force
2668 # enabled by hg.exe, and this is a more realistic way to launch hg
2668 # enabled by hg.exe, and this is a more realistic way to launch hg
2669 # anyway.
2669 # anyway.
2670 if os.name == 'nt' and not self._hgcommand.endswith(b'.exe'):
2670 if os.name == 'nt' and not self._hgcommand.endswith(b'.exe'):
2671 self._hgcommand += b'.exe'
2671 self._hgcommand += b'.exe'
2672
2672
2673 # set CHGHG, then replace "hg" command by "chg"
2673 # set CHGHG, then replace "hg" command by "chg"
2674 chgbindir = self._bindir
2674 chgbindir = self._bindir
2675 if self.options.chg or self.options.with_chg:
2675 if self.options.chg or self.options.with_chg:
2676 osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand)
2676 osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand)
2677 else:
2677 else:
2678 osenvironb.pop(b'CHGHG', None) # drop flag for hghave
2678 osenvironb.pop(b'CHGHG', None) # drop flag for hghave
2679 if self.options.chg:
2679 if self.options.chg:
2680 self._hgcommand = b'chg'
2680 self._hgcommand = b'chg'
2681 elif self.options.with_chg:
2681 elif self.options.with_chg:
2682 chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg))
2682 chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg))
2683 self._hgcommand = os.path.basename(self.options.with_chg)
2683 self._hgcommand = os.path.basename(self.options.with_chg)
2684
2684
2685 osenvironb[b"BINDIR"] = self._bindir
2685 osenvironb[b"BINDIR"] = self._bindir
2686 osenvironb[b"PYTHON"] = PYTHON
2686 osenvironb[b"PYTHON"] = PYTHON
2687
2687
2688 fileb = _bytespath(__file__)
2688 fileb = _bytespath(__file__)
2689 runtestdir = os.path.abspath(os.path.dirname(fileb))
2689 runtestdir = os.path.abspath(os.path.dirname(fileb))
2690 osenvironb[b'RUNTESTDIR'] = runtestdir
2690 osenvironb[b'RUNTESTDIR'] = runtestdir
2691 if PYTHON3:
2691 if PYTHON3:
2692 sepb = _bytespath(os.pathsep)
2692 sepb = _bytespath(os.pathsep)
2693 else:
2693 else:
2694 sepb = os.pathsep
2694 sepb = os.pathsep
2695 path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
2695 path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
2696 if os.path.islink(__file__):
2696 if os.path.islink(__file__):
2697 # test helper will likely be at the end of the symlink
2697 # test helper will likely be at the end of the symlink
2698 realfile = os.path.realpath(fileb)
2698 realfile = os.path.realpath(fileb)
2699 realdir = os.path.abspath(os.path.dirname(realfile))
2699 realdir = os.path.abspath(os.path.dirname(realfile))
2700 path.insert(2, realdir)
2700 path.insert(2, realdir)
2701 if chgbindir != self._bindir:
2701 if chgbindir != self._bindir:
2702 path.insert(1, chgbindir)
2702 path.insert(1, chgbindir)
2703 if self._testdir != runtestdir:
2703 if self._testdir != runtestdir:
2704 path = [self._testdir] + path
2704 path = [self._testdir] + path
2705 if self._tmpbindir != self._bindir:
2705 if self._tmpbindir != self._bindir:
2706 path = [self._tmpbindir] + path
2706 path = [self._tmpbindir] + path
2707 osenvironb[b"PATH"] = sepb.join(path)
2707 osenvironb[b"PATH"] = sepb.join(path)
2708
2708
2709 # Include TESTDIR in PYTHONPATH so that out-of-tree extensions
2709 # Include TESTDIR in PYTHONPATH so that out-of-tree extensions
2710 # can run .../tests/run-tests.py test-foo where test-foo
2710 # can run .../tests/run-tests.py test-foo where test-foo
2711 # adds an extension to HGRC. Also include run-test.py directory to
2711 # adds an extension to HGRC. Also include run-test.py directory to
2712 # import modules like heredoctest.
2712 # import modules like heredoctest.
2713 pypath = [self._pythondir, self._testdir, runtestdir]
2713 pypath = [self._pythondir, self._testdir, runtestdir]
2714 # We have to augment PYTHONPATH, rather than simply replacing
2714 # We have to augment PYTHONPATH, rather than simply replacing
2715 # it, in case external libraries are only available via current
2715 # it, in case external libraries are only available via current
2716 # PYTHONPATH. (In particular, the Subversion bindings on OS X
2716 # PYTHONPATH. (In particular, the Subversion bindings on OS X
2717 # are in /opt/subversion.)
2717 # are in /opt/subversion.)
2718 oldpypath = osenvironb.get(IMPL_PATH)
2718 oldpypath = osenvironb.get(IMPL_PATH)
2719 if oldpypath:
2719 if oldpypath:
2720 pypath.append(oldpypath)
2720 pypath.append(oldpypath)
2721 osenvironb[IMPL_PATH] = sepb.join(pypath)
2721 osenvironb[IMPL_PATH] = sepb.join(pypath)
2722
2722
2723 if self.options.pure:
2723 if self.options.pure:
2724 os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"
2724 os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"
2725 os.environ["HGMODULEPOLICY"] = "py"
2725 os.environ["HGMODULEPOLICY"] = "py"
2726
2726
2727 if self.options.allow_slow_tests:
2727 if self.options.allow_slow_tests:
2728 os.environ["HGTEST_SLOW"] = "slow"
2728 os.environ["HGTEST_SLOW"] = "slow"
2729 elif 'HGTEST_SLOW' in os.environ:
2729 elif 'HGTEST_SLOW' in os.environ:
2730 del os.environ['HGTEST_SLOW']
2730 del os.environ['HGTEST_SLOW']
2731
2731
2732 self._coveragefile = os.path.join(self._testdir, b'.coverage')
2732 self._coveragefile = os.path.join(self._testdir, b'.coverage')
2733
2733
2734 if self.options.exceptions:
2734 if self.options.exceptions:
2735 exceptionsdir = os.path.join(self._outputdir, b'exceptions')
2735 exceptionsdir = os.path.join(self._outputdir, b'exceptions')
2736 try:
2736 try:
2737 os.makedirs(exceptionsdir)
2737 os.makedirs(exceptionsdir)
2738 except OSError as e:
2738 except OSError as e:
2739 if e.errno != errno.EEXIST:
2739 if e.errno != errno.EEXIST:
2740 raise
2740 raise
2741
2741
2742 # Remove all existing exception reports.
2742 # Remove all existing exception reports.
2743 for f in os.listdir(exceptionsdir):
2743 for f in os.listdir(exceptionsdir):
2744 os.unlink(os.path.join(exceptionsdir, f))
2744 os.unlink(os.path.join(exceptionsdir, f))
2745
2745
2746 osenvironb[b'HGEXCEPTIONSDIR'] = exceptionsdir
2746 osenvironb[b'HGEXCEPTIONSDIR'] = exceptionsdir
2747 logexceptions = os.path.join(self._testdir, b'logexceptions.py')
2747 logexceptions = os.path.join(self._testdir, b'logexceptions.py')
2748 self.options.extra_config_opt.append(
2748 self.options.extra_config_opt.append(
2749 'extensions.logexceptions=%s' % logexceptions.decode('utf-8'))
2749 'extensions.logexceptions=%s' % logexceptions.decode('utf-8'))
2750
2750
2751 vlog("# Using TESTDIR", self._testdir)
2751 vlog("# Using TESTDIR", self._testdir)
2752 vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR'])
2752 vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR'])
2753 vlog("# Using HGTMP", self._hgtmp)
2753 vlog("# Using HGTMP", self._hgtmp)
2754 vlog("# Using PATH", os.environ["PATH"])
2754 vlog("# Using PATH", os.environ["PATH"])
2755 vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH])
2755 vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH])
2756 vlog("# Writing to directory", self._outputdir)
2756 vlog("# Writing to directory", self._outputdir)
2757
2757
2758 try:
2758 try:
2759 return self._runtests(testdescs) or 0
2759 return self._runtests(testdescs) or 0
2760 finally:
2760 finally:
2761 time.sleep(.1)
2761 time.sleep(.1)
2762 self._cleanup()
2762 self._cleanup()
2763
2763
2764 def findtests(self, args):
2764 def findtests(self, args):
2765 """Finds possible test files from arguments.
2765 """Finds possible test files from arguments.
2766
2766
2767 If you wish to inject custom tests into the test harness, this would
2767 If you wish to inject custom tests into the test harness, this would
2768 be a good function to monkeypatch or override in a derived class.
2768 be a good function to monkeypatch or override in a derived class.
2769 """
2769 """
2770 if not args:
2770 if not args:
2771 if self.options.changed:
2771 if self.options.changed:
2772 proc = Popen4('hg st --rev "%s" -man0 .' %
2772 proc = Popen4('hg st --rev "%s" -man0 .' %
2773 self.options.changed, None, 0)
2773 self.options.changed, None, 0)
2774 stdout, stderr = proc.communicate()
2774 stdout, stderr = proc.communicate()
2775 args = stdout.strip(b'\0').split(b'\0')
2775 args = stdout.strip(b'\0').split(b'\0')
2776 else:
2776 else:
2777 args = os.listdir(b'.')
2777 args = os.listdir(b'.')
2778
2778
2779 expanded_args = []
2779 expanded_args = []
2780 for arg in args:
2780 for arg in args:
2781 if os.path.isdir(arg):
2781 if os.path.isdir(arg):
2782 if not arg.endswith(b'/'):
2782 if not arg.endswith(b'/'):
2783 arg += b'/'
2783 arg += b'/'
2784 expanded_args.extend([arg + a for a in os.listdir(arg)])
2784 expanded_args.extend([arg + a for a in os.listdir(arg)])
2785 else:
2785 else:
2786 expanded_args.append(arg)
2786 expanded_args.append(arg)
2787 args = expanded_args
2787 args = expanded_args
2788
2788
2789 testcasepattern = re.compile(br'([\w-]+\.t|py)(#([a-zA-Z0-9_\-\.#]+))')
2789 testcasepattern = re.compile(br'([\w-]+\.t|py)(#([a-zA-Z0-9_\-\.#]+))')
2790 tests = []
2790 tests = []
2791 for t in args:
2791 for t in args:
2792 case = []
2792 case = []
2793
2793
2794 if not (os.path.basename(t).startswith(b'test-')
2794 if not (os.path.basename(t).startswith(b'test-')
2795 and (t.endswith(b'.py') or t.endswith(b'.t'))):
2795 and (t.endswith(b'.py') or t.endswith(b'.t'))):
2796
2796
2797 m = testcasepattern.match(t)
2797 m = testcasepattern.match(os.path.basename(t))
2798 if m is not None:
2798 if m is not None:
2799 t, _, casestr = m.groups()
2799 t_basename, _, casestr = m.groups()
2800 t = os.path.join(os.path.dirname(t), t_basename)
2800 if casestr:
2801 if casestr:
2801 case = casestr.split(b'#')
2802 case = casestr.split(b'#')
2802 else:
2803 else:
2803 continue
2804 continue
2804
2805
2805 if t.endswith(b'.t'):
2806 if t.endswith(b'.t'):
2806 # .t file may contain multiple test cases
2807 # .t file may contain multiple test cases
2807 casedimensions = parsettestcases(t)
2808 casedimensions = parsettestcases(t)
2808 if casedimensions:
2809 if casedimensions:
2809 cases = []
2810 cases = []
2810 def addcases(case, casedimensions):
2811 def addcases(case, casedimensions):
2811 if not casedimensions:
2812 if not casedimensions:
2812 cases.append(case)
2813 cases.append(case)
2813 else:
2814 else:
2814 for c in casedimensions[0]:
2815 for c in casedimensions[0]:
2815 addcases(case + [c], casedimensions[1:])
2816 addcases(case + [c], casedimensions[1:])
2816 addcases([], casedimensions)
2817 addcases([], casedimensions)
2817 if case and case in cases:
2818 if case and case in cases:
2818 cases = [case]
2819 cases = [case]
2819 elif case:
2820 elif case:
2820 # Ignore invalid cases
2821 # Ignore invalid cases
2821 cases = []
2822 cases = []
2822 else:
2823 else:
2823 pass
2824 pass
2824 tests += [{'path': t, 'case': c} for c in sorted(cases)]
2825 tests += [{'path': t, 'case': c} for c in sorted(cases)]
2825 else:
2826 else:
2826 tests.append({'path': t})
2827 tests.append({'path': t})
2827 else:
2828 else:
2828 tests.append({'path': t})
2829 tests.append({'path': t})
2829 return tests
2830 return tests
2830
2831
2831 def _runtests(self, testdescs):
2832 def _runtests(self, testdescs):
2832 def _reloadtest(test, i):
2833 def _reloadtest(test, i):
2833 # convert a test back to its description dict
2834 # convert a test back to its description dict
2834 desc = {'path': test.path}
2835 desc = {'path': test.path}
2835 case = getattr(test, '_case', [])
2836 case = getattr(test, '_case', [])
2836 if case:
2837 if case:
2837 desc['case'] = case
2838 desc['case'] = case
2838 return self._gettest(desc, i)
2839 return self._gettest(desc, i)
2839
2840
2840 try:
2841 try:
2841 if self.options.restart:
2842 if self.options.restart:
2842 orig = list(testdescs)
2843 orig = list(testdescs)
2843 while testdescs:
2844 while testdescs:
2844 desc = testdescs[0]
2845 desc = testdescs[0]
2845 # desc['path'] is a relative path
2846 # desc['path'] is a relative path
2846 if 'case' in desc:
2847 if 'case' in desc:
2847 casestr = b'#'.join(desc['case'])
2848 casestr = b'#'.join(desc['case'])
2848 errpath = b'%s#%s.err' % (desc['path'], casestr)
2849 errpath = b'%s#%s.err' % (desc['path'], casestr)
2849 else:
2850 else:
2850 errpath = b'%s.err' % desc['path']
2851 errpath = b'%s.err' % desc['path']
2851 errpath = os.path.join(self._outputdir, errpath)
2852 errpath = os.path.join(self._outputdir, errpath)
2852 if os.path.exists(errpath):
2853 if os.path.exists(errpath):
2853 break
2854 break
2854 testdescs.pop(0)
2855 testdescs.pop(0)
2855 if not testdescs:
2856 if not testdescs:
2856 print("running all tests")
2857 print("running all tests")
2857 testdescs = orig
2858 testdescs = orig
2858
2859
2859 tests = [self._gettest(d, i) for i, d in enumerate(testdescs)]
2860 tests = [self._gettest(d, i) for i, d in enumerate(testdescs)]
2860
2861
2861 jobs = min(len(tests), self.options.jobs)
2862 jobs = min(len(tests), self.options.jobs)
2862
2863
2863 failed = False
2864 failed = False
2864 kws = self.options.keywords
2865 kws = self.options.keywords
2865 if kws is not None and PYTHON3:
2866 if kws is not None and PYTHON3:
2866 kws = kws.encode('utf-8')
2867 kws = kws.encode('utf-8')
2867
2868
2868 suite = TestSuite(self._testdir,
2869 suite = TestSuite(self._testdir,
2869 jobs=jobs,
2870 jobs=jobs,
2870 whitelist=self.options.whitelisted,
2871 whitelist=self.options.whitelisted,
2871 blacklist=self.options.blacklist,
2872 blacklist=self.options.blacklist,
2872 retest=self.options.retest,
2873 retest=self.options.retest,
2873 keywords=kws,
2874 keywords=kws,
2874 loop=self.options.loop,
2875 loop=self.options.loop,
2875 runs_per_test=self.options.runs_per_test,
2876 runs_per_test=self.options.runs_per_test,
2876 showchannels=self.options.showchannels,
2877 showchannels=self.options.showchannels,
2877 tests=tests, loadtest=_reloadtest)
2878 tests=tests, loadtest=_reloadtest)
2878 verbosity = 1
2879 verbosity = 1
2879 if self.options.list_tests:
2880 if self.options.list_tests:
2880 verbosity = 0
2881 verbosity = 0
2881 elif self.options.verbose:
2882 elif self.options.verbose:
2882 verbosity = 2
2883 verbosity = 2
2883 runner = TextTestRunner(self, verbosity=verbosity)
2884 runner = TextTestRunner(self, verbosity=verbosity)
2884
2885
2885 if self.options.list_tests:
2886 if self.options.list_tests:
2886 result = runner.listtests(suite)
2887 result = runner.listtests(suite)
2887 else:
2888 else:
2888 if self._installdir:
2889 if self._installdir:
2889 self._installhg()
2890 self._installhg()
2890 self._checkhglib("Testing")
2891 self._checkhglib("Testing")
2891 else:
2892 else:
2892 self._usecorrectpython()
2893 self._usecorrectpython()
2893 if self.options.chg:
2894 if self.options.chg:
2894 assert self._installdir
2895 assert self._installdir
2895 self._installchg()
2896 self._installchg()
2896
2897
2897 log('running %d tests using %d parallel processes' % (
2898 log('running %d tests using %d parallel processes' % (
2898 len(tests), jobs))
2899 len(tests), jobs))
2899
2900
2900 result = runner.run(suite)
2901 result = runner.run(suite)
2901
2902
2902 if result.failures:
2903 if result.failures:
2903 failed = True
2904 failed = True
2904
2905
2905 result.onEnd()
2906 result.onEnd()
2906
2907
2907 if self.options.anycoverage:
2908 if self.options.anycoverage:
2908 self._outputcoverage()
2909 self._outputcoverage()
2909 except KeyboardInterrupt:
2910 except KeyboardInterrupt:
2910 failed = True
2911 failed = True
2911 print("\ninterrupted!")
2912 print("\ninterrupted!")
2912
2913
2913 if failed:
2914 if failed:
2914 return 1
2915 return 1
2915
2916
2916 def _getport(self, count):
2917 def _getport(self, count):
2917 port = self._ports.get(count) # do we have a cached entry?
2918 port = self._ports.get(count) # do we have a cached entry?
2918 if port is None:
2919 if port is None:
2919 portneeded = 3
2920 portneeded = 3
2920 # above 100 tries we just give up and let test reports failure
2921 # above 100 tries we just give up and let test reports failure
2921 for tries in xrange(100):
2922 for tries in xrange(100):
2922 allfree = True
2923 allfree = True
2923 port = self.options.port + self._portoffset
2924 port = self.options.port + self._portoffset
2924 for idx in xrange(portneeded):
2925 for idx in xrange(portneeded):
2925 if not checkportisavailable(port + idx):
2926 if not checkportisavailable(port + idx):
2926 allfree = False
2927 allfree = False
2927 break
2928 break
2928 self._portoffset += portneeded
2929 self._portoffset += portneeded
2929 if allfree:
2930 if allfree:
2930 break
2931 break
2931 self._ports[count] = port
2932 self._ports[count] = port
2932 return port
2933 return port
2933
2934
2934 def _gettest(self, testdesc, count):
2935 def _gettest(self, testdesc, count):
2935 """Obtain a Test by looking at its filename.
2936 """Obtain a Test by looking at its filename.
2936
2937
2937 Returns a Test instance. The Test may not be runnable if it doesn't
2938 Returns a Test instance. The Test may not be runnable if it doesn't
2938 map to a known type.
2939 map to a known type.
2939 """
2940 """
2940 path = testdesc['path']
2941 path = testdesc['path']
2941 lctest = path.lower()
2942 lctest = path.lower()
2942 testcls = Test
2943 testcls = Test
2943
2944
2944 for ext, cls in self.TESTTYPES:
2945 for ext, cls in self.TESTTYPES:
2945 if lctest.endswith(ext):
2946 if lctest.endswith(ext):
2946 testcls = cls
2947 testcls = cls
2947 break
2948 break
2948
2949
2949 refpath = os.path.join(getcwdb(), path)
2950 refpath = os.path.join(getcwdb(), path)
2950 tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
2951 tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
2951
2952
2952 # extra keyword parameters. 'case' is used by .t tests
2953 # extra keyword parameters. 'case' is used by .t tests
2953 kwds = dict((k, testdesc[k]) for k in ['case'] if k in testdesc)
2954 kwds = dict((k, testdesc[k]) for k in ['case'] if k in testdesc)
2954
2955
2955 t = testcls(refpath, self._outputdir, tmpdir,
2956 t = testcls(refpath, self._outputdir, tmpdir,
2956 keeptmpdir=self.options.keep_tmpdir,
2957 keeptmpdir=self.options.keep_tmpdir,
2957 debug=self.options.debug,
2958 debug=self.options.debug,
2958 first=self.options.first,
2959 first=self.options.first,
2959 timeout=self.options.timeout,
2960 timeout=self.options.timeout,
2960 startport=self._getport(count),
2961 startport=self._getport(count),
2961 extraconfigopts=self.options.extra_config_opt,
2962 extraconfigopts=self.options.extra_config_opt,
2962 py3warnings=self.options.py3_warnings,
2963 py3warnings=self.options.py3_warnings,
2963 shell=self.options.shell,
2964 shell=self.options.shell,
2964 hgcommand=self._hgcommand,
2965 hgcommand=self._hgcommand,
2965 usechg=bool(self.options.with_chg or self.options.chg),
2966 usechg=bool(self.options.with_chg or self.options.chg),
2966 useipv6=useipv6, **kwds)
2967 useipv6=useipv6, **kwds)
2967 t.should_reload = True
2968 t.should_reload = True
2968 return t
2969 return t
2969
2970
2970 def _cleanup(self):
2971 def _cleanup(self):
2971 """Clean up state from this test invocation."""
2972 """Clean up state from this test invocation."""
2972 if self.options.keep_tmpdir:
2973 if self.options.keep_tmpdir:
2973 return
2974 return
2974
2975
2975 vlog("# Cleaning up HGTMP", self._hgtmp)
2976 vlog("# Cleaning up HGTMP", self._hgtmp)
2976 shutil.rmtree(self._hgtmp, True)
2977 shutil.rmtree(self._hgtmp, True)
2977 for f in self._createdfiles:
2978 for f in self._createdfiles:
2978 try:
2979 try:
2979 os.remove(f)
2980 os.remove(f)
2980 except OSError:
2981 except OSError:
2981 pass
2982 pass
2982
2983
2983 def _usecorrectpython(self):
2984 def _usecorrectpython(self):
2984 """Configure the environment to use the appropriate Python in tests."""
2985 """Configure the environment to use the appropriate Python in tests."""
2985 # Tests must use the same interpreter as us or bad things will happen.
2986 # Tests must use the same interpreter as us or bad things will happen.
2986 pyexename = sys.platform == 'win32' and b'python.exe' or b'python'
2987 pyexename = sys.platform == 'win32' and b'python.exe' or b'python'
2987
2988
2988 # os.symlink() is a thing with py3 on Windows, but it requires
2989 # os.symlink() is a thing with py3 on Windows, but it requires
2989 # Administrator rights.
2990 # Administrator rights.
2990 if getattr(os, 'symlink', None) and os.name != 'nt':
2991 if getattr(os, 'symlink', None) and os.name != 'nt':
2991 vlog("# Making python executable in test path a symlink to '%s'" %
2992 vlog("# Making python executable in test path a symlink to '%s'" %
2992 sys.executable)
2993 sys.executable)
2993 mypython = os.path.join(self._tmpbindir, pyexename)
2994 mypython = os.path.join(self._tmpbindir, pyexename)
2994 try:
2995 try:
2995 if os.readlink(mypython) == sys.executable:
2996 if os.readlink(mypython) == sys.executable:
2996 return
2997 return
2997 os.unlink(mypython)
2998 os.unlink(mypython)
2998 except OSError as err:
2999 except OSError as err:
2999 if err.errno != errno.ENOENT:
3000 if err.errno != errno.ENOENT:
3000 raise
3001 raise
3001 if self._findprogram(pyexename) != sys.executable:
3002 if self._findprogram(pyexename) != sys.executable:
3002 try:
3003 try:
3003 os.symlink(sys.executable, mypython)
3004 os.symlink(sys.executable, mypython)
3004 self._createdfiles.append(mypython)
3005 self._createdfiles.append(mypython)
3005 except OSError as err:
3006 except OSError as err:
3006 # child processes may race, which is harmless
3007 # child processes may race, which is harmless
3007 if err.errno != errno.EEXIST:
3008 if err.errno != errno.EEXIST:
3008 raise
3009 raise
3009 else:
3010 else:
3010 exedir, exename = os.path.split(sys.executable)
3011 exedir, exename = os.path.split(sys.executable)
3011 vlog("# Modifying search path to find %s as %s in '%s'" %
3012 vlog("# Modifying search path to find %s as %s in '%s'" %
3012 (exename, pyexename, exedir))
3013 (exename, pyexename, exedir))
3013 path = os.environ['PATH'].split(os.pathsep)
3014 path = os.environ['PATH'].split(os.pathsep)
3014 while exedir in path:
3015 while exedir in path:
3015 path.remove(exedir)
3016 path.remove(exedir)
3016 os.environ['PATH'] = os.pathsep.join([exedir] + path)
3017 os.environ['PATH'] = os.pathsep.join([exedir] + path)
3017 if not self._findprogram(pyexename):
3018 if not self._findprogram(pyexename):
3018 print("WARNING: Cannot find %s in search path" % pyexename)
3019 print("WARNING: Cannot find %s in search path" % pyexename)
3019
3020
3020 def _installhg(self):
3021 def _installhg(self):
3021 """Install hg into the test environment.
3022 """Install hg into the test environment.
3022
3023
3023 This will also configure hg with the appropriate testing settings.
3024 This will also configure hg with the appropriate testing settings.
3024 """
3025 """
3025 vlog("# Performing temporary installation of HG")
3026 vlog("# Performing temporary installation of HG")
3026 installerrs = os.path.join(self._hgtmp, b"install.err")
3027 installerrs = os.path.join(self._hgtmp, b"install.err")
3027 compiler = ''
3028 compiler = ''
3028 if self.options.compiler:
3029 if self.options.compiler:
3029 compiler = '--compiler ' + self.options.compiler
3030 compiler = '--compiler ' + self.options.compiler
3030 if self.options.pure:
3031 if self.options.pure:
3031 pure = b"--pure"
3032 pure = b"--pure"
3032 else:
3033 else:
3033 pure = b""
3034 pure = b""
3034
3035
3035 # Run installer in hg root
3036 # Run installer in hg root
3036 script = os.path.realpath(sys.argv[0])
3037 script = os.path.realpath(sys.argv[0])
3037 exe = sys.executable
3038 exe = sys.executable
3038 if PYTHON3:
3039 if PYTHON3:
3039 compiler = _bytespath(compiler)
3040 compiler = _bytespath(compiler)
3040 script = _bytespath(script)
3041 script = _bytespath(script)
3041 exe = _bytespath(exe)
3042 exe = _bytespath(exe)
3042 hgroot = os.path.dirname(os.path.dirname(script))
3043 hgroot = os.path.dirname(os.path.dirname(script))
3043 self._hgroot = hgroot
3044 self._hgroot = hgroot
3044 os.chdir(hgroot)
3045 os.chdir(hgroot)
3045 nohome = b'--home=""'
3046 nohome = b'--home=""'
3046 if os.name == 'nt':
3047 if os.name == 'nt':
3047 # The --home="" trick works only on OS where os.sep == '/'
3048 # The --home="" trick works only on OS where os.sep == '/'
3048 # because of a distutils convert_path() fast-path. Avoid it at
3049 # because of a distutils convert_path() fast-path. Avoid it at
3049 # least on Windows for now, deal with .pydistutils.cfg bugs
3050 # least on Windows for now, deal with .pydistutils.cfg bugs
3050 # when they happen.
3051 # when they happen.
3051 nohome = b''
3052 nohome = b''
3052 cmd = (b'"%(exe)s" setup.py %(pure)s clean --all'
3053 cmd = (b'"%(exe)s" setup.py %(pure)s clean --all'
3053 b' build %(compiler)s --build-base="%(base)s"'
3054 b' build %(compiler)s --build-base="%(base)s"'
3054 b' install --force --prefix="%(prefix)s"'
3055 b' install --force --prefix="%(prefix)s"'
3055 b' --install-lib="%(libdir)s"'
3056 b' --install-lib="%(libdir)s"'
3056 b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'
3057 b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'
3057 % {b'exe': exe, b'pure': pure,
3058 % {b'exe': exe, b'pure': pure,
3058 b'compiler': compiler,
3059 b'compiler': compiler,
3059 b'base': os.path.join(self._hgtmp, b"build"),
3060 b'base': os.path.join(self._hgtmp, b"build"),
3060 b'prefix': self._installdir, b'libdir': self._pythondir,
3061 b'prefix': self._installdir, b'libdir': self._pythondir,
3061 b'bindir': self._bindir,
3062 b'bindir': self._bindir,
3062 b'nohome': nohome, b'logfile': installerrs})
3063 b'nohome': nohome, b'logfile': installerrs})
3063
3064
3064 # setuptools requires install directories to exist.
3065 # setuptools requires install directories to exist.
3065 def makedirs(p):
3066 def makedirs(p):
3066 try:
3067 try:
3067 os.makedirs(p)
3068 os.makedirs(p)
3068 except OSError as e:
3069 except OSError as e:
3069 if e.errno != errno.EEXIST:
3070 if e.errno != errno.EEXIST:
3070 raise
3071 raise
3071 makedirs(self._pythondir)
3072 makedirs(self._pythondir)
3072 makedirs(self._bindir)
3073 makedirs(self._bindir)
3073
3074
3074 vlog("# Running", cmd)
3075 vlog("# Running", cmd)
3075 if subprocess.call(_strpath(cmd), shell=True) == 0:
3076 if subprocess.call(_strpath(cmd), shell=True) == 0:
3076 if not self.options.verbose:
3077 if not self.options.verbose:
3077 try:
3078 try:
3078 os.remove(installerrs)
3079 os.remove(installerrs)
3079 except OSError as e:
3080 except OSError as e:
3080 if e.errno != errno.ENOENT:
3081 if e.errno != errno.ENOENT:
3081 raise
3082 raise
3082 else:
3083 else:
3083 with open(installerrs, 'rb') as f:
3084 with open(installerrs, 'rb') as f:
3084 for line in f:
3085 for line in f:
3085 if PYTHON3:
3086 if PYTHON3:
3086 sys.stdout.buffer.write(line)
3087 sys.stdout.buffer.write(line)
3087 else:
3088 else:
3088 sys.stdout.write(line)
3089 sys.stdout.write(line)
3089 sys.exit(1)
3090 sys.exit(1)
3090 os.chdir(self._testdir)
3091 os.chdir(self._testdir)
3091
3092
3092 self._usecorrectpython()
3093 self._usecorrectpython()
3093
3094
3094 if self.options.py3_warnings and not self.options.anycoverage:
3095 if self.options.py3_warnings and not self.options.anycoverage:
3095 vlog("# Updating hg command to enable Py3k Warnings switch")
3096 vlog("# Updating hg command to enable Py3k Warnings switch")
3096 with open(os.path.join(self._bindir, 'hg'), 'rb') as f:
3097 with open(os.path.join(self._bindir, 'hg'), 'rb') as f:
3097 lines = [line.rstrip() for line in f]
3098 lines = [line.rstrip() for line in f]
3098 lines[0] += ' -3'
3099 lines[0] += ' -3'
3099 with open(os.path.join(self._bindir, 'hg'), 'wb') as f:
3100 with open(os.path.join(self._bindir, 'hg'), 'wb') as f:
3100 for line in lines:
3101 for line in lines:
3101 f.write(line + '\n')
3102 f.write(line + '\n')
3102
3103
3103 hgbat = os.path.join(self._bindir, b'hg.bat')
3104 hgbat = os.path.join(self._bindir, b'hg.bat')
3104 if os.path.isfile(hgbat):
3105 if os.path.isfile(hgbat):
3105 # hg.bat expects to be put in bin/scripts while run-tests.py
3106 # hg.bat expects to be put in bin/scripts while run-tests.py
3106 # installation layout put it in bin/ directly. Fix it
3107 # installation layout put it in bin/ directly. Fix it
3107 with open(hgbat, 'rb') as f:
3108 with open(hgbat, 'rb') as f:
3108 data = f.read()
3109 data = f.read()
3109 if b'"%~dp0..\python" "%~dp0hg" %*' in data:
3110 if b'"%~dp0..\python" "%~dp0hg" %*' in data:
3110 data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*',
3111 data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*',
3111 b'"%~dp0python" "%~dp0hg" %*')
3112 b'"%~dp0python" "%~dp0hg" %*')
3112 with open(hgbat, 'wb') as f:
3113 with open(hgbat, 'wb') as f:
3113 f.write(data)
3114 f.write(data)
3114 else:
3115 else:
3115 print('WARNING: cannot fix hg.bat reference to python.exe')
3116 print('WARNING: cannot fix hg.bat reference to python.exe')
3116
3117
3117 if self.options.anycoverage:
3118 if self.options.anycoverage:
3118 custom = os.path.join(self._testdir, 'sitecustomize.py')
3119 custom = os.path.join(self._testdir, 'sitecustomize.py')
3119 target = os.path.join(self._pythondir, 'sitecustomize.py')
3120 target = os.path.join(self._pythondir, 'sitecustomize.py')
3120 vlog('# Installing coverage trigger to %s' % target)
3121 vlog('# Installing coverage trigger to %s' % target)
3121 shutil.copyfile(custom, target)
3122 shutil.copyfile(custom, target)
3122 rc = os.path.join(self._testdir, '.coveragerc')
3123 rc = os.path.join(self._testdir, '.coveragerc')
3123 vlog('# Installing coverage rc to %s' % rc)
3124 vlog('# Installing coverage rc to %s' % rc)
3124 os.environ['COVERAGE_PROCESS_START'] = rc
3125 os.environ['COVERAGE_PROCESS_START'] = rc
3125 covdir = os.path.join(self._installdir, '..', 'coverage')
3126 covdir = os.path.join(self._installdir, '..', 'coverage')
3126 try:
3127 try:
3127 os.mkdir(covdir)
3128 os.mkdir(covdir)
3128 except OSError as e:
3129 except OSError as e:
3129 if e.errno != errno.EEXIST:
3130 if e.errno != errno.EEXIST:
3130 raise
3131 raise
3131
3132
3132 os.environ['COVERAGE_DIR'] = covdir
3133 os.environ['COVERAGE_DIR'] = covdir
3133
3134
3134 def _checkhglib(self, verb):
3135 def _checkhglib(self, verb):
3135 """Ensure that the 'mercurial' package imported by python is
3136 """Ensure that the 'mercurial' package imported by python is
3136 the one we expect it to be. If not, print a warning to stderr."""
3137 the one we expect it to be. If not, print a warning to stderr."""
3137 if ((self._bindir == self._pythondir) and
3138 if ((self._bindir == self._pythondir) and
3138 (self._bindir != self._tmpbindir)):
3139 (self._bindir != self._tmpbindir)):
3139 # The pythondir has been inferred from --with-hg flag.
3140 # The pythondir has been inferred from --with-hg flag.
3140 # We cannot expect anything sensible here.
3141 # We cannot expect anything sensible here.
3141 return
3142 return
3142 expecthg = os.path.join(self._pythondir, b'mercurial')
3143 expecthg = os.path.join(self._pythondir, b'mercurial')
3143 actualhg = self._gethgpath()
3144 actualhg = self._gethgpath()
3144 if os.path.abspath(actualhg) != os.path.abspath(expecthg):
3145 if os.path.abspath(actualhg) != os.path.abspath(expecthg):
3145 sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n'
3146 sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n'
3146 ' (expected %s)\n'
3147 ' (expected %s)\n'
3147 % (verb, actualhg, expecthg))
3148 % (verb, actualhg, expecthg))
3148 def _gethgpath(self):
3149 def _gethgpath(self):
3149 """Return the path to the mercurial package that is actually found by
3150 """Return the path to the mercurial package that is actually found by
3150 the current Python interpreter."""
3151 the current Python interpreter."""
3151 if self._hgpath is not None:
3152 if self._hgpath is not None:
3152 return self._hgpath
3153 return self._hgpath
3153
3154
3154 cmd = b'"%s" -c "import mercurial; print (mercurial.__path__[0])"'
3155 cmd = b'"%s" -c "import mercurial; print (mercurial.__path__[0])"'
3155 cmd = cmd % PYTHON
3156 cmd = cmd % PYTHON
3156 if PYTHON3:
3157 if PYTHON3:
3157 cmd = _strpath(cmd)
3158 cmd = _strpath(cmd)
3158
3159
3159 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
3160 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
3160 out, err = p.communicate()
3161 out, err = p.communicate()
3161
3162
3162 self._hgpath = out.strip()
3163 self._hgpath = out.strip()
3163
3164
3164 return self._hgpath
3165 return self._hgpath
3165
3166
3166 def _installchg(self):
3167 def _installchg(self):
3167 """Install chg into the test environment"""
3168 """Install chg into the test environment"""
3168 vlog('# Performing temporary installation of CHG')
3169 vlog('# Performing temporary installation of CHG')
3169 assert os.path.dirname(self._bindir) == self._installdir
3170 assert os.path.dirname(self._bindir) == self._installdir
3170 assert self._hgroot, 'must be called after _installhg()'
3171 assert self._hgroot, 'must be called after _installhg()'
3171 cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"'
3172 cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"'
3172 % {b'make': 'make', # TODO: switch by option or environment?
3173 % {b'make': 'make', # TODO: switch by option or environment?
3173 b'prefix': self._installdir})
3174 b'prefix': self._installdir})
3174 cwd = os.path.join(self._hgroot, b'contrib', b'chg')
3175 cwd = os.path.join(self._hgroot, b'contrib', b'chg')
3175 vlog("# Running", cmd)
3176 vlog("# Running", cmd)
3176 proc = subprocess.Popen(cmd, shell=True, cwd=cwd,
3177 proc = subprocess.Popen(cmd, shell=True, cwd=cwd,
3177 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
3178 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
3178 stderr=subprocess.STDOUT)
3179 stderr=subprocess.STDOUT)
3179 out, _err = proc.communicate()
3180 out, _err = proc.communicate()
3180 if proc.returncode != 0:
3181 if proc.returncode != 0:
3181 if PYTHON3:
3182 if PYTHON3:
3182 sys.stdout.buffer.write(out)
3183 sys.stdout.buffer.write(out)
3183 else:
3184 else:
3184 sys.stdout.write(out)
3185 sys.stdout.write(out)
3185 sys.exit(1)
3186 sys.exit(1)
3186
3187
3187 def _outputcoverage(self):
3188 def _outputcoverage(self):
3188 """Produce code coverage output."""
3189 """Produce code coverage output."""
3189 import coverage
3190 import coverage
3190 coverage = coverage.coverage
3191 coverage = coverage.coverage
3191
3192
3192 vlog('# Producing coverage report')
3193 vlog('# Producing coverage report')
3193 # chdir is the easiest way to get short, relative paths in the
3194 # chdir is the easiest way to get short, relative paths in the
3194 # output.
3195 # output.
3195 os.chdir(self._hgroot)
3196 os.chdir(self._hgroot)
3196 covdir = os.path.join(self._installdir, '..', 'coverage')
3197 covdir = os.path.join(self._installdir, '..', 'coverage')
3197 cov = coverage(data_file=os.path.join(covdir, 'cov'))
3198 cov = coverage(data_file=os.path.join(covdir, 'cov'))
3198
3199
3199 # Map install directory paths back to source directory.
3200 # Map install directory paths back to source directory.
3200 cov.config.paths['srcdir'] = ['.', self._pythondir]
3201 cov.config.paths['srcdir'] = ['.', self._pythondir]
3201
3202
3202 cov.combine()
3203 cov.combine()
3203
3204
3204 omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]]
3205 omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]]
3205 cov.report(ignore_errors=True, omit=omit)
3206 cov.report(ignore_errors=True, omit=omit)
3206
3207
3207 if self.options.htmlcov:
3208 if self.options.htmlcov:
3208 htmldir = os.path.join(self._outputdir, 'htmlcov')
3209 htmldir = os.path.join(self._outputdir, 'htmlcov')
3209 cov.html_report(directory=htmldir, omit=omit)
3210 cov.html_report(directory=htmldir, omit=omit)
3210 if self.options.annotate:
3211 if self.options.annotate:
3211 adir = os.path.join(self._outputdir, 'annotated')
3212 adir = os.path.join(self._outputdir, 'annotated')
3212 if not os.path.isdir(adir):
3213 if not os.path.isdir(adir):
3213 os.mkdir(adir)
3214 os.mkdir(adir)
3214 cov.annotate(directory=adir, omit=omit)
3215 cov.annotate(directory=adir, omit=omit)
3215
3216
3216 def _findprogram(self, program):
3217 def _findprogram(self, program):
3217 """Search PATH for a executable program"""
3218 """Search PATH for a executable program"""
3218 dpb = _bytespath(os.defpath)
3219 dpb = _bytespath(os.defpath)
3219 sepb = _bytespath(os.pathsep)
3220 sepb = _bytespath(os.pathsep)
3220 for p in osenvironb.get(b'PATH', dpb).split(sepb):
3221 for p in osenvironb.get(b'PATH', dpb).split(sepb):
3221 name = os.path.join(p, program)
3222 name = os.path.join(p, program)
3222 if os.name == 'nt' or os.access(name, os.X_OK):
3223 if os.name == 'nt' or os.access(name, os.X_OK):
3223 return name
3224 return name
3224 return None
3225 return None
3225
3226
3226 def _checktools(self):
3227 def _checktools(self):
3227 """Ensure tools required to run tests are present."""
3228 """Ensure tools required to run tests are present."""
3228 for p in self.REQUIREDTOOLS:
3229 for p in self.REQUIREDTOOLS:
3229 if os.name == 'nt' and not p.endswith(b'.exe'):
3230 if os.name == 'nt' and not p.endswith(b'.exe'):
3230 p += b'.exe'
3231 p += b'.exe'
3231 found = self._findprogram(p)
3232 found = self._findprogram(p)
3232 if found:
3233 if found:
3233 vlog("# Found prerequisite", p, "at", found)
3234 vlog("# Found prerequisite", p, "at", found)
3234 else:
3235 else:
3235 print("WARNING: Did not find prerequisite tool: %s " %
3236 print("WARNING: Did not find prerequisite tool: %s " %
3236 p.decode("utf-8"))
3237 p.decode("utf-8"))
3237
3238
3238 def aggregateexceptions(path):
3239 def aggregateexceptions(path):
3239 exceptioncounts = collections.Counter()
3240 exceptioncounts = collections.Counter()
3240 testsbyfailure = collections.defaultdict(set)
3241 testsbyfailure = collections.defaultdict(set)
3241 failuresbytest = collections.defaultdict(set)
3242 failuresbytest = collections.defaultdict(set)
3242
3243
3243 for f in os.listdir(path):
3244 for f in os.listdir(path):
3244 with open(os.path.join(path, f), 'rb') as fh:
3245 with open(os.path.join(path, f), 'rb') as fh:
3245 data = fh.read().split(b'\0')
3246 data = fh.read().split(b'\0')
3246 if len(data) != 5:
3247 if len(data) != 5:
3247 continue
3248 continue
3248
3249
3249 exc, mainframe, hgframe, hgline, testname = data
3250 exc, mainframe, hgframe, hgline, testname = data
3250 exc = exc.decode('utf-8')
3251 exc = exc.decode('utf-8')
3251 mainframe = mainframe.decode('utf-8')
3252 mainframe = mainframe.decode('utf-8')
3252 hgframe = hgframe.decode('utf-8')
3253 hgframe = hgframe.decode('utf-8')
3253 hgline = hgline.decode('utf-8')
3254 hgline = hgline.decode('utf-8')
3254 testname = testname.decode('utf-8')
3255 testname = testname.decode('utf-8')
3255
3256
3256 key = (hgframe, hgline, exc)
3257 key = (hgframe, hgline, exc)
3257 exceptioncounts[key] += 1
3258 exceptioncounts[key] += 1
3258 testsbyfailure[key].add(testname)
3259 testsbyfailure[key].add(testname)
3259 failuresbytest[testname].add(key)
3260 failuresbytest[testname].add(key)
3260
3261
3261 # Find test having fewest failures for each failure.
3262 # Find test having fewest failures for each failure.
3262 leastfailing = {}
3263 leastfailing = {}
3263 for key, tests in testsbyfailure.items():
3264 for key, tests in testsbyfailure.items():
3264 fewesttest = None
3265 fewesttest = None
3265 fewestcount = 99999999
3266 fewestcount = 99999999
3266 for test in sorted(tests):
3267 for test in sorted(tests):
3267 if len(failuresbytest[test]) < fewestcount:
3268 if len(failuresbytest[test]) < fewestcount:
3268 fewesttest = test
3269 fewesttest = test
3269 fewestcount = len(failuresbytest[test])
3270 fewestcount = len(failuresbytest[test])
3270
3271
3271 leastfailing[key] = (fewestcount, fewesttest)
3272 leastfailing[key] = (fewestcount, fewesttest)
3272
3273
3273 # Create a combined counter so we can sort by total occurrences and
3274 # Create a combined counter so we can sort by total occurrences and
3274 # impacted tests.
3275 # impacted tests.
3275 combined = {}
3276 combined = {}
3276 for key in exceptioncounts:
3277 for key in exceptioncounts:
3277 combined[key] = (exceptioncounts[key],
3278 combined[key] = (exceptioncounts[key],
3278 len(testsbyfailure[key]),
3279 len(testsbyfailure[key]),
3279 leastfailing[key][0],
3280 leastfailing[key][0],
3280 leastfailing[key][1])
3281 leastfailing[key][1])
3281
3282
3282 return {
3283 return {
3283 'exceptioncounts': exceptioncounts,
3284 'exceptioncounts': exceptioncounts,
3284 'total': sum(exceptioncounts.values()),
3285 'total': sum(exceptioncounts.values()),
3285 'combined': combined,
3286 'combined': combined,
3286 'leastfailing': leastfailing,
3287 'leastfailing': leastfailing,
3287 'byfailure': testsbyfailure,
3288 'byfailure': testsbyfailure,
3288 'bytest': failuresbytest,
3289 'bytest': failuresbytest,
3289 }
3290 }
3290
3291
3291 if __name__ == '__main__':
3292 if __name__ == '__main__':
3292 runner = TestRunner()
3293 runner = TestRunner()
3293
3294
3294 try:
3295 try:
3295 import msvcrt
3296 import msvcrt
3296 msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
3297 msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
3297 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3298 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3298 msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
3299 msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
3299 except ImportError:
3300 except ImportError:
3300 pass
3301 pass
3301
3302
3302 sys.exit(runner.run(sys.argv[1:]))
3303 sys.exit(runner.run(sys.argv[1:]))
General Comments 0
You need to be logged in to leave comments. Login now