##// END OF EJS Templates
run-tests: write bytes to the binary buffer on sys.{stdout,stderr}
Augie Fackler -
r25053:4f2c74ef default
parent child Browse files
Show More
@@ -1,2165 +1,2170
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 #
38 #
39 # (You could use any subset of the tests: test-s* happens to match
39 # (You could use any subset of the tests: test-s* happens to match
40 # enough that it's worth doing parallel runs, few enough that it
40 # enough that it's worth doing parallel runs, few enough that it
41 # completes fairly quickly, includes both shell and Python scripts, and
41 # completes fairly quickly, includes both shell and Python scripts, and
42 # includes some scripts that run daemon processes.)
42 # includes some scripts that run daemon processes.)
43
43
44 from __future__ import print_function
44 from __future__ import print_function
45
45
46 from distutils import version
46 from distutils import version
47 import difflib
47 import difflib
48 import errno
48 import errno
49 import optparse
49 import optparse
50 import os
50 import os
51 import shutil
51 import shutil
52 import subprocess
52 import subprocess
53 import signal
53 import signal
54 import socket
54 import socket
55 import sys
55 import sys
56 import tempfile
56 import tempfile
57 import time
57 import time
58 import random
58 import random
59 import re
59 import re
60 import threading
60 import threading
61 import killdaemons as killmod
61 import killdaemons as killmod
62 try:
62 try:
63 import Queue as queue
63 import Queue as queue
64 except ImportError:
64 except ImportError:
65 import queue
65 import queue
66 from xml.dom import minidom
66 from xml.dom import minidom
67 import unittest
67 import unittest
68
68
69 osenvironb = getattr(os, 'environb', os.environ)
69 osenvironb = getattr(os, 'environb', os.environ)
70
70
71 try:
71 try:
72 import json
72 import json
73 except ImportError:
73 except ImportError:
74 try:
74 try:
75 import simplejson as json
75 import simplejson as json
76 except ImportError:
76 except ImportError:
77 json = None
77 json = None
78
78
79 processlock = threading.Lock()
79 processlock = threading.Lock()
80
80
81 if sys.version_info > (3, 0, 0):
81 if sys.version_info > (3, 0, 0):
82 xrange = range # we use xrange in one place, and we'd rather not use range
82 xrange = range # we use xrange in one place, and we'd rather not use range
83
83
84 # subprocess._cleanup can race with any Popen.wait or Popen.poll on py24
84 # subprocess._cleanup can race with any Popen.wait or Popen.poll on py24
85 # http://bugs.python.org/issue1731717 for details. We shouldn't be producing
85 # http://bugs.python.org/issue1731717 for details. We shouldn't be producing
86 # zombies but it's pretty harmless even if we do.
86 # zombies but it's pretty harmless even if we do.
87 if sys.version_info < (2, 5):
87 if sys.version_info < (2, 5):
88 subprocess._cleanup = lambda: None
88 subprocess._cleanup = lambda: None
89
89
90 wifexited = getattr(os, "WIFEXITED", lambda x: False)
90 wifexited = getattr(os, "WIFEXITED", lambda x: False)
91
91
92 def checkportisavailable(port):
92 def checkportisavailable(port):
93 """return true if a port seems free to bind on localhost"""
93 """return true if a port seems free to bind on localhost"""
94 try:
94 try:
95 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
95 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
96 s.bind(('localhost', port))
96 s.bind(('localhost', port))
97 s.close()
97 s.close()
98 return True
98 return True
99 except socket.error as exc:
99 except socket.error as exc:
100 if not exc.errno == errno.EADDRINUSE:
100 if not exc.errno == errno.EADDRINUSE:
101 raise
101 raise
102 return False
102 return False
103
103
104 closefds = os.name == 'posix'
104 closefds = os.name == 'posix'
105 def Popen4(cmd, wd, timeout, env=None):
105 def Popen4(cmd, wd, timeout, env=None):
106 processlock.acquire()
106 processlock.acquire()
107 p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env,
107 p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env,
108 close_fds=closefds,
108 close_fds=closefds,
109 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
109 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
110 stderr=subprocess.STDOUT)
110 stderr=subprocess.STDOUT)
111 processlock.release()
111 processlock.release()
112
112
113 p.fromchild = p.stdout
113 p.fromchild = p.stdout
114 p.tochild = p.stdin
114 p.tochild = p.stdin
115 p.childerr = p.stderr
115 p.childerr = p.stderr
116
116
117 p.timeout = False
117 p.timeout = False
118 if timeout:
118 if timeout:
119 def t():
119 def t():
120 start = time.time()
120 start = time.time()
121 while time.time() - start < timeout and p.returncode is None:
121 while time.time() - start < timeout and p.returncode is None:
122 time.sleep(.1)
122 time.sleep(.1)
123 p.timeout = True
123 p.timeout = True
124 if p.returncode is None:
124 if p.returncode is None:
125 terminate(p)
125 terminate(p)
126 threading.Thread(target=t).start()
126 threading.Thread(target=t).start()
127
127
128 return p
128 return p
129
129
130 PYTHON = sys.executable.replace('\\', '/')
130 PYTHON = sys.executable.replace('\\', '/')
131 IMPL_PATH = b'PYTHONPATH'
131 IMPL_PATH = b'PYTHONPATH'
132 if 'java' in sys.platform:
132 if 'java' in sys.platform:
133 IMPL_PATH = b'JYTHONPATH'
133 IMPL_PATH = b'JYTHONPATH'
134
134
135 defaults = {
135 defaults = {
136 'jobs': ('HGTEST_JOBS', 1),
136 'jobs': ('HGTEST_JOBS', 1),
137 'timeout': ('HGTEST_TIMEOUT', 180),
137 'timeout': ('HGTEST_TIMEOUT', 180),
138 'port': ('HGTEST_PORT', 20059),
138 'port': ('HGTEST_PORT', 20059),
139 'shell': ('HGTEST_SHELL', 'sh'),
139 'shell': ('HGTEST_SHELL', 'sh'),
140 }
140 }
141
141
142 def parselistfiles(files, listtype, warn=True):
142 def parselistfiles(files, listtype, warn=True):
143 entries = dict()
143 entries = dict()
144 for filename in files:
144 for filename in files:
145 try:
145 try:
146 path = os.path.expanduser(os.path.expandvars(filename))
146 path = os.path.expanduser(os.path.expandvars(filename))
147 f = open(path, "rb")
147 f = open(path, "rb")
148 except IOError as err:
148 except IOError as err:
149 if err.errno != errno.ENOENT:
149 if err.errno != errno.ENOENT:
150 raise
150 raise
151 if warn:
151 if warn:
152 print("warning: no such %s file: %s" % (listtype, filename))
152 print("warning: no such %s file: %s" % (listtype, filename))
153 continue
153 continue
154
154
155 for line in f.readlines():
155 for line in f.readlines():
156 line = line.split(b'#', 1)[0].strip()
156 line = line.split(b'#', 1)[0].strip()
157 if line:
157 if line:
158 entries[line] = filename
158 entries[line] = filename
159
159
160 f.close()
160 f.close()
161 return entries
161 return entries
162
162
163 def getparser():
163 def getparser():
164 """Obtain the OptionParser used by the CLI."""
164 """Obtain the OptionParser used by the CLI."""
165 parser = optparse.OptionParser("%prog [options] [tests]")
165 parser = optparse.OptionParser("%prog [options] [tests]")
166
166
167 # keep these sorted
167 # keep these sorted
168 parser.add_option("--blacklist", action="append",
168 parser.add_option("--blacklist", action="append",
169 help="skip tests listed in the specified blacklist file")
169 help="skip tests listed in the specified blacklist file")
170 parser.add_option("--whitelist", action="append",
170 parser.add_option("--whitelist", action="append",
171 help="always run tests listed in the specified whitelist file")
171 help="always run tests listed in the specified whitelist file")
172 parser.add_option("--changed", type="string",
172 parser.add_option("--changed", type="string",
173 help="run tests that are changed in parent rev or working directory")
173 help="run tests that are changed in parent rev or working directory")
174 parser.add_option("-C", "--annotate", action="store_true",
174 parser.add_option("-C", "--annotate", action="store_true",
175 help="output files annotated with coverage")
175 help="output files annotated with coverage")
176 parser.add_option("-c", "--cover", action="store_true",
176 parser.add_option("-c", "--cover", action="store_true",
177 help="print a test coverage report")
177 help="print a test coverage report")
178 parser.add_option("-d", "--debug", action="store_true",
178 parser.add_option("-d", "--debug", action="store_true",
179 help="debug mode: write output of test scripts to console"
179 help="debug mode: write output of test scripts to console"
180 " rather than capturing and diffing it (disables timeout)")
180 " rather than capturing and diffing it (disables timeout)")
181 parser.add_option("-f", "--first", action="store_true",
181 parser.add_option("-f", "--first", action="store_true",
182 help="exit on the first test failure")
182 help="exit on the first test failure")
183 parser.add_option("-H", "--htmlcov", action="store_true",
183 parser.add_option("-H", "--htmlcov", action="store_true",
184 help="create an HTML report of the coverage of the files")
184 help="create an HTML report of the coverage of the files")
185 parser.add_option("-i", "--interactive", action="store_true",
185 parser.add_option("-i", "--interactive", action="store_true",
186 help="prompt to accept changed output")
186 help="prompt to accept changed output")
187 parser.add_option("-j", "--jobs", type="int",
187 parser.add_option("-j", "--jobs", type="int",
188 help="number of jobs to run in parallel"
188 help="number of jobs to run in parallel"
189 " (default: $%s or %d)" % defaults['jobs'])
189 " (default: $%s or %d)" % defaults['jobs'])
190 parser.add_option("--keep-tmpdir", action="store_true",
190 parser.add_option("--keep-tmpdir", action="store_true",
191 help="keep temporary directory after running tests")
191 help="keep temporary directory after running tests")
192 parser.add_option("-k", "--keywords",
192 parser.add_option("-k", "--keywords",
193 help="run tests matching keywords")
193 help="run tests matching keywords")
194 parser.add_option("-l", "--local", action="store_true",
194 parser.add_option("-l", "--local", action="store_true",
195 help="shortcut for --with-hg=<testdir>/../hg")
195 help="shortcut for --with-hg=<testdir>/../hg")
196 parser.add_option("--loop", action="store_true",
196 parser.add_option("--loop", action="store_true",
197 help="loop tests repeatedly")
197 help="loop tests repeatedly")
198 parser.add_option("--runs-per-test", type="int", dest="runs_per_test",
198 parser.add_option("--runs-per-test", type="int", dest="runs_per_test",
199 help="run each test N times (default=1)", default=1)
199 help="run each test N times (default=1)", default=1)
200 parser.add_option("-n", "--nodiff", action="store_true",
200 parser.add_option("-n", "--nodiff", action="store_true",
201 help="skip showing test changes")
201 help="skip showing test changes")
202 parser.add_option("-p", "--port", type="int",
202 parser.add_option("-p", "--port", type="int",
203 help="port on which servers should listen"
203 help="port on which servers should listen"
204 " (default: $%s or %d)" % defaults['port'])
204 " (default: $%s or %d)" % defaults['port'])
205 parser.add_option("--compiler", type="string",
205 parser.add_option("--compiler", type="string",
206 help="compiler to build with")
206 help="compiler to build with")
207 parser.add_option("--pure", action="store_true",
207 parser.add_option("--pure", action="store_true",
208 help="use pure Python code instead of C extensions")
208 help="use pure Python code instead of C extensions")
209 parser.add_option("-R", "--restart", action="store_true",
209 parser.add_option("-R", "--restart", action="store_true",
210 help="restart at last error")
210 help="restart at last error")
211 parser.add_option("-r", "--retest", action="store_true",
211 parser.add_option("-r", "--retest", action="store_true",
212 help="retest failed tests")
212 help="retest failed tests")
213 parser.add_option("-S", "--noskips", action="store_true",
213 parser.add_option("-S", "--noskips", action="store_true",
214 help="don't report skip tests verbosely")
214 help="don't report skip tests verbosely")
215 parser.add_option("--shell", type="string",
215 parser.add_option("--shell", type="string",
216 help="shell to use (default: $%s or %s)" % defaults['shell'])
216 help="shell to use (default: $%s or %s)" % defaults['shell'])
217 parser.add_option("-t", "--timeout", type="int",
217 parser.add_option("-t", "--timeout", type="int",
218 help="kill errant tests after TIMEOUT seconds"
218 help="kill errant tests after TIMEOUT seconds"
219 " (default: $%s or %d)" % defaults['timeout'])
219 " (default: $%s or %d)" % defaults['timeout'])
220 parser.add_option("--time", action="store_true",
220 parser.add_option("--time", action="store_true",
221 help="time how long each test takes")
221 help="time how long each test takes")
222 parser.add_option("--json", action="store_true",
222 parser.add_option("--json", action="store_true",
223 help="store test result data in 'report.json' file")
223 help="store test result data in 'report.json' file")
224 parser.add_option("--tmpdir", type="string",
224 parser.add_option("--tmpdir", type="string",
225 help="run tests in the given temporary directory"
225 help="run tests in the given temporary directory"
226 " (implies --keep-tmpdir)")
226 " (implies --keep-tmpdir)")
227 parser.add_option("-v", "--verbose", action="store_true",
227 parser.add_option("-v", "--verbose", action="store_true",
228 help="output verbose messages")
228 help="output verbose messages")
229 parser.add_option("--xunit", type="string",
229 parser.add_option("--xunit", type="string",
230 help="record xunit results at specified path")
230 help="record xunit results at specified path")
231 parser.add_option("--view", type="string",
231 parser.add_option("--view", type="string",
232 help="external diff viewer")
232 help="external diff viewer")
233 parser.add_option("--with-hg", type="string",
233 parser.add_option("--with-hg", type="string",
234 metavar="HG",
234 metavar="HG",
235 help="test using specified hg script rather than a "
235 help="test using specified hg script rather than a "
236 "temporary installation")
236 "temporary installation")
237 parser.add_option("-3", "--py3k-warnings", action="store_true",
237 parser.add_option("-3", "--py3k-warnings", action="store_true",
238 help="enable Py3k warnings on Python 2.6+")
238 help="enable Py3k warnings on Python 2.6+")
239 parser.add_option('--extra-config-opt', action="append",
239 parser.add_option('--extra-config-opt', action="append",
240 help='set the given config opt in the test hgrc')
240 help='set the given config opt in the test hgrc')
241 parser.add_option('--random', action="store_true",
241 parser.add_option('--random', action="store_true",
242 help='run tests in random order')
242 help='run tests in random order')
243
243
244 for option, (envvar, default) in defaults.items():
244 for option, (envvar, default) in defaults.items():
245 defaults[option] = type(default)(os.environ.get(envvar, default))
245 defaults[option] = type(default)(os.environ.get(envvar, default))
246 parser.set_defaults(**defaults)
246 parser.set_defaults(**defaults)
247
247
248 return parser
248 return parser
249
249
250 def parseargs(args, parser):
250 def parseargs(args, parser):
251 """Parse arguments with our OptionParser and validate results."""
251 """Parse arguments with our OptionParser and validate results."""
252 (options, args) = parser.parse_args(args)
252 (options, args) = parser.parse_args(args)
253
253
254 # jython is always pure
254 # jython is always pure
255 if 'java' in sys.platform or '__pypy__' in sys.modules:
255 if 'java' in sys.platform or '__pypy__' in sys.modules:
256 options.pure = True
256 options.pure = True
257
257
258 if options.with_hg:
258 if options.with_hg:
259 options.with_hg = os.path.expanduser(options.with_hg)
259 options.with_hg = os.path.expanduser(options.with_hg)
260 if not (os.path.isfile(options.with_hg) and
260 if not (os.path.isfile(options.with_hg) and
261 os.access(options.with_hg, os.X_OK)):
261 os.access(options.with_hg, os.X_OK)):
262 parser.error('--with-hg must specify an executable hg script')
262 parser.error('--with-hg must specify an executable hg script')
263 if not os.path.basename(options.with_hg) == 'hg':
263 if not os.path.basename(options.with_hg) == 'hg':
264 sys.stderr.write('warning: --with-hg should specify an hg script\n')
264 sys.stderr.write('warning: --with-hg should specify an hg script\n')
265 if options.local:
265 if options.local:
266 testdir = os.path.dirname(os.path.realpath(sys.argv[0]).encode('utf-8'))
266 testdir = os.path.dirname(os.path.realpath(sys.argv[0]).encode('utf-8'))
267 hgbin = os.path.join(os.path.dirname(testdir), b'hg')
267 hgbin = os.path.join(os.path.dirname(testdir), b'hg')
268 if os.name != 'nt' and not os.access(hgbin, os.X_OK):
268 if os.name != 'nt' and not os.access(hgbin, os.X_OK):
269 parser.error('--local specified, but %r not found or not executable'
269 parser.error('--local specified, but %r not found or not executable'
270 % hgbin)
270 % hgbin)
271 options.with_hg = hgbin
271 options.with_hg = hgbin
272
272
273 options.anycoverage = options.cover or options.annotate or options.htmlcov
273 options.anycoverage = options.cover or options.annotate or options.htmlcov
274 if options.anycoverage:
274 if options.anycoverage:
275 try:
275 try:
276 import coverage
276 import coverage
277 covver = version.StrictVersion(coverage.__version__).version
277 covver = version.StrictVersion(coverage.__version__).version
278 if covver < (3, 3):
278 if covver < (3, 3):
279 parser.error('coverage options require coverage 3.3 or later')
279 parser.error('coverage options require coverage 3.3 or later')
280 except ImportError:
280 except ImportError:
281 parser.error('coverage options now require the coverage package')
281 parser.error('coverage options now require the coverage package')
282
282
283 if options.anycoverage and options.local:
283 if options.anycoverage and options.local:
284 # this needs some path mangling somewhere, I guess
284 # this needs some path mangling somewhere, I guess
285 parser.error("sorry, coverage options do not work when --local "
285 parser.error("sorry, coverage options do not work when --local "
286 "is specified")
286 "is specified")
287
287
288 if options.anycoverage and options.with_hg:
288 if options.anycoverage and options.with_hg:
289 parser.error("sorry, coverage options do not work when --with-hg "
289 parser.error("sorry, coverage options do not work when --with-hg "
290 "is specified")
290 "is specified")
291
291
292 global verbose
292 global verbose
293 if options.verbose:
293 if options.verbose:
294 verbose = ''
294 verbose = ''
295
295
296 if options.tmpdir:
296 if options.tmpdir:
297 options.tmpdir = os.path.expanduser(options.tmpdir)
297 options.tmpdir = os.path.expanduser(options.tmpdir)
298
298
299 if options.jobs < 1:
299 if options.jobs < 1:
300 parser.error('--jobs must be positive')
300 parser.error('--jobs must be positive')
301 if options.interactive and options.debug:
301 if options.interactive and options.debug:
302 parser.error("-i/--interactive and -d/--debug are incompatible")
302 parser.error("-i/--interactive and -d/--debug are incompatible")
303 if options.debug:
303 if options.debug:
304 if options.timeout != defaults['timeout']:
304 if options.timeout != defaults['timeout']:
305 sys.stderr.write(
305 sys.stderr.write(
306 'warning: --timeout option ignored with --debug\n')
306 'warning: --timeout option ignored with --debug\n')
307 options.timeout = 0
307 options.timeout = 0
308 if options.py3k_warnings:
308 if options.py3k_warnings:
309 if sys.version_info[:2] < (2, 6) or sys.version_info[:2] >= (3, 0):
309 if sys.version_info[:2] < (2, 6) or sys.version_info[:2] >= (3, 0):
310 parser.error('--py3k-warnings can only be used on Python 2.6+')
310 parser.error('--py3k-warnings can only be used on Python 2.6+')
311 if options.blacklist:
311 if options.blacklist:
312 options.blacklist = parselistfiles(options.blacklist, 'blacklist')
312 options.blacklist = parselistfiles(options.blacklist, 'blacklist')
313 if options.whitelist:
313 if options.whitelist:
314 options.whitelisted = parselistfiles(options.whitelist, 'whitelist')
314 options.whitelisted = parselistfiles(options.whitelist, 'whitelist')
315 else:
315 else:
316 options.whitelisted = {}
316 options.whitelisted = {}
317
317
318 return (options, args)
318 return (options, args)
319
319
320 def rename(src, dst):
320 def rename(src, dst):
321 """Like os.rename(), trade atomicity and opened files friendliness
321 """Like os.rename(), trade atomicity and opened files friendliness
322 for existing destination support.
322 for existing destination support.
323 """
323 """
324 shutil.copy(src, dst)
324 shutil.copy(src, dst)
325 os.remove(src)
325 os.remove(src)
326
326
327 _unified_diff = difflib.unified_diff
327 _unified_diff = difflib.unified_diff
328 if sys.version_info[0] > 2:
328 if sys.version_info[0] > 2:
329 import functools
329 import functools
330 _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)
330 _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)
331
331
332 def getdiff(expected, output, ref, err):
332 def getdiff(expected, output, ref, err):
333 servefail = False
333 servefail = False
334 lines = []
334 lines = []
335 for line in _unified_diff(expected, output, ref, err):
335 for line in _unified_diff(expected, output, ref, err):
336 if line.startswith(b'+++') or line.startswith(b'---'):
336 if line.startswith(b'+++') or line.startswith(b'---'):
337 line = line.replace(b'\\', b'/')
337 line = line.replace(b'\\', b'/')
338 if line.endswith(b' \n'):
338 if line.endswith(b' \n'):
339 line = line[:-2] + b'\n'
339 line = line[:-2] + b'\n'
340 lines.append(line)
340 lines.append(line)
341 if not servefail and line.startswith(
341 if not servefail and line.startswith(
342 b'+ abort: child process failed to start'):
342 b'+ abort: child process failed to start'):
343 servefail = True
343 servefail = True
344
344
345 return servefail, lines
345 return servefail, lines
346
346
347 verbose = False
347 verbose = False
348 def vlog(*msg):
348 def vlog(*msg):
349 """Log only when in verbose mode."""
349 """Log only when in verbose mode."""
350 if verbose is False:
350 if verbose is False:
351 return
351 return
352
352
353 return log(*msg)
353 return log(*msg)
354
354
355 # Bytes that break XML even in a CDATA block: control characters 0-31
355 # Bytes that break XML even in a CDATA block: control characters 0-31
356 # sans \t, \n and \r
356 # sans \t, \n and \r
357 CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")
357 CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")
358
358
359 def cdatasafe(data):
359 def cdatasafe(data):
360 """Make a string safe to include in a CDATA block.
360 """Make a string safe to include in a CDATA block.
361
361
362 Certain control characters are illegal in a CDATA block, and
362 Certain control characters are illegal in a CDATA block, and
363 there's no way to include a ]]> in a CDATA either. This function
363 there's no way to include a ]]> in a CDATA either. This function
364 replaces illegal bytes with ? and adds a space between the ]] so
364 replaces illegal bytes with ? and adds a space between the ]] so
365 that it won't break the CDATA block.
365 that it won't break the CDATA block.
366 """
366 """
367 return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')
367 return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')
368
368
369 def log(*msg):
369 def log(*msg):
370 """Log something to stdout.
370 """Log something to stdout.
371
371
372 Arguments are strings to print.
372 Arguments are strings to print.
373 """
373 """
374 with iolock:
374 with iolock:
375 if verbose:
375 if verbose:
376 print(verbose, end=' ')
376 print(verbose, end=' ')
377 for m in msg:
377 for m in msg:
378 print(m, end=' ')
378 print(m, end=' ')
379 print()
379 print()
380 sys.stdout.flush()
380 sys.stdout.flush()
381
381
382 def terminate(proc):
382 def terminate(proc):
383 """Terminate subprocess (with fallback for Python versions < 2.6)"""
383 """Terminate subprocess (with fallback for Python versions < 2.6)"""
384 vlog('# Terminating process %d' % proc.pid)
384 vlog('# Terminating process %d' % proc.pid)
385 try:
385 try:
386 getattr(proc, 'terminate', lambda : os.kill(proc.pid, signal.SIGTERM))()
386 getattr(proc, 'terminate', lambda : os.kill(proc.pid, signal.SIGTERM))()
387 except OSError:
387 except OSError:
388 pass
388 pass
389
389
390 def killdaemons(pidfile):
390 def killdaemons(pidfile):
391 return killmod.killdaemons(pidfile, tryhard=False, remove=True,
391 return killmod.killdaemons(pidfile, tryhard=False, remove=True,
392 logfn=vlog)
392 logfn=vlog)
393
393
394 class Test(unittest.TestCase):
394 class Test(unittest.TestCase):
395 """Encapsulates a single, runnable test.
395 """Encapsulates a single, runnable test.
396
396
397 While this class conforms to the unittest.TestCase API, it differs in that
397 While this class conforms to the unittest.TestCase API, it differs in that
398 instances need to be instantiated manually. (Typically, unittest.TestCase
398 instances need to be instantiated manually. (Typically, unittest.TestCase
399 classes are instantiated automatically by scanning modules.)
399 classes are instantiated automatically by scanning modules.)
400 """
400 """
401
401
402 # Status code reserved for skipped tests (used by hghave).
402 # Status code reserved for skipped tests (used by hghave).
403 SKIPPED_STATUS = 80
403 SKIPPED_STATUS = 80
404
404
405 def __init__(self, path, tmpdir, keeptmpdir=False,
405 def __init__(self, path, tmpdir, keeptmpdir=False,
406 debug=False,
406 debug=False,
407 timeout=defaults['timeout'],
407 timeout=defaults['timeout'],
408 startport=defaults['port'], extraconfigopts=None,
408 startport=defaults['port'], extraconfigopts=None,
409 py3kwarnings=False, shell=None):
409 py3kwarnings=False, shell=None):
410 """Create a test from parameters.
410 """Create a test from parameters.
411
411
412 path is the full path to the file defining the test.
412 path is the full path to the file defining the test.
413
413
414 tmpdir is the main temporary directory to use for this test.
414 tmpdir is the main temporary directory to use for this test.
415
415
416 keeptmpdir determines whether to keep the test's temporary directory
416 keeptmpdir determines whether to keep the test's temporary directory
417 after execution. It defaults to removal (False).
417 after execution. It defaults to removal (False).
418
418
419 debug mode will make the test execute verbosely, with unfiltered
419 debug mode will make the test execute verbosely, with unfiltered
420 output.
420 output.
421
421
422 timeout controls the maximum run time of the test. It is ignored when
422 timeout controls the maximum run time of the test. It is ignored when
423 debug is True.
423 debug is True.
424
424
425 startport controls the starting port number to use for this test. Each
425 startport controls the starting port number to use for this test. Each
426 test will reserve 3 port numbers for execution. It is the caller's
426 test will reserve 3 port numbers for execution. It is the caller's
427 responsibility to allocate a non-overlapping port range to Test
427 responsibility to allocate a non-overlapping port range to Test
428 instances.
428 instances.
429
429
430 extraconfigopts is an iterable of extra hgrc config options. Values
430 extraconfigopts is an iterable of extra hgrc config options. Values
431 must have the form "key=value" (something understood by hgrc). Values
431 must have the form "key=value" (something understood by hgrc). Values
432 of the form "foo.key=value" will result in "[foo] key=value".
432 of the form "foo.key=value" will result in "[foo] key=value".
433
433
434 py3kwarnings enables Py3k warnings.
434 py3kwarnings enables Py3k warnings.
435
435
436 shell is the shell to execute tests in.
436 shell is the shell to execute tests in.
437 """
437 """
438 self.path = path
438 self.path = path
439 self.bname = os.path.basename(path)
439 self.bname = os.path.basename(path)
440 self.name = self.bname.decode('utf-8')
440 self.name = self.bname.decode('utf-8')
441 self._testdir = os.path.dirname(path)
441 self._testdir = os.path.dirname(path)
442 self.errpath = os.path.join(self._testdir, b'%s.err' % self.bname)
442 self.errpath = os.path.join(self._testdir, b'%s.err' % self.bname)
443
443
444 self._threadtmp = tmpdir
444 self._threadtmp = tmpdir
445 self._keeptmpdir = keeptmpdir
445 self._keeptmpdir = keeptmpdir
446 self._debug = debug
446 self._debug = debug
447 self._timeout = timeout
447 self._timeout = timeout
448 self._startport = startport
448 self._startport = startport
449 self._extraconfigopts = extraconfigopts or []
449 self._extraconfigopts = extraconfigopts or []
450 self._py3kwarnings = py3kwarnings
450 self._py3kwarnings = py3kwarnings
451 self._shell = shell.encode('utf-8')
451 self._shell = shell.encode('utf-8')
452
452
453 self._aborted = False
453 self._aborted = False
454 self._daemonpids = []
454 self._daemonpids = []
455 self._finished = None
455 self._finished = None
456 self._ret = None
456 self._ret = None
457 self._out = None
457 self._out = None
458 self._skipped = None
458 self._skipped = None
459 self._testtmp = None
459 self._testtmp = None
460
460
461 # If we're not in --debug mode and reference output file exists,
461 # If we're not in --debug mode and reference output file exists,
462 # check test output against it.
462 # check test output against it.
463 if debug:
463 if debug:
464 self._refout = None # to match "out is None"
464 self._refout = None # to match "out is None"
465 elif os.path.exists(self.refpath):
465 elif os.path.exists(self.refpath):
466 f = open(self.refpath, 'rb')
466 f = open(self.refpath, 'rb')
467 self._refout = f.read().splitlines(True)
467 self._refout = f.read().splitlines(True)
468 f.close()
468 f.close()
469 else:
469 else:
470 self._refout = []
470 self._refout = []
471
471
472 # needed to get base class __repr__ running
472 # needed to get base class __repr__ running
473 @property
473 @property
474 def _testMethodName(self):
474 def _testMethodName(self):
475 return self.name
475 return self.name
476
476
477 def __str__(self):
477 def __str__(self):
478 return self.name
478 return self.name
479
479
480 def shortDescription(self):
480 def shortDescription(self):
481 return self.name
481 return self.name
482
482
483 def setUp(self):
483 def setUp(self):
484 """Tasks to perform before run()."""
484 """Tasks to perform before run()."""
485 self._finished = False
485 self._finished = False
486 self._ret = None
486 self._ret = None
487 self._out = None
487 self._out = None
488 self._skipped = None
488 self._skipped = None
489
489
490 try:
490 try:
491 os.mkdir(self._threadtmp)
491 os.mkdir(self._threadtmp)
492 except OSError as e:
492 except OSError as e:
493 if e.errno != errno.EEXIST:
493 if e.errno != errno.EEXIST:
494 raise
494 raise
495
495
496 self._testtmp = os.path.join(self._threadtmp,
496 self._testtmp = os.path.join(self._threadtmp,
497 os.path.basename(self.path))
497 os.path.basename(self.path))
498 os.mkdir(self._testtmp)
498 os.mkdir(self._testtmp)
499
499
500 # Remove any previous output files.
500 # Remove any previous output files.
501 if os.path.exists(self.errpath):
501 if os.path.exists(self.errpath):
502 try:
502 try:
503 os.remove(self.errpath)
503 os.remove(self.errpath)
504 except OSError as e:
504 except OSError as e:
505 # We might have raced another test to clean up a .err
505 # We might have raced another test to clean up a .err
506 # file, so ignore ENOENT when removing a previous .err
506 # file, so ignore ENOENT when removing a previous .err
507 # file.
507 # file.
508 if e.errno != errno.ENOENT:
508 if e.errno != errno.ENOENT:
509 raise
509 raise
510
510
511 def run(self, result):
511 def run(self, result):
512 """Run this test and report results against a TestResult instance."""
512 """Run this test and report results against a TestResult instance."""
513 # This function is extremely similar to unittest.TestCase.run(). Once
513 # This function is extremely similar to unittest.TestCase.run(). Once
514 # we require Python 2.7 (or at least its version of unittest), this
514 # we require Python 2.7 (or at least its version of unittest), this
515 # function can largely go away.
515 # function can largely go away.
516 self._result = result
516 self._result = result
517 result.startTest(self)
517 result.startTest(self)
518 try:
518 try:
519 try:
519 try:
520 self.setUp()
520 self.setUp()
521 except (KeyboardInterrupt, SystemExit):
521 except (KeyboardInterrupt, SystemExit):
522 self._aborted = True
522 self._aborted = True
523 raise
523 raise
524 except Exception:
524 except Exception:
525 result.addError(self, sys.exc_info())
525 result.addError(self, sys.exc_info())
526 return
526 return
527
527
528 success = False
528 success = False
529 try:
529 try:
530 self.runTest()
530 self.runTest()
531 except KeyboardInterrupt:
531 except KeyboardInterrupt:
532 self._aborted = True
532 self._aborted = True
533 raise
533 raise
534 except SkipTest as e:
534 except SkipTest as e:
535 result.addSkip(self, str(e))
535 result.addSkip(self, str(e))
536 # The base class will have already counted this as a
536 # The base class will have already counted this as a
537 # test we "ran", but we want to exclude skipped tests
537 # test we "ran", but we want to exclude skipped tests
538 # from those we count towards those run.
538 # from those we count towards those run.
539 result.testsRun -= 1
539 result.testsRun -= 1
540 except IgnoreTest as e:
540 except IgnoreTest as e:
541 result.addIgnore(self, str(e))
541 result.addIgnore(self, str(e))
542 # As with skips, ignores also should be excluded from
542 # As with skips, ignores also should be excluded from
543 # the number of tests executed.
543 # the number of tests executed.
544 result.testsRun -= 1
544 result.testsRun -= 1
545 except WarnTest as e:
545 except WarnTest as e:
546 result.addWarn(self, str(e))
546 result.addWarn(self, str(e))
547 except self.failureException as e:
547 except self.failureException as e:
548 # This differs from unittest in that we don't capture
548 # This differs from unittest in that we don't capture
549 # the stack trace. This is for historical reasons and
549 # the stack trace. This is for historical reasons and
550 # this decision could be revisited in the future,
550 # this decision could be revisited in the future,
551 # especially for PythonTest instances.
551 # especially for PythonTest instances.
552 if result.addFailure(self, str(e)):
552 if result.addFailure(self, str(e)):
553 success = True
553 success = True
554 except Exception:
554 except Exception:
555 result.addError(self, sys.exc_info())
555 result.addError(self, sys.exc_info())
556 else:
556 else:
557 success = True
557 success = True
558
558
559 try:
559 try:
560 self.tearDown()
560 self.tearDown()
561 except (KeyboardInterrupt, SystemExit):
561 except (KeyboardInterrupt, SystemExit):
562 self._aborted = True
562 self._aborted = True
563 raise
563 raise
564 except Exception:
564 except Exception:
565 result.addError(self, sys.exc_info())
565 result.addError(self, sys.exc_info())
566 success = False
566 success = False
567
567
568 if success:
568 if success:
569 result.addSuccess(self)
569 result.addSuccess(self)
570 finally:
570 finally:
571 result.stopTest(self, interrupted=self._aborted)
571 result.stopTest(self, interrupted=self._aborted)
572
572
573 def runTest(self):
573 def runTest(self):
574 """Run this test instance.
574 """Run this test instance.
575
575
576 This will return a tuple describing the result of the test.
576 This will return a tuple describing the result of the test.
577 """
577 """
578 env = self._getenv()
578 env = self._getenv()
579 self._daemonpids.append(env['DAEMON_PIDS'])
579 self._daemonpids.append(env['DAEMON_PIDS'])
580 self._createhgrc(env['HGRCPATH'])
580 self._createhgrc(env['HGRCPATH'])
581
581
582 vlog('# Test', self.name)
582 vlog('# Test', self.name)
583
583
584 ret, out = self._run(env)
584 ret, out = self._run(env)
585 self._finished = True
585 self._finished = True
586 self._ret = ret
586 self._ret = ret
587 self._out = out
587 self._out = out
588
588
589 def describe(ret):
589 def describe(ret):
590 if ret < 0:
590 if ret < 0:
591 return 'killed by signal: %d' % -ret
591 return 'killed by signal: %d' % -ret
592 return 'returned error code %d' % ret
592 return 'returned error code %d' % ret
593
593
594 self._skipped = False
594 self._skipped = False
595
595
596 if ret == self.SKIPPED_STATUS:
596 if ret == self.SKIPPED_STATUS:
597 if out is None: # Debug mode, nothing to parse.
597 if out is None: # Debug mode, nothing to parse.
598 missing = ['unknown']
598 missing = ['unknown']
599 failed = None
599 failed = None
600 else:
600 else:
601 missing, failed = TTest.parsehghaveoutput(out)
601 missing, failed = TTest.parsehghaveoutput(out)
602
602
603 if not missing:
603 if not missing:
604 missing = ['skipped']
604 missing = ['skipped']
605
605
606 if failed:
606 if failed:
607 self.fail('hg have failed checking for %s' % failed[-1])
607 self.fail('hg have failed checking for %s' % failed[-1])
608 else:
608 else:
609 self._skipped = True
609 self._skipped = True
610 raise SkipTest(missing[-1])
610 raise SkipTest(missing[-1])
611 elif ret == 'timeout':
611 elif ret == 'timeout':
612 self.fail('timed out')
612 self.fail('timed out')
613 elif ret is False:
613 elif ret is False:
614 raise WarnTest('no result code from test')
614 raise WarnTest('no result code from test')
615 elif out != self._refout:
615 elif out != self._refout:
616 # Diff generation may rely on written .err file.
616 # Diff generation may rely on written .err file.
617 if (ret != 0 or out != self._refout) and not self._skipped \
617 if (ret != 0 or out != self._refout) and not self._skipped \
618 and not self._debug:
618 and not self._debug:
619 f = open(self.errpath, 'wb')
619 f = open(self.errpath, 'wb')
620 for line in out:
620 for line in out:
621 f.write(line)
621 f.write(line)
622 f.close()
622 f.close()
623
623
624 # The result object handles diff calculation for us.
624 # The result object handles diff calculation for us.
625 if self._result.addOutputMismatch(self, ret, out, self._refout):
625 if self._result.addOutputMismatch(self, ret, out, self._refout):
626 # change was accepted, skip failing
626 # change was accepted, skip failing
627 return
627 return
628
628
629 if ret:
629 if ret:
630 msg = 'output changed and ' + describe(ret)
630 msg = 'output changed and ' + describe(ret)
631 else:
631 else:
632 msg = 'output changed'
632 msg = 'output changed'
633
633
634 self.fail(msg)
634 self.fail(msg)
635 elif ret:
635 elif ret:
636 self.fail(describe(ret))
636 self.fail(describe(ret))
637
637
638 def tearDown(self):
638 def tearDown(self):
639 """Tasks to perform after run()."""
639 """Tasks to perform after run()."""
640 for entry in self._daemonpids:
640 for entry in self._daemonpids:
641 killdaemons(entry)
641 killdaemons(entry)
642 self._daemonpids = []
642 self._daemonpids = []
643
643
644 if not self._keeptmpdir:
644 if not self._keeptmpdir:
645 shutil.rmtree(self._testtmp, True)
645 shutil.rmtree(self._testtmp, True)
646 shutil.rmtree(self._threadtmp, True)
646 shutil.rmtree(self._threadtmp, True)
647
647
648 if (self._ret != 0 or self._out != self._refout) and not self._skipped \
648 if (self._ret != 0 or self._out != self._refout) and not self._skipped \
649 and not self._debug and self._out:
649 and not self._debug and self._out:
650 f = open(self.errpath, 'wb')
650 f = open(self.errpath, 'wb')
651 for line in self._out:
651 for line in self._out:
652 f.write(line)
652 f.write(line)
653 f.close()
653 f.close()
654
654
655 vlog("# Ret was:", self._ret, '(%s)' % self.name)
655 vlog("# Ret was:", self._ret, '(%s)' % self.name)
656
656
657 def _run(self, env):
657 def _run(self, env):
658 # This should be implemented in child classes to run tests.
658 # This should be implemented in child classes to run tests.
659 raise SkipTest('unknown test type')
659 raise SkipTest('unknown test type')
660
660
661 def abort(self):
661 def abort(self):
662 """Terminate execution of this test."""
662 """Terminate execution of this test."""
663 self._aborted = True
663 self._aborted = True
664
664
665 def _getreplacements(self):
665 def _getreplacements(self):
666 """Obtain a mapping of text replacements to apply to test output.
666 """Obtain a mapping of text replacements to apply to test output.
667
667
668 Test output needs to be normalized so it can be compared to expected
668 Test output needs to be normalized so it can be compared to expected
669 output. This function defines how some of that normalization will
669 output. This function defines how some of that normalization will
670 occur.
670 occur.
671 """
671 """
672 r = [
672 r = [
673 (br':%d\b' % self._startport, b':$HGPORT'),
673 (br':%d\b' % self._startport, b':$HGPORT'),
674 (br':%d\b' % (self._startport + 1), b':$HGPORT1'),
674 (br':%d\b' % (self._startport + 1), b':$HGPORT1'),
675 (br':%d\b' % (self._startport + 2), b':$HGPORT2'),
675 (br':%d\b' % (self._startport + 2), b':$HGPORT2'),
676 (br'(?m)^(saved backup bundle to .*\.hg)( \(glob\))?$',
676 (br'(?m)^(saved backup bundle to .*\.hg)( \(glob\))?$',
677 br'\1 (glob)'),
677 br'\1 (glob)'),
678 ]
678 ]
679
679
680 if os.name == 'nt':
680 if os.name == 'nt':
681 r.append(
681 r.append(
682 (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or
682 (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or
683 c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c
683 c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c
684 for c in self._testtmp), b'$TESTTMP'))
684 for c in self._testtmp), b'$TESTTMP'))
685 else:
685 else:
686 r.append((re.escape(self._testtmp), b'$TESTTMP'))
686 r.append((re.escape(self._testtmp), b'$TESTTMP'))
687
687
688 return r
688 return r
689
689
690 def _getenv(self):
690 def _getenv(self):
691 """Obtain environment variables to use during test execution."""
691 """Obtain environment variables to use during test execution."""
692 env = os.environ.copy()
692 env = os.environ.copy()
693 env['TESTTMP'] = self._testtmp
693 env['TESTTMP'] = self._testtmp
694 env['HOME'] = self._testtmp
694 env['HOME'] = self._testtmp
695 env["HGPORT"] = str(self._startport)
695 env["HGPORT"] = str(self._startport)
696 env["HGPORT1"] = str(self._startport + 1)
696 env["HGPORT1"] = str(self._startport + 1)
697 env["HGPORT2"] = str(self._startport + 2)
697 env["HGPORT2"] = str(self._startport + 2)
698 env["HGRCPATH"] = os.path.join(self._threadtmp, b'.hgrc')
698 env["HGRCPATH"] = os.path.join(self._threadtmp, b'.hgrc')
699 env["DAEMON_PIDS"] = os.path.join(self._threadtmp, b'daemon.pids')
699 env["DAEMON_PIDS"] = os.path.join(self._threadtmp, b'daemon.pids')
700 env["HGEDITOR"] = ('"' + sys.executable + '"'
700 env["HGEDITOR"] = ('"' + sys.executable + '"'
701 + ' -c "import sys; sys.exit(0)"')
701 + ' -c "import sys; sys.exit(0)"')
702 env["HGMERGE"] = "internal:merge"
702 env["HGMERGE"] = "internal:merge"
703 env["HGUSER"] = "test"
703 env["HGUSER"] = "test"
704 env["HGENCODING"] = "ascii"
704 env["HGENCODING"] = "ascii"
705 env["HGENCODINGMODE"] = "strict"
705 env["HGENCODINGMODE"] = "strict"
706
706
707 # Reset some environment variables to well-known values so that
707 # Reset some environment variables to well-known values so that
708 # the tests produce repeatable output.
708 # the tests produce repeatable output.
709 env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'
709 env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'
710 env['TZ'] = 'GMT'
710 env['TZ'] = 'GMT'
711 env["EMAIL"] = "Foo Bar <foo.bar@example.com>"
711 env["EMAIL"] = "Foo Bar <foo.bar@example.com>"
712 env['COLUMNS'] = '80'
712 env['COLUMNS'] = '80'
713 env['TERM'] = 'xterm'
713 env['TERM'] = 'xterm'
714
714
715 for k in ('HG HGPROF CDPATH GREP_OPTIONS http_proxy no_proxy ' +
715 for k in ('HG HGPROF CDPATH GREP_OPTIONS http_proxy no_proxy ' +
716 'NO_PROXY').split():
716 'NO_PROXY').split():
717 if k in env:
717 if k in env:
718 del env[k]
718 del env[k]
719
719
720 # unset env related to hooks
720 # unset env related to hooks
721 for k in env.keys():
721 for k in env.keys():
722 if k.startswith('HG_'):
722 if k.startswith('HG_'):
723 del env[k]
723 del env[k]
724
724
725 return env
725 return env
726
726
727 def _createhgrc(self, path):
727 def _createhgrc(self, path):
728 """Create an hgrc file for this test."""
728 """Create an hgrc file for this test."""
729 hgrc = open(path, 'wb')
729 hgrc = open(path, 'wb')
730 hgrc.write(b'[ui]\n')
730 hgrc.write(b'[ui]\n')
731 hgrc.write(b'slash = True\n')
731 hgrc.write(b'slash = True\n')
732 hgrc.write(b'interactive = False\n')
732 hgrc.write(b'interactive = False\n')
733 hgrc.write(b'mergemarkers = detailed\n')
733 hgrc.write(b'mergemarkers = detailed\n')
734 hgrc.write(b'promptecho = True\n')
734 hgrc.write(b'promptecho = True\n')
735 hgrc.write(b'[defaults]\n')
735 hgrc.write(b'[defaults]\n')
736 hgrc.write(b'backout = -d "0 0"\n')
736 hgrc.write(b'backout = -d "0 0"\n')
737 hgrc.write(b'commit = -d "0 0"\n')
737 hgrc.write(b'commit = -d "0 0"\n')
738 hgrc.write(b'shelve = --date "0 0"\n')
738 hgrc.write(b'shelve = --date "0 0"\n')
739 hgrc.write(b'tag = -d "0 0"\n')
739 hgrc.write(b'tag = -d "0 0"\n')
740 hgrc.write(b'[devel]\n')
740 hgrc.write(b'[devel]\n')
741 hgrc.write(b'all = true\n')
741 hgrc.write(b'all = true\n')
742 hgrc.write(b'[largefiles]\n')
742 hgrc.write(b'[largefiles]\n')
743 hgrc.write(b'usercache = %s\n' %
743 hgrc.write(b'usercache = %s\n' %
744 (os.path.join(self._testtmp, b'.cache/largefiles')))
744 (os.path.join(self._testtmp, b'.cache/largefiles')))
745
745
746 for opt in self._extraconfigopts:
746 for opt in self._extraconfigopts:
747 section, key = opt.split('.', 1)
747 section, key = opt.split('.', 1)
748 assert '=' in key, ('extra config opt %s must '
748 assert '=' in key, ('extra config opt %s must '
749 'have an = for assignment' % opt)
749 'have an = for assignment' % opt)
750 hgrc.write(b'[%s]\n%s\n' % (section, key))
750 hgrc.write(b'[%s]\n%s\n' % (section, key))
751 hgrc.close()
751 hgrc.close()
752
752
753 def fail(self, msg):
753 def fail(self, msg):
754 # unittest differentiates between errored and failed.
754 # unittest differentiates between errored and failed.
755 # Failed is denoted by AssertionError (by default at least).
755 # Failed is denoted by AssertionError (by default at least).
756 raise AssertionError(msg)
756 raise AssertionError(msg)
757
757
758 def _runcommand(self, cmd, env, normalizenewlines=False):
758 def _runcommand(self, cmd, env, normalizenewlines=False):
759 """Run command in a sub-process, capturing the output (stdout and
759 """Run command in a sub-process, capturing the output (stdout and
760 stderr).
760 stderr).
761
761
762 Return a tuple (exitcode, output). output is None in debug mode.
762 Return a tuple (exitcode, output). output is None in debug mode.
763 """
763 """
764 if self._debug:
764 if self._debug:
765 proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp,
765 proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp,
766 env=env)
766 env=env)
767 ret = proc.wait()
767 ret = proc.wait()
768 return (ret, None)
768 return (ret, None)
769
769
770 proc = Popen4(cmd, self._testtmp, self._timeout, env)
770 proc = Popen4(cmd, self._testtmp, self._timeout, env)
771 def cleanup():
771 def cleanup():
772 terminate(proc)
772 terminate(proc)
773 ret = proc.wait()
773 ret = proc.wait()
774 if ret == 0:
774 if ret == 0:
775 ret = signal.SIGTERM << 8
775 ret = signal.SIGTERM << 8
776 killdaemons(env['DAEMON_PIDS'])
776 killdaemons(env['DAEMON_PIDS'])
777 return ret
777 return ret
778
778
779 output = ''
779 output = ''
780 proc.tochild.close()
780 proc.tochild.close()
781
781
782 try:
782 try:
783 output = proc.fromchild.read()
783 output = proc.fromchild.read()
784 except KeyboardInterrupt:
784 except KeyboardInterrupt:
785 vlog('# Handling keyboard interrupt')
785 vlog('# Handling keyboard interrupt')
786 cleanup()
786 cleanup()
787 raise
787 raise
788
788
789 ret = proc.wait()
789 ret = proc.wait()
790 if wifexited(ret):
790 if wifexited(ret):
791 ret = os.WEXITSTATUS(ret)
791 ret = os.WEXITSTATUS(ret)
792
792
793 if proc.timeout:
793 if proc.timeout:
794 ret = 'timeout'
794 ret = 'timeout'
795
795
796 if ret:
796 if ret:
797 killdaemons(env['DAEMON_PIDS'])
797 killdaemons(env['DAEMON_PIDS'])
798
798
799 for s, r in self._getreplacements():
799 for s, r in self._getreplacements():
800 output = re.sub(s, r, output)
800 output = re.sub(s, r, output)
801
801
802 if normalizenewlines:
802 if normalizenewlines:
803 output = output.replace('\r\n', '\n')
803 output = output.replace('\r\n', '\n')
804
804
805 return ret, output.splitlines(True)
805 return ret, output.splitlines(True)
806
806
807 class PythonTest(Test):
807 class PythonTest(Test):
808 """A Python-based test."""
808 """A Python-based test."""
809
809
810 @property
810 @property
811 def refpath(self):
811 def refpath(self):
812 return os.path.join(self._testdir, '%s.out' % self.name)
812 return os.path.join(self._testdir, '%s.out' % self.name)
813
813
814 def _run(self, env):
814 def _run(self, env):
815 py3kswitch = self._py3kwarnings and ' -3' or ''
815 py3kswitch = self._py3kwarnings and ' -3' or ''
816 cmd = '%s%s "%s"' % (PYTHON, py3kswitch, self.path)
816 cmd = '%s%s "%s"' % (PYTHON, py3kswitch, self.path)
817 vlog("# Running", cmd)
817 vlog("# Running", cmd)
818 normalizenewlines = os.name == 'nt'
818 normalizenewlines = os.name == 'nt'
819 result = self._runcommand(cmd, env,
819 result = self._runcommand(cmd, env,
820 normalizenewlines=normalizenewlines)
820 normalizenewlines=normalizenewlines)
821 if self._aborted:
821 if self._aborted:
822 raise KeyboardInterrupt()
822 raise KeyboardInterrupt()
823
823
824 return result
824 return result
825
825
826 # This script may want to drop globs from lines matching these patterns on
826 # This script may want to drop globs from lines matching these patterns on
827 # Windows, but check-code.py wants a glob on these lines unconditionally. Don't
827 # Windows, but check-code.py wants a glob on these lines unconditionally. Don't
828 # warn if that is the case for anything matching these lines.
828 # warn if that is the case for anything matching these lines.
829 checkcodeglobpats = [
829 checkcodeglobpats = [
830 re.compile(r'^pushing to \$TESTTMP/.*[^)]$'),
830 re.compile(r'^pushing to \$TESTTMP/.*[^)]$'),
831 re.compile(r'^moving \S+/.*[^)]$'),
831 re.compile(r'^moving \S+/.*[^)]$'),
832 re.compile(r'^pulling from \$TESTTMP/.*[^)]$')
832 re.compile(r'^pulling from \$TESTTMP/.*[^)]$')
833 ]
833 ]
834
834
835 bchr = chr
835 bchr = chr
836 if sys.version_info[0] == 3:
836 if sys.version_info[0] == 3:
837 bchr = lambda x: bytes([x])
837 bchr = lambda x: bytes([x])
838
838
839 class TTest(Test):
839 class TTest(Test):
840 """A "t test" is a test backed by a .t file."""
840 """A "t test" is a test backed by a .t file."""
841
841
842 SKIPPED_PREFIX = 'skipped: '
842 SKIPPED_PREFIX = 'skipped: '
843 FAILED_PREFIX = 'hghave check failed: '
843 FAILED_PREFIX = 'hghave check failed: '
844 NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
844 NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
845
845
846 ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
846 ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
847 ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256))
847 ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256))
848 ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
848 ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
849
849
850 @property
850 @property
851 def refpath(self):
851 def refpath(self):
852 return os.path.join(self._testdir, self.bname)
852 return os.path.join(self._testdir, self.bname)
853
853
854 def _run(self, env):
854 def _run(self, env):
855 f = open(self.path, 'rb')
855 f = open(self.path, 'rb')
856 lines = f.readlines()
856 lines = f.readlines()
857 f.close()
857 f.close()
858
858
859 salt, script, after, expected = self._parsetest(lines)
859 salt, script, after, expected = self._parsetest(lines)
860
860
861 # Write out the generated script.
861 # Write out the generated script.
862 fname = b'%s.sh' % self._testtmp
862 fname = b'%s.sh' % self._testtmp
863 f = open(fname, 'wb')
863 f = open(fname, 'wb')
864 for l in script:
864 for l in script:
865 f.write(l)
865 f.write(l)
866 f.close()
866 f.close()
867
867
868 cmd = b'%s "%s"' % (self._shell, fname)
868 cmd = b'%s "%s"' % (self._shell, fname)
869 vlog("# Running", cmd)
869 vlog("# Running", cmd)
870
870
871 exitcode, output = self._runcommand(cmd, env)
871 exitcode, output = self._runcommand(cmd, env)
872
872
873 if self._aborted:
873 if self._aborted:
874 raise KeyboardInterrupt()
874 raise KeyboardInterrupt()
875
875
876 # Do not merge output if skipped. Return hghave message instead.
876 # Do not merge output if skipped. Return hghave message instead.
877 # Similarly, with --debug, output is None.
877 # Similarly, with --debug, output is None.
878 if exitcode == self.SKIPPED_STATUS or output is None:
878 if exitcode == self.SKIPPED_STATUS or output is None:
879 return exitcode, output
879 return exitcode, output
880
880
881 return self._processoutput(exitcode, output, salt, after, expected)
881 return self._processoutput(exitcode, output, salt, after, expected)
882
882
883 def _hghave(self, reqs):
883 def _hghave(self, reqs):
884 # TODO do something smarter when all other uses of hghave are gone.
884 # TODO do something smarter when all other uses of hghave are gone.
885 tdir = self._testdir.replace(b'\\', b'/')
885 tdir = self._testdir.replace(b'\\', b'/')
886 proc = Popen4(b'%s -c "%s/hghave %s"' %
886 proc = Popen4(b'%s -c "%s/hghave %s"' %
887 (self._shell, tdir, b' '.join(reqs)),
887 (self._shell, tdir, b' '.join(reqs)),
888 self._testtmp, 0, self._getenv())
888 self._testtmp, 0, self._getenv())
889 stdout, stderr = proc.communicate()
889 stdout, stderr = proc.communicate()
890 ret = proc.wait()
890 ret = proc.wait()
891 if wifexited(ret):
891 if wifexited(ret):
892 ret = os.WEXITSTATUS(ret)
892 ret = os.WEXITSTATUS(ret)
893 if ret == 2:
893 if ret == 2:
894 print(stdout)
894 print(stdout)
895 sys.exit(1)
895 sys.exit(1)
896
896
897 return ret == 0
897 return ret == 0
898
898
899 def _parsetest(self, lines):
899 def _parsetest(self, lines):
900 # We generate a shell script which outputs unique markers to line
900 # We generate a shell script which outputs unique markers to line
901 # up script results with our source. These markers include input
901 # up script results with our source. These markers include input
902 # line number and the last return code.
902 # line number and the last return code.
903 salt = b"SALT%d" % time.time()
903 salt = b"SALT%d" % time.time()
904 def addsalt(line, inpython):
904 def addsalt(line, inpython):
905 if inpython:
905 if inpython:
906 script.append(b'%s %d 0\n' % (salt, line))
906 script.append(b'%s %d 0\n' % (salt, line))
907 else:
907 else:
908 script.append(b'echo %s %d $?\n' % (salt, line))
908 script.append(b'echo %s %d $?\n' % (salt, line))
909
909
910 script = []
910 script = []
911
911
912 # After we run the shell script, we re-unify the script output
912 # After we run the shell script, we re-unify the script output
913 # with non-active parts of the source, with synchronization by our
913 # with non-active parts of the source, with synchronization by our
914 # SALT line number markers. The after table contains the non-active
914 # SALT line number markers. The after table contains the non-active
915 # components, ordered by line number.
915 # components, ordered by line number.
916 after = {}
916 after = {}
917
917
918 # Expected shell script output.
918 # Expected shell script output.
919 expected = {}
919 expected = {}
920
920
921 pos = prepos = -1
921 pos = prepos = -1
922
922
923 # True or False when in a true or false conditional section
923 # True or False when in a true or false conditional section
924 skipping = None
924 skipping = None
925
925
926 # We keep track of whether or not we're in a Python block so we
926 # We keep track of whether or not we're in a Python block so we
927 # can generate the surrounding doctest magic.
927 # can generate the surrounding doctest magic.
928 inpython = False
928 inpython = False
929
929
930 if self._debug:
930 if self._debug:
931 script.append('set -x\n')
931 script.append('set -x\n')
932 if os.getenv('MSYSTEM'):
932 if os.getenv('MSYSTEM'):
933 script.append('alias pwd="pwd -W"\n')
933 script.append('alias pwd="pwd -W"\n')
934
934
935 for n, l in enumerate(lines):
935 for n, l in enumerate(lines):
936 if not l.endswith(b'\n'):
936 if not l.endswith(b'\n'):
937 l += b'\n'
937 l += b'\n'
938 if l.startswith(b'#require'):
938 if l.startswith(b'#require'):
939 lsplit = l.split()
939 lsplit = l.split()
940 if len(lsplit) < 2 or lsplit[0] != b'#require':
940 if len(lsplit) < 2 or lsplit[0] != b'#require':
941 after.setdefault(pos, []).append(' !!! invalid #require\n')
941 after.setdefault(pos, []).append(' !!! invalid #require\n')
942 if not self._hghave(lsplit[1:]):
942 if not self._hghave(lsplit[1:]):
943 script = ["exit 80\n"]
943 script = ["exit 80\n"]
944 break
944 break
945 after.setdefault(pos, []).append(l)
945 after.setdefault(pos, []).append(l)
946 elif l.startswith(b'#if'):
946 elif l.startswith(b'#if'):
947 lsplit = l.split()
947 lsplit = l.split()
948 if len(lsplit) < 2 or lsplit[0] != b'#if':
948 if len(lsplit) < 2 or lsplit[0] != b'#if':
949 after.setdefault(pos, []).append(' !!! invalid #if\n')
949 after.setdefault(pos, []).append(' !!! invalid #if\n')
950 if skipping is not None:
950 if skipping is not None:
951 after.setdefault(pos, []).append(' !!! nested #if\n')
951 after.setdefault(pos, []).append(' !!! nested #if\n')
952 skipping = not self._hghave(lsplit[1:])
952 skipping = not self._hghave(lsplit[1:])
953 after.setdefault(pos, []).append(l)
953 after.setdefault(pos, []).append(l)
954 elif l.startswith(b'#else'):
954 elif l.startswith(b'#else'):
955 if skipping is None:
955 if skipping is None:
956 after.setdefault(pos, []).append(' !!! missing #if\n')
956 after.setdefault(pos, []).append(' !!! missing #if\n')
957 skipping = not skipping
957 skipping = not skipping
958 after.setdefault(pos, []).append(l)
958 after.setdefault(pos, []).append(l)
959 elif l.startswith(b'#endif'):
959 elif l.startswith(b'#endif'):
960 if skipping is None:
960 if skipping is None:
961 after.setdefault(pos, []).append(' !!! missing #if\n')
961 after.setdefault(pos, []).append(' !!! missing #if\n')
962 skipping = None
962 skipping = None
963 after.setdefault(pos, []).append(l)
963 after.setdefault(pos, []).append(l)
964 elif skipping:
964 elif skipping:
965 after.setdefault(pos, []).append(l)
965 after.setdefault(pos, []).append(l)
966 elif l.startswith(b' >>> '): # python inlines
966 elif l.startswith(b' >>> '): # python inlines
967 after.setdefault(pos, []).append(l)
967 after.setdefault(pos, []).append(l)
968 prepos = pos
968 prepos = pos
969 pos = n
969 pos = n
970 if not inpython:
970 if not inpython:
971 # We've just entered a Python block. Add the header.
971 # We've just entered a Python block. Add the header.
972 inpython = True
972 inpython = True
973 addsalt(prepos, False) # Make sure we report the exit code.
973 addsalt(prepos, False) # Make sure we report the exit code.
974 script.append('%s -m heredoctest <<EOF\n' % PYTHON)
974 script.append('%s -m heredoctest <<EOF\n' % PYTHON)
975 addsalt(n, True)
975 addsalt(n, True)
976 script.append(l[2:])
976 script.append(l[2:])
977 elif l.startswith(b' ... '): # python inlines
977 elif l.startswith(b' ... '): # python inlines
978 after.setdefault(prepos, []).append(l)
978 after.setdefault(prepos, []).append(l)
979 script.append(l[2:])
979 script.append(l[2:])
980 elif l.startswith(b' $ '): # commands
980 elif l.startswith(b' $ '): # commands
981 if inpython:
981 if inpython:
982 script.append('EOF\n')
982 script.append('EOF\n')
983 inpython = False
983 inpython = False
984 after.setdefault(pos, []).append(l)
984 after.setdefault(pos, []).append(l)
985 prepos = pos
985 prepos = pos
986 pos = n
986 pos = n
987 addsalt(n, False)
987 addsalt(n, False)
988 cmd = l[4:].split()
988 cmd = l[4:].split()
989 if len(cmd) == 2 and cmd[0] == 'cd':
989 if len(cmd) == 2 and cmd[0] == 'cd':
990 l = ' $ cd %s || exit 1\n' % cmd[1]
990 l = ' $ cd %s || exit 1\n' % cmd[1]
991 script.append(l[4:])
991 script.append(l[4:])
992 elif l.startswith(b' > '): # continuations
992 elif l.startswith(b' > '): # continuations
993 after.setdefault(prepos, []).append(l)
993 after.setdefault(prepos, []).append(l)
994 script.append(l[4:])
994 script.append(l[4:])
995 elif l.startswith(b' '): # results
995 elif l.startswith(b' '): # results
996 # Queue up a list of expected results.
996 # Queue up a list of expected results.
997 expected.setdefault(pos, []).append(l[2:])
997 expected.setdefault(pos, []).append(l[2:])
998 else:
998 else:
999 if inpython:
999 if inpython:
1000 script.append('EOF\n')
1000 script.append('EOF\n')
1001 inpython = False
1001 inpython = False
1002 # Non-command/result. Queue up for merged output.
1002 # Non-command/result. Queue up for merged output.
1003 after.setdefault(pos, []).append(l)
1003 after.setdefault(pos, []).append(l)
1004
1004
1005 if inpython:
1005 if inpython:
1006 script.append('EOF\n')
1006 script.append('EOF\n')
1007 if skipping is not None:
1007 if skipping is not None:
1008 after.setdefault(pos, []).append(' !!! missing #endif\n')
1008 after.setdefault(pos, []).append(' !!! missing #endif\n')
1009 addsalt(n + 1, False)
1009 addsalt(n + 1, False)
1010
1010
1011 return salt, script, after, expected
1011 return salt, script, after, expected
1012
1012
1013 def _processoutput(self, exitcode, output, salt, after, expected):
1013 def _processoutput(self, exitcode, output, salt, after, expected):
1014 # Merge the script output back into a unified test.
1014 # Merge the script output back into a unified test.
1015 warnonly = 1 # 1: not yet; 2: yes; 3: for sure not
1015 warnonly = 1 # 1: not yet; 2: yes; 3: for sure not
1016 if exitcode != 0:
1016 if exitcode != 0:
1017 warnonly = 3
1017 warnonly = 3
1018
1018
1019 pos = -1
1019 pos = -1
1020 postout = []
1020 postout = []
1021 for l in output:
1021 for l in output:
1022 lout, lcmd = l, None
1022 lout, lcmd = l, None
1023 if salt in l:
1023 if salt in l:
1024 lout, lcmd = l.split(salt, 1)
1024 lout, lcmd = l.split(salt, 1)
1025
1025
1026 if lout:
1026 if lout:
1027 if not lout.endswith(b'\n'):
1027 if not lout.endswith(b'\n'):
1028 lout += b' (no-eol)\n'
1028 lout += b' (no-eol)\n'
1029
1029
1030 # Find the expected output at the current position.
1030 # Find the expected output at the current position.
1031 el = None
1031 el = None
1032 if expected.get(pos, None):
1032 if expected.get(pos, None):
1033 el = expected[pos].pop(0)
1033 el = expected[pos].pop(0)
1034
1034
1035 r = TTest.linematch(el, lout)
1035 r = TTest.linematch(el, lout)
1036 if isinstance(r, str):
1036 if isinstance(r, str):
1037 if r == '+glob':
1037 if r == '+glob':
1038 lout = el[:-1] + ' (glob)\n'
1038 lout = el[:-1] + ' (glob)\n'
1039 r = '' # Warn only this line.
1039 r = '' # Warn only this line.
1040 elif r == '-glob':
1040 elif r == '-glob':
1041 lout = ''.join(el.rsplit(' (glob)', 1))
1041 lout = ''.join(el.rsplit(' (glob)', 1))
1042 r = '' # Warn only this line.
1042 r = '' # Warn only this line.
1043 else:
1043 else:
1044 log('\ninfo, unknown linematch result: %r\n' % r)
1044 log('\ninfo, unknown linematch result: %r\n' % r)
1045 r = False
1045 r = False
1046 if r:
1046 if r:
1047 postout.append(b' ' + el)
1047 postout.append(b' ' + el)
1048 else:
1048 else:
1049 if self.NEEDESCAPE(lout):
1049 if self.NEEDESCAPE(lout):
1050 lout = TTest._stringescape(b'%s (esc)\n' %
1050 lout = TTest._stringescape(b'%s (esc)\n' %
1051 lout.rstrip(b'\n'))
1051 lout.rstrip(b'\n'))
1052 postout.append(b' ' + lout) # Let diff deal with it.
1052 postout.append(b' ' + lout) # Let diff deal with it.
1053 if r != '': # If line failed.
1053 if r != '': # If line failed.
1054 warnonly = 3 # for sure not
1054 warnonly = 3 # for sure not
1055 elif warnonly == 1: # Is "not yet" and line is warn only.
1055 elif warnonly == 1: # Is "not yet" and line is warn only.
1056 warnonly = 2 # Yes do warn.
1056 warnonly = 2 # Yes do warn.
1057
1057
1058 if lcmd:
1058 if lcmd:
1059 # Add on last return code.
1059 # Add on last return code.
1060 ret = int(lcmd.split()[1])
1060 ret = int(lcmd.split()[1])
1061 if ret != 0:
1061 if ret != 0:
1062 postout.append(b' [%d]\n' % ret)
1062 postout.append(b' [%d]\n' % ret)
1063 if pos in after:
1063 if pos in after:
1064 # Merge in non-active test bits.
1064 # Merge in non-active test bits.
1065 postout += after.pop(pos)
1065 postout += after.pop(pos)
1066 pos = int(lcmd.split()[0])
1066 pos = int(lcmd.split()[0])
1067
1067
1068 if pos in after:
1068 if pos in after:
1069 postout += after.pop(pos)
1069 postout += after.pop(pos)
1070
1070
1071 if warnonly == 2:
1071 if warnonly == 2:
1072 exitcode = False # Set exitcode to warned.
1072 exitcode = False # Set exitcode to warned.
1073
1073
1074 return exitcode, postout
1074 return exitcode, postout
1075
1075
1076 @staticmethod
1076 @staticmethod
1077 def rematch(el, l):
1077 def rematch(el, l):
1078 try:
1078 try:
1079 # use \Z to ensure that the regex matches to the end of the string
1079 # use \Z to ensure that the regex matches to the end of the string
1080 if os.name == 'nt':
1080 if os.name == 'nt':
1081 return re.match(el + br'\r?\n\Z', l)
1081 return re.match(el + br'\r?\n\Z', l)
1082 return re.match(el + br'\n\Z', l)
1082 return re.match(el + br'\n\Z', l)
1083 except re.error:
1083 except re.error:
1084 # el is an invalid regex
1084 # el is an invalid regex
1085 return False
1085 return False
1086
1086
1087 @staticmethod
1087 @staticmethod
1088 def globmatch(el, l):
1088 def globmatch(el, l):
1089 # The only supported special characters are * and ? plus / which also
1089 # The only supported special characters are * and ? plus / which also
1090 # matches \ on windows. Escaping of these characters is supported.
1090 # matches \ on windows. Escaping of these characters is supported.
1091 if el + b'\n' == l:
1091 if el + b'\n' == l:
1092 if os.altsep:
1092 if os.altsep:
1093 # matching on "/" is not needed for this line
1093 # matching on "/" is not needed for this line
1094 for pat in checkcodeglobpats:
1094 for pat in checkcodeglobpats:
1095 if pat.match(el):
1095 if pat.match(el):
1096 return True
1096 return True
1097 return b'-glob'
1097 return b'-glob'
1098 return True
1098 return True
1099 i, n = 0, len(el)
1099 i, n = 0, len(el)
1100 res = b''
1100 res = b''
1101 while i < n:
1101 while i < n:
1102 c = el[i:i + 1]
1102 c = el[i:i + 1]
1103 i += 1
1103 i += 1
1104 if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/':
1104 if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/':
1105 res += el[i - 1:i + 1]
1105 res += el[i - 1:i + 1]
1106 i += 1
1106 i += 1
1107 elif c == b'*':
1107 elif c == b'*':
1108 res += b'.*'
1108 res += b'.*'
1109 elif c == b'?':
1109 elif c == b'?':
1110 res += b'.'
1110 res += b'.'
1111 elif c == b'/' and os.altsep:
1111 elif c == b'/' and os.altsep:
1112 res += b'[/\\\\]'
1112 res += b'[/\\\\]'
1113 else:
1113 else:
1114 res += re.escape(c)
1114 res += re.escape(c)
1115 return TTest.rematch(res, l)
1115 return TTest.rematch(res, l)
1116
1116
1117 @staticmethod
1117 @staticmethod
1118 def linematch(el, l):
1118 def linematch(el, l):
1119 if el == l: # perfect match (fast)
1119 if el == l: # perfect match (fast)
1120 return True
1120 return True
1121 if el:
1121 if el:
1122 if el.endswith(b" (esc)\n"):
1122 if el.endswith(b" (esc)\n"):
1123 if sys.version_info[0] == 3:
1123 if sys.version_info[0] == 3:
1124 el = el[:-7].decode('unicode_escape') + '\n'
1124 el = el[:-7].decode('unicode_escape') + '\n'
1125 el = el.encode('utf-8')
1125 el = el.encode('utf-8')
1126 else:
1126 else:
1127 el = el[:-7].decode('string-escape') + '\n'
1127 el = el[:-7].decode('string-escape') + '\n'
1128 if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:
1128 if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:
1129 return True
1129 return True
1130 if el.endswith(b" (re)\n"):
1130 if el.endswith(b" (re)\n"):
1131 return TTest.rematch(el[:-6], l)
1131 return TTest.rematch(el[:-6], l)
1132 if el.endswith(b" (glob)\n"):
1132 if el.endswith(b" (glob)\n"):
1133 # ignore '(glob)' added to l by 'replacements'
1133 # ignore '(glob)' added to l by 'replacements'
1134 if l.endswith(b" (glob)\n"):
1134 if l.endswith(b" (glob)\n"):
1135 l = l[:-8] + b"\n"
1135 l = l[:-8] + b"\n"
1136 return TTest.globmatch(el[:-8], l)
1136 return TTest.globmatch(el[:-8], l)
1137 if os.altsep and l.replace(b'\\', b'/') == el:
1137 if os.altsep and l.replace(b'\\', b'/') == el:
1138 return b'+glob'
1138 return b'+glob'
1139 return False
1139 return False
1140
1140
1141 @staticmethod
1141 @staticmethod
1142 def parsehghaveoutput(lines):
1142 def parsehghaveoutput(lines):
1143 '''Parse hghave log lines.
1143 '''Parse hghave log lines.
1144
1144
1145 Return tuple of lists (missing, failed):
1145 Return tuple of lists (missing, failed):
1146 * the missing/unknown features
1146 * the missing/unknown features
1147 * the features for which existence check failed'''
1147 * the features for which existence check failed'''
1148 missing = []
1148 missing = []
1149 failed = []
1149 failed = []
1150 for line in lines:
1150 for line in lines:
1151 if line.startswith(TTest.SKIPPED_PREFIX):
1151 if line.startswith(TTest.SKIPPED_PREFIX):
1152 line = line.splitlines()[0]
1152 line = line.splitlines()[0]
1153 missing.append(line[len(TTest.SKIPPED_PREFIX):])
1153 missing.append(line[len(TTest.SKIPPED_PREFIX):])
1154 elif line.startswith(TTest.FAILED_PREFIX):
1154 elif line.startswith(TTest.FAILED_PREFIX):
1155 line = line.splitlines()[0]
1155 line = line.splitlines()[0]
1156 failed.append(line[len(TTest.FAILED_PREFIX):])
1156 failed.append(line[len(TTest.FAILED_PREFIX):])
1157
1157
1158 return missing, failed
1158 return missing, failed
1159
1159
1160 @staticmethod
1160 @staticmethod
1161 def _escapef(m):
1161 def _escapef(m):
1162 return TTest.ESCAPEMAP[m.group(0)]
1162 return TTest.ESCAPEMAP[m.group(0)]
1163
1163
1164 @staticmethod
1164 @staticmethod
1165 def _stringescape(s):
1165 def _stringescape(s):
1166 return TTest.ESCAPESUB(TTest._escapef, s)
1166 return TTest.ESCAPESUB(TTest._escapef, s)
1167
1167
1168 iolock = threading.RLock()
1168 iolock = threading.RLock()
1169
1169
1170 class SkipTest(Exception):
1170 class SkipTest(Exception):
1171 """Raised to indicate that a test is to be skipped."""
1171 """Raised to indicate that a test is to be skipped."""
1172
1172
1173 class IgnoreTest(Exception):
1173 class IgnoreTest(Exception):
1174 """Raised to indicate that a test is to be ignored."""
1174 """Raised to indicate that a test is to be ignored."""
1175
1175
1176 class WarnTest(Exception):
1176 class WarnTest(Exception):
1177 """Raised to indicate that a test warned."""
1177 """Raised to indicate that a test warned."""
1178
1178
1179 class TestResult(unittest._TextTestResult):
1179 class TestResult(unittest._TextTestResult):
1180 """Holds results when executing via unittest."""
1180 """Holds results when executing via unittest."""
1181 # Don't worry too much about accessing the non-public _TextTestResult.
1181 # Don't worry too much about accessing the non-public _TextTestResult.
1182 # It is relatively common in Python testing tools.
1182 # It is relatively common in Python testing tools.
1183 def __init__(self, options, *args, **kwargs):
1183 def __init__(self, options, *args, **kwargs):
1184 super(TestResult, self).__init__(*args, **kwargs)
1184 super(TestResult, self).__init__(*args, **kwargs)
1185
1185
1186 self._options = options
1186 self._options = options
1187
1187
1188 # unittest.TestResult didn't have skipped until 2.7. We need to
1188 # unittest.TestResult didn't have skipped until 2.7. We need to
1189 # polyfill it.
1189 # polyfill it.
1190 self.skipped = []
1190 self.skipped = []
1191
1191
1192 # We have a custom "ignored" result that isn't present in any Python
1192 # We have a custom "ignored" result that isn't present in any Python
1193 # unittest implementation. It is very similar to skipped. It may make
1193 # unittest implementation. It is very similar to skipped. It may make
1194 # sense to map it into skip some day.
1194 # sense to map it into skip some day.
1195 self.ignored = []
1195 self.ignored = []
1196
1196
1197 # We have a custom "warned" result that isn't present in any Python
1197 # We have a custom "warned" result that isn't present in any Python
1198 # unittest implementation. It is very similar to failed. It may make
1198 # unittest implementation. It is very similar to failed. It may make
1199 # sense to map it into fail some day.
1199 # sense to map it into fail some day.
1200 self.warned = []
1200 self.warned = []
1201
1201
1202 self.times = []
1202 self.times = []
1203 # Data stored for the benefit of generating xunit reports.
1203 # Data stored for the benefit of generating xunit reports.
1204 self.successes = []
1204 self.successes = []
1205 self.faildata = {}
1205 self.faildata = {}
1206
1206
1207 def addFailure(self, test, reason):
1207 def addFailure(self, test, reason):
1208 self.failures.append((test, reason))
1208 self.failures.append((test, reason))
1209
1209
1210 if self._options.first:
1210 if self._options.first:
1211 self.stop()
1211 self.stop()
1212 else:
1212 else:
1213 with iolock:
1213 with iolock:
1214 if not self._options.nodiff:
1214 if not self._options.nodiff:
1215 self.stream.write('\nERROR: %s output changed\n' % test)
1215 self.stream.write('\nERROR: %s output changed\n' % test)
1216
1216
1217 self.stream.write('!')
1217 self.stream.write('!')
1218 self.stream.flush()
1218 self.stream.flush()
1219
1219
1220 def addSuccess(self, test):
1220 def addSuccess(self, test):
1221 with iolock:
1221 with iolock:
1222 super(TestResult, self).addSuccess(test)
1222 super(TestResult, self).addSuccess(test)
1223 self.successes.append(test)
1223 self.successes.append(test)
1224
1224
1225 def addError(self, test, err):
1225 def addError(self, test, err):
1226 super(TestResult, self).addError(test, err)
1226 super(TestResult, self).addError(test, err)
1227 if self._options.first:
1227 if self._options.first:
1228 self.stop()
1228 self.stop()
1229
1229
1230 # Polyfill.
1230 # Polyfill.
1231 def addSkip(self, test, reason):
1231 def addSkip(self, test, reason):
1232 self.skipped.append((test, reason))
1232 self.skipped.append((test, reason))
1233 with iolock:
1233 with iolock:
1234 if self.showAll:
1234 if self.showAll:
1235 self.stream.writeln('skipped %s' % reason)
1235 self.stream.writeln('skipped %s' % reason)
1236 else:
1236 else:
1237 self.stream.write('s')
1237 self.stream.write('s')
1238 self.stream.flush()
1238 self.stream.flush()
1239
1239
1240 def addIgnore(self, test, reason):
1240 def addIgnore(self, test, reason):
1241 self.ignored.append((test, reason))
1241 self.ignored.append((test, reason))
1242 with iolock:
1242 with iolock:
1243 if self.showAll:
1243 if self.showAll:
1244 self.stream.writeln('ignored %s' % reason)
1244 self.stream.writeln('ignored %s' % reason)
1245 else:
1245 else:
1246 if reason not in ('not retesting', "doesn't match keyword"):
1246 if reason not in ('not retesting', "doesn't match keyword"):
1247 self.stream.write('i')
1247 self.stream.write('i')
1248 else:
1248 else:
1249 self.testsRun += 1
1249 self.testsRun += 1
1250 self.stream.flush()
1250 self.stream.flush()
1251
1251
1252 def addWarn(self, test, reason):
1252 def addWarn(self, test, reason):
1253 self.warned.append((test, reason))
1253 self.warned.append((test, reason))
1254
1254
1255 if self._options.first:
1255 if self._options.first:
1256 self.stop()
1256 self.stop()
1257
1257
1258 with iolock:
1258 with iolock:
1259 if self.showAll:
1259 if self.showAll:
1260 self.stream.writeln('warned %s' % reason)
1260 self.stream.writeln('warned %s' % reason)
1261 else:
1261 else:
1262 self.stream.write('~')
1262 self.stream.write('~')
1263 self.stream.flush()
1263 self.stream.flush()
1264
1264
1265 def addOutputMismatch(self, test, ret, got, expected):
1265 def addOutputMismatch(self, test, ret, got, expected):
1266 """Record a mismatch in test output for a particular test."""
1266 """Record a mismatch in test output for a particular test."""
1267 if self.shouldStop:
1267 if self.shouldStop:
1268 # don't print, some other test case already failed and
1268 # don't print, some other test case already failed and
1269 # printed, we're just stale and probably failed due to our
1269 # printed, we're just stale and probably failed due to our
1270 # temp dir getting cleaned up.
1270 # temp dir getting cleaned up.
1271 return
1271 return
1272
1272
1273 accepted = False
1273 accepted = False
1274 failed = False
1274 failed = False
1275 lines = []
1275 lines = []
1276
1276
1277 with iolock:
1277 with iolock:
1278 if self._options.nodiff:
1278 if self._options.nodiff:
1279 pass
1279 pass
1280 elif self._options.view:
1280 elif self._options.view:
1281 os.system("%s %s %s" %
1281 os.system("%s %s %s" %
1282 (self._options.view, test.refpath, test.errpath))
1282 (self._options.view, test.refpath, test.errpath))
1283 else:
1283 else:
1284 servefail, lines = getdiff(expected, got,
1284 servefail, lines = getdiff(expected, got,
1285 test.refpath, test.errpath)
1285 test.refpath, test.errpath)
1286 if servefail:
1286 if servefail:
1287 self.addFailure(
1287 self.addFailure(
1288 test,
1288 test,
1289 'server failed to start (HGPORT=%s)' % test._startport)
1289 'server failed to start (HGPORT=%s)' % test._startport)
1290 else:
1290 else:
1291 self.stream.write('\n')
1291 self.stream.write('\n')
1292 for line in lines:
1292 for line in lines:
1293 self.stream.write(line)
1293 if sys.version_info[0] > 2:
1294 self.stream.flush()
1294 self.stream.flush()
1295 self.stream.buffer.write(line)
1296 self.stream.buffer.flush()
1297 else:
1298 self.stream.write(line)
1299 self.stream.flush()
1295
1300
1296 # handle interactive prompt without releasing iolock
1301 # handle interactive prompt without releasing iolock
1297 if self._options.interactive:
1302 if self._options.interactive:
1298 self.stream.write('Accept this change? [n] ')
1303 self.stream.write('Accept this change? [n] ')
1299 answer = sys.stdin.readline().strip()
1304 answer = sys.stdin.readline().strip()
1300 if answer.lower() in ('y', 'yes'):
1305 if answer.lower() in ('y', 'yes'):
1301 if test.name.endswith('.t'):
1306 if test.name.endswith('.t'):
1302 rename(test.errpath, test.path)
1307 rename(test.errpath, test.path)
1303 else:
1308 else:
1304 rename(test.errpath, '%s.out' % test.path)
1309 rename(test.errpath, '%s.out' % test.path)
1305 accepted = True
1310 accepted = True
1306 if not accepted and not failed:
1311 if not accepted and not failed:
1307 self.faildata[test.name] = b''.join(lines)
1312 self.faildata[test.name] = b''.join(lines)
1308
1313
1309 return accepted
1314 return accepted
1310
1315
1311 def startTest(self, test):
1316 def startTest(self, test):
1312 super(TestResult, self).startTest(test)
1317 super(TestResult, self).startTest(test)
1313
1318
1314 # os.times module computes the user time and system time spent by
1319 # os.times module computes the user time and system time spent by
1315 # child's processes along with real elapsed time taken by a process.
1320 # child's processes along with real elapsed time taken by a process.
1316 # This module has one limitation. It can only work for Linux user
1321 # This module has one limitation. It can only work for Linux user
1317 # and not for Windows.
1322 # and not for Windows.
1318 test.started = os.times()
1323 test.started = os.times()
1319
1324
1320 def stopTest(self, test, interrupted=False):
1325 def stopTest(self, test, interrupted=False):
1321 super(TestResult, self).stopTest(test)
1326 super(TestResult, self).stopTest(test)
1322
1327
1323 test.stopped = os.times()
1328 test.stopped = os.times()
1324
1329
1325 starttime = test.started
1330 starttime = test.started
1326 endtime = test.stopped
1331 endtime = test.stopped
1327 self.times.append((test.name,
1332 self.times.append((test.name,
1328 endtime[2] - starttime[2], # user space CPU time
1333 endtime[2] - starttime[2], # user space CPU time
1329 endtime[3] - starttime[3], # sys space CPU time
1334 endtime[3] - starttime[3], # sys space CPU time
1330 endtime[4] - starttime[4], # real time
1335 endtime[4] - starttime[4], # real time
1331 ))
1336 ))
1332
1337
1333 if interrupted:
1338 if interrupted:
1334 with iolock:
1339 with iolock:
1335 self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % (
1340 self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % (
1336 test.name, self.times[-1][3]))
1341 test.name, self.times[-1][3]))
1337
1342
1338 class TestSuite(unittest.TestSuite):
1343 class TestSuite(unittest.TestSuite):
1339 """Custom unittest TestSuite that knows how to execute Mercurial tests."""
1344 """Custom unittest TestSuite that knows how to execute Mercurial tests."""
1340
1345
1341 def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None,
1346 def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None,
1342 retest=False, keywords=None, loop=False, runs_per_test=1,
1347 retest=False, keywords=None, loop=False, runs_per_test=1,
1343 loadtest=None,
1348 loadtest=None,
1344 *args, **kwargs):
1349 *args, **kwargs):
1345 """Create a new instance that can run tests with a configuration.
1350 """Create a new instance that can run tests with a configuration.
1346
1351
1347 testdir specifies the directory where tests are executed from. This
1352 testdir specifies the directory where tests are executed from. This
1348 is typically the ``tests`` directory from Mercurial's source
1353 is typically the ``tests`` directory from Mercurial's source
1349 repository.
1354 repository.
1350
1355
1351 jobs specifies the number of jobs to run concurrently. Each test
1356 jobs specifies the number of jobs to run concurrently. Each test
1352 executes on its own thread. Tests actually spawn new processes, so
1357 executes on its own thread. Tests actually spawn new processes, so
1353 state mutation should not be an issue.
1358 state mutation should not be an issue.
1354
1359
1355 whitelist and blacklist denote tests that have been whitelisted and
1360 whitelist and blacklist denote tests that have been whitelisted and
1356 blacklisted, respectively. These arguments don't belong in TestSuite.
1361 blacklisted, respectively. These arguments don't belong in TestSuite.
1357 Instead, whitelist and blacklist should be handled by the thing that
1362 Instead, whitelist and blacklist should be handled by the thing that
1358 populates the TestSuite with tests. They are present to preserve
1363 populates the TestSuite with tests. They are present to preserve
1359 backwards compatible behavior which reports skipped tests as part
1364 backwards compatible behavior which reports skipped tests as part
1360 of the results.
1365 of the results.
1361
1366
1362 retest denotes whether to retest failed tests. This arguably belongs
1367 retest denotes whether to retest failed tests. This arguably belongs
1363 outside of TestSuite.
1368 outside of TestSuite.
1364
1369
1365 keywords denotes key words that will be used to filter which tests
1370 keywords denotes key words that will be used to filter which tests
1366 to execute. This arguably belongs outside of TestSuite.
1371 to execute. This arguably belongs outside of TestSuite.
1367
1372
1368 loop denotes whether to loop over tests forever.
1373 loop denotes whether to loop over tests forever.
1369 """
1374 """
1370 super(TestSuite, self).__init__(*args, **kwargs)
1375 super(TestSuite, self).__init__(*args, **kwargs)
1371
1376
1372 self._jobs = jobs
1377 self._jobs = jobs
1373 self._whitelist = whitelist
1378 self._whitelist = whitelist
1374 self._blacklist = blacklist
1379 self._blacklist = blacklist
1375 self._retest = retest
1380 self._retest = retest
1376 self._keywords = keywords
1381 self._keywords = keywords
1377 self._loop = loop
1382 self._loop = loop
1378 self._runs_per_test = runs_per_test
1383 self._runs_per_test = runs_per_test
1379 self._loadtest = loadtest
1384 self._loadtest = loadtest
1380
1385
1381 def run(self, result):
1386 def run(self, result):
1382 # We have a number of filters that need to be applied. We do this
1387 # We have a number of filters that need to be applied. We do this
1383 # here instead of inside Test because it makes the running logic for
1388 # here instead of inside Test because it makes the running logic for
1384 # Test simpler.
1389 # Test simpler.
1385 tests = []
1390 tests = []
1386 num_tests = [0]
1391 num_tests = [0]
1387 for test in self._tests:
1392 for test in self._tests:
1388 def get():
1393 def get():
1389 num_tests[0] += 1
1394 num_tests[0] += 1
1390 if getattr(test, 'should_reload', False):
1395 if getattr(test, 'should_reload', False):
1391 return self._loadtest(test.bname, num_tests[0])
1396 return self._loadtest(test.bname, num_tests[0])
1392 return test
1397 return test
1393 if not os.path.exists(test.path):
1398 if not os.path.exists(test.path):
1394 result.addSkip(test, "Doesn't exist")
1399 result.addSkip(test, "Doesn't exist")
1395 continue
1400 continue
1396
1401
1397 if not (self._whitelist and test.name in self._whitelist):
1402 if not (self._whitelist and test.name in self._whitelist):
1398 if self._blacklist and test.name in self._blacklist:
1403 if self._blacklist and test.name in self._blacklist:
1399 result.addSkip(test, 'blacklisted')
1404 result.addSkip(test, 'blacklisted')
1400 continue
1405 continue
1401
1406
1402 if self._retest and not os.path.exists(test.errpath):
1407 if self._retest and not os.path.exists(test.errpath):
1403 result.addIgnore(test, 'not retesting')
1408 result.addIgnore(test, 'not retesting')
1404 continue
1409 continue
1405
1410
1406 if self._keywords:
1411 if self._keywords:
1407 f = open(test.path, 'rb')
1412 f = open(test.path, 'rb')
1408 t = f.read().lower() + test.bname.lower()
1413 t = f.read().lower() + test.bname.lower()
1409 f.close()
1414 f.close()
1410 ignored = False
1415 ignored = False
1411 for k in self._keywords.lower().split():
1416 for k in self._keywords.lower().split():
1412 if k not in t:
1417 if k not in t:
1413 result.addIgnore(test, "doesn't match keyword")
1418 result.addIgnore(test, "doesn't match keyword")
1414 ignored = True
1419 ignored = True
1415 break
1420 break
1416
1421
1417 if ignored:
1422 if ignored:
1418 continue
1423 continue
1419 for _ in xrange(self._runs_per_test):
1424 for _ in xrange(self._runs_per_test):
1420 tests.append(get())
1425 tests.append(get())
1421
1426
1422 runtests = list(tests)
1427 runtests = list(tests)
1423 done = queue.Queue()
1428 done = queue.Queue()
1424 running = 0
1429 running = 0
1425
1430
1426 def job(test, result):
1431 def job(test, result):
1427 try:
1432 try:
1428 test(result)
1433 test(result)
1429 done.put(None)
1434 done.put(None)
1430 except KeyboardInterrupt:
1435 except KeyboardInterrupt:
1431 pass
1436 pass
1432 except: # re-raises
1437 except: # re-raises
1433 done.put(('!', test, 'run-test raised an error, see traceback'))
1438 done.put(('!', test, 'run-test raised an error, see traceback'))
1434 raise
1439 raise
1435
1440
1436 stoppedearly = False
1441 stoppedearly = False
1437
1442
1438 try:
1443 try:
1439 while tests or running:
1444 while tests or running:
1440 if not done.empty() or running == self._jobs or not tests:
1445 if not done.empty() or running == self._jobs or not tests:
1441 try:
1446 try:
1442 done.get(True, 1)
1447 done.get(True, 1)
1443 running -= 1
1448 running -= 1
1444 if result and result.shouldStop:
1449 if result and result.shouldStop:
1445 stoppedearly = True
1450 stoppedearly = True
1446 break
1451 break
1447 except queue.Empty:
1452 except queue.Empty:
1448 continue
1453 continue
1449 if tests and not running == self._jobs:
1454 if tests and not running == self._jobs:
1450 test = tests.pop(0)
1455 test = tests.pop(0)
1451 if self._loop:
1456 if self._loop:
1452 if getattr(test, 'should_reload', False):
1457 if getattr(test, 'should_reload', False):
1453 num_tests[0] += 1
1458 num_tests[0] += 1
1454 tests.append(
1459 tests.append(
1455 self._loadtest(test.name, num_tests[0]))
1460 self._loadtest(test.name, num_tests[0]))
1456 else:
1461 else:
1457 tests.append(test)
1462 tests.append(test)
1458 t = threading.Thread(target=job, name=test.name,
1463 t = threading.Thread(target=job, name=test.name,
1459 args=(test, result))
1464 args=(test, result))
1460 t.start()
1465 t.start()
1461 running += 1
1466 running += 1
1462
1467
1463 # If we stop early we still need to wait on started tests to
1468 # If we stop early we still need to wait on started tests to
1464 # finish. Otherwise, there is a race between the test completing
1469 # finish. Otherwise, there is a race between the test completing
1465 # and the test's cleanup code running. This could result in the
1470 # and the test's cleanup code running. This could result in the
1466 # test reporting incorrect.
1471 # test reporting incorrect.
1467 if stoppedearly:
1472 if stoppedearly:
1468 while running:
1473 while running:
1469 try:
1474 try:
1470 done.get(True, 1)
1475 done.get(True, 1)
1471 running -= 1
1476 running -= 1
1472 except queue.Empty:
1477 except queue.Empty:
1473 continue
1478 continue
1474 except KeyboardInterrupt:
1479 except KeyboardInterrupt:
1475 for test in runtests:
1480 for test in runtests:
1476 test.abort()
1481 test.abort()
1477
1482
1478 return result
1483 return result
1479
1484
1480 class TextTestRunner(unittest.TextTestRunner):
1485 class TextTestRunner(unittest.TextTestRunner):
1481 """Custom unittest test runner that uses appropriate settings."""
1486 """Custom unittest test runner that uses appropriate settings."""
1482
1487
1483 def __init__(self, runner, *args, **kwargs):
1488 def __init__(self, runner, *args, **kwargs):
1484 super(TextTestRunner, self).__init__(*args, **kwargs)
1489 super(TextTestRunner, self).__init__(*args, **kwargs)
1485
1490
1486 self._runner = runner
1491 self._runner = runner
1487
1492
1488 def run(self, test):
1493 def run(self, test):
1489 result = TestResult(self._runner.options, self.stream,
1494 result = TestResult(self._runner.options, self.stream,
1490 self.descriptions, self.verbosity)
1495 self.descriptions, self.verbosity)
1491
1496
1492 test(result)
1497 test(result)
1493
1498
1494 failed = len(result.failures)
1499 failed = len(result.failures)
1495 warned = len(result.warned)
1500 warned = len(result.warned)
1496 skipped = len(result.skipped)
1501 skipped = len(result.skipped)
1497 ignored = len(result.ignored)
1502 ignored = len(result.ignored)
1498
1503
1499 with iolock:
1504 with iolock:
1500 self.stream.writeln('')
1505 self.stream.writeln('')
1501
1506
1502 if not self._runner.options.noskips:
1507 if not self._runner.options.noskips:
1503 for test, msg in result.skipped:
1508 for test, msg in result.skipped:
1504 self.stream.writeln('Skipped %s: %s' % (test.name, msg))
1509 self.stream.writeln('Skipped %s: %s' % (test.name, msg))
1505 for test, msg in result.warned:
1510 for test, msg in result.warned:
1506 self.stream.writeln('Warned %s: %s' % (test.name, msg))
1511 self.stream.writeln('Warned %s: %s' % (test.name, msg))
1507 for test, msg in result.failures:
1512 for test, msg in result.failures:
1508 self.stream.writeln('Failed %s: %s' % (test.name, msg))
1513 self.stream.writeln('Failed %s: %s' % (test.name, msg))
1509 for test, msg in result.errors:
1514 for test, msg in result.errors:
1510 self.stream.writeln('Errored %s: %s' % (test.name, msg))
1515 self.stream.writeln('Errored %s: %s' % (test.name, msg))
1511
1516
1512 if self._runner.options.xunit:
1517 if self._runner.options.xunit:
1513 xuf = open(self._runner.options.xunit, 'wb')
1518 xuf = open(self._runner.options.xunit, 'wb')
1514 try:
1519 try:
1515 timesd = dict((t[0], t[3]) for t in result.times)
1520 timesd = dict((t[0], t[3]) for t in result.times)
1516 doc = minidom.Document()
1521 doc = minidom.Document()
1517 s = doc.createElement('testsuite')
1522 s = doc.createElement('testsuite')
1518 s.setAttribute('name', 'run-tests')
1523 s.setAttribute('name', 'run-tests')
1519 s.setAttribute('tests', str(result.testsRun))
1524 s.setAttribute('tests', str(result.testsRun))
1520 s.setAttribute('errors', "0") # TODO
1525 s.setAttribute('errors', "0") # TODO
1521 s.setAttribute('failures', str(failed))
1526 s.setAttribute('failures', str(failed))
1522 s.setAttribute('skipped', str(skipped + ignored))
1527 s.setAttribute('skipped', str(skipped + ignored))
1523 doc.appendChild(s)
1528 doc.appendChild(s)
1524 for tc in result.successes:
1529 for tc in result.successes:
1525 t = doc.createElement('testcase')
1530 t = doc.createElement('testcase')
1526 t.setAttribute('name', tc.name)
1531 t.setAttribute('name', tc.name)
1527 t.setAttribute('time', '%.3f' % timesd[tc.name])
1532 t.setAttribute('time', '%.3f' % timesd[tc.name])
1528 s.appendChild(t)
1533 s.appendChild(t)
1529 for tc, err in sorted(result.faildata.items()):
1534 for tc, err in sorted(result.faildata.items()):
1530 t = doc.createElement('testcase')
1535 t = doc.createElement('testcase')
1531 t.setAttribute('name', tc)
1536 t.setAttribute('name', tc)
1532 t.setAttribute('time', '%.3f' % timesd[tc])
1537 t.setAttribute('time', '%.3f' % timesd[tc])
1533 # createCDATASection expects a unicode or it will
1538 # createCDATASection expects a unicode or it will
1534 # convert using default conversion rules, which will
1539 # convert using default conversion rules, which will
1535 # fail if string isn't ASCII.
1540 # fail if string isn't ASCII.
1536 err = cdatasafe(err).decode('utf-8', 'replace')
1541 err = cdatasafe(err).decode('utf-8', 'replace')
1537 cd = doc.createCDATASection(err)
1542 cd = doc.createCDATASection(err)
1538 t.appendChild(cd)
1543 t.appendChild(cd)
1539 s.appendChild(t)
1544 s.appendChild(t)
1540 xuf.write(doc.toprettyxml(indent=' ', encoding='utf-8'))
1545 xuf.write(doc.toprettyxml(indent=' ', encoding='utf-8'))
1541 finally:
1546 finally:
1542 xuf.close()
1547 xuf.close()
1543
1548
1544 if self._runner.options.json:
1549 if self._runner.options.json:
1545 if json is None:
1550 if json is None:
1546 raise ImportError("json module not installed")
1551 raise ImportError("json module not installed")
1547 jsonpath = os.path.join(self._runner._testdir, 'report.json')
1552 jsonpath = os.path.join(self._runner._testdir, 'report.json')
1548 fp = open(jsonpath, 'w')
1553 fp = open(jsonpath, 'w')
1549 try:
1554 try:
1550 timesd = {}
1555 timesd = {}
1551 for tdata in result.times:
1556 for tdata in result.times:
1552 test = tdata[0]
1557 test = tdata[0]
1553 timesd[test] = tdata[1:]
1558 timesd[test] = tdata[1:]
1554
1559
1555 outcome = {}
1560 outcome = {}
1556 groups = [('success', ((tc, None)
1561 groups = [('success', ((tc, None)
1557 for tc in result.successes)),
1562 for tc in result.successes)),
1558 ('failure', result.failures),
1563 ('failure', result.failures),
1559 ('skip', result.skipped)]
1564 ('skip', result.skipped)]
1560 for res, testcases in groups:
1565 for res, testcases in groups:
1561 for tc, __ in testcases:
1566 for tc, __ in testcases:
1562 tres = {'result': res,
1567 tres = {'result': res,
1563 'time': ('%0.3f' % timesd[tc.name][2]),
1568 'time': ('%0.3f' % timesd[tc.name][2]),
1564 'cuser': ('%0.3f' % timesd[tc.name][0]),
1569 'cuser': ('%0.3f' % timesd[tc.name][0]),
1565 'csys': ('%0.3f' % timesd[tc.name][1])}
1570 'csys': ('%0.3f' % timesd[tc.name][1])}
1566 outcome[tc.name] = tres
1571 outcome[tc.name] = tres
1567
1572
1568 jsonout = json.dumps(outcome, sort_keys=True, indent=4)
1573 jsonout = json.dumps(outcome, sort_keys=True, indent=4)
1569 fp.writelines(("testreport =", jsonout))
1574 fp.writelines(("testreport =", jsonout))
1570 finally:
1575 finally:
1571 fp.close()
1576 fp.close()
1572
1577
1573 self._runner._checkhglib('Tested')
1578 self._runner._checkhglib('Tested')
1574
1579
1575 self.stream.writeln(
1580 self.stream.writeln(
1576 '# Ran %d tests, %d skipped, %d warned, %d failed.'
1581 '# Ran %d tests, %d skipped, %d warned, %d failed.'
1577 % (result.testsRun,
1582 % (result.testsRun,
1578 skipped + ignored, warned, failed))
1583 skipped + ignored, warned, failed))
1579 if failed:
1584 if failed:
1580 self.stream.writeln('python hash seed: %s' %
1585 self.stream.writeln('python hash seed: %s' %
1581 os.environ['PYTHONHASHSEED'])
1586 os.environ['PYTHONHASHSEED'])
1582 if self._runner.options.time:
1587 if self._runner.options.time:
1583 self.printtimes(result.times)
1588 self.printtimes(result.times)
1584
1589
1585 return result
1590 return result
1586
1591
1587 def printtimes(self, times):
1592 def printtimes(self, times):
1588 # iolock held by run
1593 # iolock held by run
1589 self.stream.writeln('# Producing time report')
1594 self.stream.writeln('# Producing time report')
1590 times.sort(key=lambda t: (t[3]))
1595 times.sort(key=lambda t: (t[3]))
1591 cols = '%7.3f %7.3f %7.3f %s'
1596 cols = '%7.3f %7.3f %7.3f %s'
1592 self.stream.writeln('%-7s %-7s %-7s %s' % ('cuser', 'csys', 'real',
1597 self.stream.writeln('%-7s %-7s %-7s %s' % ('cuser', 'csys', 'real',
1593 'Test'))
1598 'Test'))
1594 for tdata in times:
1599 for tdata in times:
1595 test = tdata[0]
1600 test = tdata[0]
1596 cuser, csys, real = tdata[1:4]
1601 cuser, csys, real = tdata[1:4]
1597 self.stream.writeln(cols % (cuser, csys, real, test))
1602 self.stream.writeln(cols % (cuser, csys, real, test))
1598
1603
1599 class TestRunner(object):
1604 class TestRunner(object):
1600 """Holds context for executing tests.
1605 """Holds context for executing tests.
1601
1606
1602 Tests rely on a lot of state. This object holds it for them.
1607 Tests rely on a lot of state. This object holds it for them.
1603 """
1608 """
1604
1609
1605 # Programs required to run tests.
1610 # Programs required to run tests.
1606 REQUIREDTOOLS = [
1611 REQUIREDTOOLS = [
1607 os.path.basename(sys.executable).encode('utf-8'),
1612 os.path.basename(sys.executable).encode('utf-8'),
1608 b'diff',
1613 b'diff',
1609 b'grep',
1614 b'grep',
1610 b'unzip',
1615 b'unzip',
1611 b'gunzip',
1616 b'gunzip',
1612 b'bunzip2',
1617 b'bunzip2',
1613 b'sed',
1618 b'sed',
1614 ]
1619 ]
1615
1620
1616 # Maps file extensions to test class.
1621 # Maps file extensions to test class.
1617 TESTTYPES = [
1622 TESTTYPES = [
1618 (b'.py', PythonTest),
1623 (b'.py', PythonTest),
1619 (b'.t', TTest),
1624 (b'.t', TTest),
1620 ]
1625 ]
1621
1626
1622 def __init__(self):
1627 def __init__(self):
1623 self.options = None
1628 self.options = None
1624 self._hgroot = None
1629 self._hgroot = None
1625 self._testdir = None
1630 self._testdir = None
1626 self._hgtmp = None
1631 self._hgtmp = None
1627 self._installdir = None
1632 self._installdir = None
1628 self._bindir = None
1633 self._bindir = None
1629 self._tmpbinddir = None
1634 self._tmpbinddir = None
1630 self._pythondir = None
1635 self._pythondir = None
1631 self._coveragefile = None
1636 self._coveragefile = None
1632 self._createdfiles = []
1637 self._createdfiles = []
1633 self._hgpath = None
1638 self._hgpath = None
1634 self._portoffset = 0
1639 self._portoffset = 0
1635 self._ports = {}
1640 self._ports = {}
1636
1641
1637 def run(self, args, parser=None):
1642 def run(self, args, parser=None):
1638 """Run the test suite."""
1643 """Run the test suite."""
1639 oldmask = os.umask(0o22)
1644 oldmask = os.umask(0o22)
1640 try:
1645 try:
1641 parser = parser or getparser()
1646 parser = parser or getparser()
1642 options, args = parseargs(args, parser)
1647 options, args = parseargs(args, parser)
1643 args = [a.encode('utf-8') for a in args]
1648 args = [a.encode('utf-8') for a in args]
1644 self.options = options
1649 self.options = options
1645
1650
1646 self._checktools()
1651 self._checktools()
1647 tests = self.findtests(args)
1652 tests = self.findtests(args)
1648 return self._run(tests)
1653 return self._run(tests)
1649 finally:
1654 finally:
1650 os.umask(oldmask)
1655 os.umask(oldmask)
1651
1656
1652 def _run(self, tests):
1657 def _run(self, tests):
1653 if self.options.random:
1658 if self.options.random:
1654 random.shuffle(tests)
1659 random.shuffle(tests)
1655 else:
1660 else:
1656 # keywords for slow tests
1661 # keywords for slow tests
1657 slow = b'svn gendoc check-code-hg'.split()
1662 slow = b'svn gendoc check-code-hg'.split()
1658 def sortkey(f):
1663 def sortkey(f):
1659 # run largest tests first, as they tend to take the longest
1664 # run largest tests first, as they tend to take the longest
1660 try:
1665 try:
1661 val = -os.stat(f).st_size
1666 val = -os.stat(f).st_size
1662 except OSError as e:
1667 except OSError as e:
1663 if e.errno != errno.ENOENT:
1668 if e.errno != errno.ENOENT:
1664 raise
1669 raise
1665 return -1e9 # file does not exist, tell early
1670 return -1e9 # file does not exist, tell early
1666 for kw in slow:
1671 for kw in slow:
1667 if kw in f:
1672 if kw in f:
1668 val *= 10
1673 val *= 10
1669 return val
1674 return val
1670 tests.sort(key=sortkey)
1675 tests.sort(key=sortkey)
1671
1676
1672 self._testdir = osenvironb[b'TESTDIR'] = getattr(
1677 self._testdir = osenvironb[b'TESTDIR'] = getattr(
1673 os, 'getcwdb', os.getcwd)()
1678 os, 'getcwdb', os.getcwd)()
1674
1679
1675 if 'PYTHONHASHSEED' not in os.environ:
1680 if 'PYTHONHASHSEED' not in os.environ:
1676 # use a random python hash seed all the time
1681 # use a random python hash seed all the time
1677 # we do the randomness ourself to know what seed is used
1682 # we do the randomness ourself to know what seed is used
1678 os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))
1683 os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))
1679
1684
1680 if self.options.tmpdir:
1685 if self.options.tmpdir:
1681 self.options.keep_tmpdir = True
1686 self.options.keep_tmpdir = True
1682 tmpdir = self.options.tmpdir.encode('utf-8')
1687 tmpdir = self.options.tmpdir.encode('utf-8')
1683 if os.path.exists(tmpdir):
1688 if os.path.exists(tmpdir):
1684 # Meaning of tmpdir has changed since 1.3: we used to create
1689 # Meaning of tmpdir has changed since 1.3: we used to create
1685 # HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if
1690 # HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if
1686 # tmpdir already exists.
1691 # tmpdir already exists.
1687 print("error: temp dir %r already exists" % tmpdir)
1692 print("error: temp dir %r already exists" % tmpdir)
1688 return 1
1693 return 1
1689
1694
1690 # Automatically removing tmpdir sounds convenient, but could
1695 # Automatically removing tmpdir sounds convenient, but could
1691 # really annoy anyone in the habit of using "--tmpdir=/tmp"
1696 # really annoy anyone in the habit of using "--tmpdir=/tmp"
1692 # or "--tmpdir=$HOME".
1697 # or "--tmpdir=$HOME".
1693 #vlog("# Removing temp dir", tmpdir)
1698 #vlog("# Removing temp dir", tmpdir)
1694 #shutil.rmtree(tmpdir)
1699 #shutil.rmtree(tmpdir)
1695 os.makedirs(tmpdir)
1700 os.makedirs(tmpdir)
1696 else:
1701 else:
1697 d = None
1702 d = None
1698 if os.name == 'nt':
1703 if os.name == 'nt':
1699 # without this, we get the default temp dir location, but
1704 # without this, we get the default temp dir location, but
1700 # in all lowercase, which causes troubles with paths (issue3490)
1705 # in all lowercase, which causes troubles with paths (issue3490)
1701 d = osenvironb.get(b'TMP', None)
1706 d = osenvironb.get(b'TMP', None)
1702 # FILE BUG: mkdtemp works only on unicode in Python 3
1707 # FILE BUG: mkdtemp works only on unicode in Python 3
1703 tmpdir = tempfile.mkdtemp('', 'hgtests.',
1708 tmpdir = tempfile.mkdtemp('', 'hgtests.',
1704 d and d.decode('utf-8')).encode('utf-8')
1709 d and d.decode('utf-8')).encode('utf-8')
1705
1710
1706 self._hgtmp = osenvironb[b'HGTMP'] = (
1711 self._hgtmp = osenvironb[b'HGTMP'] = (
1707 os.path.realpath(tmpdir))
1712 os.path.realpath(tmpdir))
1708
1713
1709 if self.options.with_hg:
1714 if self.options.with_hg:
1710 self._installdir = None
1715 self._installdir = None
1711 whg = self.options.with_hg
1716 whg = self.options.with_hg
1712 # If --with-hg is not specified, we have bytes already,
1717 # If --with-hg is not specified, we have bytes already,
1713 # but if it was specified in python3 we get a str, so we
1718 # but if it was specified in python3 we get a str, so we
1714 # have to encode it back into a bytes.
1719 # have to encode it back into a bytes.
1715 if sys.version_info[0] == 3:
1720 if sys.version_info[0] == 3:
1716 if not isinstance(whg, bytes):
1721 if not isinstance(whg, bytes):
1717 whg = whg.encode('utf-8')
1722 whg = whg.encode('utf-8')
1718 self._bindir = os.path.dirname(os.path.realpath(whg))
1723 self._bindir = os.path.dirname(os.path.realpath(whg))
1719 assert isinstance(self._bindir, bytes)
1724 assert isinstance(self._bindir, bytes)
1720 self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')
1725 self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')
1721 os.makedirs(self._tmpbindir)
1726 os.makedirs(self._tmpbindir)
1722
1727
1723 # This looks redundant with how Python initializes sys.path from
1728 # This looks redundant with how Python initializes sys.path from
1724 # the location of the script being executed. Needed because the
1729 # the location of the script being executed. Needed because the
1725 # "hg" specified by --with-hg is not the only Python script
1730 # "hg" specified by --with-hg is not the only Python script
1726 # executed in the test suite that needs to import 'mercurial'
1731 # executed in the test suite that needs to import 'mercurial'
1727 # ... which means it's not really redundant at all.
1732 # ... which means it's not really redundant at all.
1728 self._pythondir = self._bindir
1733 self._pythondir = self._bindir
1729 else:
1734 else:
1730 self._installdir = os.path.join(self._hgtmp, b"install")
1735 self._installdir = os.path.join(self._hgtmp, b"install")
1731 self._bindir = osenvironb[b"BINDIR"] = \
1736 self._bindir = osenvironb[b"BINDIR"] = \
1732 os.path.join(self._installdir, b"bin")
1737 os.path.join(self._installdir, b"bin")
1733 self._tmpbindir = self._bindir
1738 self._tmpbindir = self._bindir
1734 self._pythondir = os.path.join(self._installdir, b"lib", b"python")
1739 self._pythondir = os.path.join(self._installdir, b"lib", b"python")
1735
1740
1736 osenvironb[b"BINDIR"] = self._bindir
1741 osenvironb[b"BINDIR"] = self._bindir
1737 os.environ["PYTHON"] = PYTHON
1742 os.environ["PYTHON"] = PYTHON
1738
1743
1739 fileb = __file__.encode('utf-8')
1744 fileb = __file__.encode('utf-8')
1740 runtestdir = os.path.abspath(os.path.dirname(fileb))
1745 runtestdir = os.path.abspath(os.path.dirname(fileb))
1741 if sys.version_info[0] == 3:
1746 if sys.version_info[0] == 3:
1742 sepb = os.pathsep.encode('utf-8')
1747 sepb = os.pathsep.encode('utf-8')
1743 else:
1748 else:
1744 sepb = os.pathsep
1749 sepb = os.pathsep
1745 path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
1750 path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
1746 if os.path.islink(__file__):
1751 if os.path.islink(__file__):
1747 # test helper will likely be at the end of the symlink
1752 # test helper will likely be at the end of the symlink
1748 realfile = os.path.realpath(fileb)
1753 realfile = os.path.realpath(fileb)
1749 realdir = os.path.abspath(os.path.dirname(realfile))
1754 realdir = os.path.abspath(os.path.dirname(realfile))
1750 path.insert(2, realdir)
1755 path.insert(2, realdir)
1751 if self._tmpbindir != self._bindir:
1756 if self._tmpbindir != self._bindir:
1752 path = [self._tmpbindir] + path
1757 path = [self._tmpbindir] + path
1753 osenvironb[b"PATH"] = sepb.join(path)
1758 osenvironb[b"PATH"] = sepb.join(path)
1754
1759
1755 # Include TESTDIR in PYTHONPATH so that out-of-tree extensions
1760 # Include TESTDIR in PYTHONPATH so that out-of-tree extensions
1756 # can run .../tests/run-tests.py test-foo where test-foo
1761 # can run .../tests/run-tests.py test-foo where test-foo
1757 # adds an extension to HGRC. Also include run-test.py directory to
1762 # adds an extension to HGRC. Also include run-test.py directory to
1758 # import modules like heredoctest.
1763 # import modules like heredoctest.
1759 pypath = [self._pythondir, self._testdir, runtestdir]
1764 pypath = [self._pythondir, self._testdir, runtestdir]
1760 # We have to augment PYTHONPATH, rather than simply replacing
1765 # We have to augment PYTHONPATH, rather than simply replacing
1761 # it, in case external libraries are only available via current
1766 # it, in case external libraries are only available via current
1762 # PYTHONPATH. (In particular, the Subversion bindings on OS X
1767 # PYTHONPATH. (In particular, the Subversion bindings on OS X
1763 # are in /opt/subversion.)
1768 # are in /opt/subversion.)
1764 oldpypath = osenvironb.get(IMPL_PATH)
1769 oldpypath = osenvironb.get(IMPL_PATH)
1765 if oldpypath:
1770 if oldpypath:
1766 pypath.append(oldpypath)
1771 pypath.append(oldpypath)
1767 osenvironb[IMPL_PATH] = sepb.join(pypath)
1772 osenvironb[IMPL_PATH] = sepb.join(pypath)
1768
1773
1769 if self.options.pure:
1774 if self.options.pure:
1770 os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"
1775 os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"
1771
1776
1772 self._coveragefile = os.path.join(self._testdir, b'.coverage')
1777 self._coveragefile = os.path.join(self._testdir, b'.coverage')
1773
1778
1774 vlog("# Using TESTDIR", self._testdir)
1779 vlog("# Using TESTDIR", self._testdir)
1775 vlog("# Using HGTMP", self._hgtmp)
1780 vlog("# Using HGTMP", self._hgtmp)
1776 vlog("# Using PATH", os.environ["PATH"])
1781 vlog("# Using PATH", os.environ["PATH"])
1777 vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH])
1782 vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH])
1778
1783
1779 try:
1784 try:
1780 return self._runtests(tests) or 0
1785 return self._runtests(tests) or 0
1781 finally:
1786 finally:
1782 time.sleep(.1)
1787 time.sleep(.1)
1783 self._cleanup()
1788 self._cleanup()
1784
1789
1785 def findtests(self, args):
1790 def findtests(self, args):
1786 """Finds possible test files from arguments.
1791 """Finds possible test files from arguments.
1787
1792
1788 If you wish to inject custom tests into the test harness, this would
1793 If you wish to inject custom tests into the test harness, this would
1789 be a good function to monkeypatch or override in a derived class.
1794 be a good function to monkeypatch or override in a derived class.
1790 """
1795 """
1791 if not args:
1796 if not args:
1792 if self.options.changed:
1797 if self.options.changed:
1793 proc = Popen4('hg st --rev "%s" -man0 .' %
1798 proc = Popen4('hg st --rev "%s" -man0 .' %
1794 self.options.changed, None, 0)
1799 self.options.changed, None, 0)
1795 stdout, stderr = proc.communicate()
1800 stdout, stderr = proc.communicate()
1796 args = stdout.strip(b'\0').split(b'\0')
1801 args = stdout.strip(b'\0').split(b'\0')
1797 else:
1802 else:
1798 args = os.listdir(b'.')
1803 args = os.listdir(b'.')
1799
1804
1800 return [t for t in args
1805 return [t for t in args
1801 if os.path.basename(t).startswith(b'test-')
1806 if os.path.basename(t).startswith(b'test-')
1802 and (t.endswith(b'.py') or t.endswith(b'.t'))]
1807 and (t.endswith(b'.py') or t.endswith(b'.t'))]
1803
1808
1804 def _runtests(self, tests):
1809 def _runtests(self, tests):
1805 try:
1810 try:
1806 if self._installdir:
1811 if self._installdir:
1807 self._installhg()
1812 self._installhg()
1808 self._checkhglib("Testing")
1813 self._checkhglib("Testing")
1809 else:
1814 else:
1810 self._usecorrectpython()
1815 self._usecorrectpython()
1811
1816
1812 if self.options.restart:
1817 if self.options.restart:
1813 orig = list(tests)
1818 orig = list(tests)
1814 while tests:
1819 while tests:
1815 if os.path.exists(tests[0] + ".err"):
1820 if os.path.exists(tests[0] + ".err"):
1816 break
1821 break
1817 tests.pop(0)
1822 tests.pop(0)
1818 if not tests:
1823 if not tests:
1819 print("running all tests")
1824 print("running all tests")
1820 tests = orig
1825 tests = orig
1821
1826
1822 tests = [self._gettest(t, i) for i, t in enumerate(tests)]
1827 tests = [self._gettest(t, i) for i, t in enumerate(tests)]
1823
1828
1824 failed = False
1829 failed = False
1825 warned = False
1830 warned = False
1826 kws = self.options.keywords
1831 kws = self.options.keywords
1827 if kws is not None and sys.version_info[0] == 3:
1832 if kws is not None and sys.version_info[0] == 3:
1828 kws = kws.encode('utf-8')
1833 kws = kws.encode('utf-8')
1829
1834
1830 suite = TestSuite(self._testdir,
1835 suite = TestSuite(self._testdir,
1831 jobs=self.options.jobs,
1836 jobs=self.options.jobs,
1832 whitelist=self.options.whitelisted,
1837 whitelist=self.options.whitelisted,
1833 blacklist=self.options.blacklist,
1838 blacklist=self.options.blacklist,
1834 retest=self.options.retest,
1839 retest=self.options.retest,
1835 keywords=kws,
1840 keywords=kws,
1836 loop=self.options.loop,
1841 loop=self.options.loop,
1837 runs_per_test=self.options.runs_per_test,
1842 runs_per_test=self.options.runs_per_test,
1838 tests=tests, loadtest=self._gettest)
1843 tests=tests, loadtest=self._gettest)
1839 verbosity = 1
1844 verbosity = 1
1840 if self.options.verbose:
1845 if self.options.verbose:
1841 verbosity = 2
1846 verbosity = 2
1842 runner = TextTestRunner(self, verbosity=verbosity)
1847 runner = TextTestRunner(self, verbosity=verbosity)
1843 result = runner.run(suite)
1848 result = runner.run(suite)
1844
1849
1845 if result.failures:
1850 if result.failures:
1846 failed = True
1851 failed = True
1847 if result.warned:
1852 if result.warned:
1848 warned = True
1853 warned = True
1849
1854
1850 if self.options.anycoverage:
1855 if self.options.anycoverage:
1851 self._outputcoverage()
1856 self._outputcoverage()
1852 except KeyboardInterrupt:
1857 except KeyboardInterrupt:
1853 failed = True
1858 failed = True
1854 print("\ninterrupted!")
1859 print("\ninterrupted!")
1855
1860
1856 if failed:
1861 if failed:
1857 return 1
1862 return 1
1858 if warned:
1863 if warned:
1859 return 80
1864 return 80
1860
1865
1861 def _getport(self, count):
1866 def _getport(self, count):
1862 port = self._ports.get(count) # do we have a cached entry?
1867 port = self._ports.get(count) # do we have a cached entry?
1863 if port is None:
1868 if port is None:
1864 port = self.options.port + self._portoffset
1869 port = self.options.port + self._portoffset
1865 portneeded = 3
1870 portneeded = 3
1866 # above 100 tries we just give up and let test reports failure
1871 # above 100 tries we just give up and let test reports failure
1867 for tries in xrange(100):
1872 for tries in xrange(100):
1868 allfree = True
1873 allfree = True
1869 for idx in xrange(portneeded):
1874 for idx in xrange(portneeded):
1870 if not checkportisavailable(port + idx):
1875 if not checkportisavailable(port + idx):
1871 allfree = False
1876 allfree = False
1872 break
1877 break
1873 self._portoffset += portneeded
1878 self._portoffset += portneeded
1874 if allfree:
1879 if allfree:
1875 break
1880 break
1876 self._ports[count] = port
1881 self._ports[count] = port
1877 return port
1882 return port
1878
1883
1879 def _gettest(self, test, count):
1884 def _gettest(self, test, count):
1880 """Obtain a Test by looking at its filename.
1885 """Obtain a Test by looking at its filename.
1881
1886
1882 Returns a Test instance. The Test may not be runnable if it doesn't
1887 Returns a Test instance. The Test may not be runnable if it doesn't
1883 map to a known type.
1888 map to a known type.
1884 """
1889 """
1885 lctest = test.lower()
1890 lctest = test.lower()
1886 testcls = Test
1891 testcls = Test
1887
1892
1888 for ext, cls in self.TESTTYPES:
1893 for ext, cls in self.TESTTYPES:
1889 if lctest.endswith(ext):
1894 if lctest.endswith(ext):
1890 testcls = cls
1895 testcls = cls
1891 break
1896 break
1892
1897
1893 refpath = os.path.join(self._testdir, test)
1898 refpath = os.path.join(self._testdir, test)
1894 tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
1899 tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
1895
1900
1896 t = testcls(refpath, tmpdir,
1901 t = testcls(refpath, tmpdir,
1897 keeptmpdir=self.options.keep_tmpdir,
1902 keeptmpdir=self.options.keep_tmpdir,
1898 debug=self.options.debug,
1903 debug=self.options.debug,
1899 timeout=self.options.timeout,
1904 timeout=self.options.timeout,
1900 startport=self._getport(count),
1905 startport=self._getport(count),
1901 extraconfigopts=self.options.extra_config_opt,
1906 extraconfigopts=self.options.extra_config_opt,
1902 py3kwarnings=self.options.py3k_warnings,
1907 py3kwarnings=self.options.py3k_warnings,
1903 shell=self.options.shell)
1908 shell=self.options.shell)
1904 t.should_reload = True
1909 t.should_reload = True
1905 return t
1910 return t
1906
1911
1907 def _cleanup(self):
1912 def _cleanup(self):
1908 """Clean up state from this test invocation."""
1913 """Clean up state from this test invocation."""
1909
1914
1910 if self.options.keep_tmpdir:
1915 if self.options.keep_tmpdir:
1911 return
1916 return
1912
1917
1913 vlog("# Cleaning up HGTMP", self._hgtmp)
1918 vlog("# Cleaning up HGTMP", self._hgtmp)
1914 shutil.rmtree(self._hgtmp, True)
1919 shutil.rmtree(self._hgtmp, True)
1915 for f in self._createdfiles:
1920 for f in self._createdfiles:
1916 try:
1921 try:
1917 os.remove(f)
1922 os.remove(f)
1918 except OSError:
1923 except OSError:
1919 pass
1924 pass
1920
1925
1921 def _usecorrectpython(self):
1926 def _usecorrectpython(self):
1922 """Configure the environment to use the appropriate Python in tests."""
1927 """Configure the environment to use the appropriate Python in tests."""
1923 # Tests must use the same interpreter as us or bad things will happen.
1928 # Tests must use the same interpreter as us or bad things will happen.
1924 pyexename = sys.platform == 'win32' and b'python.exe' or b'python'
1929 pyexename = sys.platform == 'win32' and b'python.exe' or b'python'
1925 if getattr(os, 'symlink', None):
1930 if getattr(os, 'symlink', None):
1926 vlog("# Making python executable in test path a symlink to '%s'" %
1931 vlog("# Making python executable in test path a symlink to '%s'" %
1927 sys.executable)
1932 sys.executable)
1928 mypython = os.path.join(self._tmpbindir, pyexename)
1933 mypython = os.path.join(self._tmpbindir, pyexename)
1929 try:
1934 try:
1930 if os.readlink(mypython) == sys.executable:
1935 if os.readlink(mypython) == sys.executable:
1931 return
1936 return
1932 os.unlink(mypython)
1937 os.unlink(mypython)
1933 except OSError as err:
1938 except OSError as err:
1934 if err.errno != errno.ENOENT:
1939 if err.errno != errno.ENOENT:
1935 raise
1940 raise
1936 if self._findprogram(pyexename) != sys.executable:
1941 if self._findprogram(pyexename) != sys.executable:
1937 try:
1942 try:
1938 os.symlink(sys.executable, mypython)
1943 os.symlink(sys.executable, mypython)
1939 self._createdfiles.append(mypython)
1944 self._createdfiles.append(mypython)
1940 except OSError as err:
1945 except OSError as err:
1941 # child processes may race, which is harmless
1946 # child processes may race, which is harmless
1942 if err.errno != errno.EEXIST:
1947 if err.errno != errno.EEXIST:
1943 raise
1948 raise
1944 else:
1949 else:
1945 exedir, exename = os.path.split(sys.executable)
1950 exedir, exename = os.path.split(sys.executable)
1946 vlog("# Modifying search path to find %s as %s in '%s'" %
1951 vlog("# Modifying search path to find %s as %s in '%s'" %
1947 (exename, pyexename, exedir))
1952 (exename, pyexename, exedir))
1948 path = os.environ['PATH'].split(os.pathsep)
1953 path = os.environ['PATH'].split(os.pathsep)
1949 while exedir in path:
1954 while exedir in path:
1950 path.remove(exedir)
1955 path.remove(exedir)
1951 os.environ['PATH'] = os.pathsep.join([exedir] + path)
1956 os.environ['PATH'] = os.pathsep.join([exedir] + path)
1952 if not self._findprogram(pyexename):
1957 if not self._findprogram(pyexename):
1953 print("WARNING: Cannot find %s in search path" % pyexename)
1958 print("WARNING: Cannot find %s in search path" % pyexename)
1954
1959
1955 def _installhg(self):
1960 def _installhg(self):
1956 """Install hg into the test environment.
1961 """Install hg into the test environment.
1957
1962
1958 This will also configure hg with the appropriate testing settings.
1963 This will also configure hg with the appropriate testing settings.
1959 """
1964 """
1960 vlog("# Performing temporary installation of HG")
1965 vlog("# Performing temporary installation of HG")
1961 installerrs = os.path.join(b"tests", b"install.err")
1966 installerrs = os.path.join(b"tests", b"install.err")
1962 compiler = ''
1967 compiler = ''
1963 if self.options.compiler:
1968 if self.options.compiler:
1964 compiler = '--compiler ' + self.options.compiler
1969 compiler = '--compiler ' + self.options.compiler
1965 if self.options.pure:
1970 if self.options.pure:
1966 pure = b"--pure"
1971 pure = b"--pure"
1967 else:
1972 else:
1968 pure = b""
1973 pure = b""
1969 py3 = ''
1974 py3 = ''
1970
1975
1971 # Run installer in hg root
1976 # Run installer in hg root
1972 script = os.path.realpath(sys.argv[0])
1977 script = os.path.realpath(sys.argv[0])
1973 exe = sys.executable
1978 exe = sys.executable
1974 if sys.version_info[0] == 3:
1979 if sys.version_info[0] == 3:
1975 py3 = b'--c2to3'
1980 py3 = b'--c2to3'
1976 compiler = compiler.encode('utf-8')
1981 compiler = compiler.encode('utf-8')
1977 script = script.encode('utf-8')
1982 script = script.encode('utf-8')
1978 exe = exe.encode('utf-8')
1983 exe = exe.encode('utf-8')
1979 hgroot = os.path.dirname(os.path.dirname(script))
1984 hgroot = os.path.dirname(os.path.dirname(script))
1980 self._hgroot = hgroot
1985 self._hgroot = hgroot
1981 os.chdir(hgroot)
1986 os.chdir(hgroot)
1982 nohome = b'--home=""'
1987 nohome = b'--home=""'
1983 if os.name == 'nt':
1988 if os.name == 'nt':
1984 # The --home="" trick works only on OS where os.sep == '/'
1989 # The --home="" trick works only on OS where os.sep == '/'
1985 # because of a distutils convert_path() fast-path. Avoid it at
1990 # because of a distutils convert_path() fast-path. Avoid it at
1986 # least on Windows for now, deal with .pydistutils.cfg bugs
1991 # least on Windows for now, deal with .pydistutils.cfg bugs
1987 # when they happen.
1992 # when they happen.
1988 nohome = b''
1993 nohome = b''
1989 cmd = (b'%(exe)s setup.py %(py3)s %(pure)s clean --all'
1994 cmd = (b'%(exe)s setup.py %(py3)s %(pure)s clean --all'
1990 b' build %(compiler)s --build-base="%(base)s"'
1995 b' build %(compiler)s --build-base="%(base)s"'
1991 b' install --force --prefix="%(prefix)s"'
1996 b' install --force --prefix="%(prefix)s"'
1992 b' --install-lib="%(libdir)s"'
1997 b' --install-lib="%(libdir)s"'
1993 b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'
1998 b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'
1994 % {b'exe': exe, b'py3': py3, b'pure': pure,
1999 % {b'exe': exe, b'py3': py3, b'pure': pure,
1995 b'compiler': compiler,
2000 b'compiler': compiler,
1996 b'base': os.path.join(self._hgtmp, b"build"),
2001 b'base': os.path.join(self._hgtmp, b"build"),
1997 b'prefix': self._installdir, b'libdir': self._pythondir,
2002 b'prefix': self._installdir, b'libdir': self._pythondir,
1998 b'bindir': self._bindir,
2003 b'bindir': self._bindir,
1999 b'nohome': nohome, b'logfile': installerrs})
2004 b'nohome': nohome, b'logfile': installerrs})
2000
2005
2001 # setuptools requires install directories to exist.
2006 # setuptools requires install directories to exist.
2002 def makedirs(p):
2007 def makedirs(p):
2003 try:
2008 try:
2004 os.makedirs(p)
2009 os.makedirs(p)
2005 except OSError as e:
2010 except OSError as e:
2006 if e.errno != errno.EEXIST:
2011 if e.errno != errno.EEXIST:
2007 raise
2012 raise
2008 makedirs(self._pythondir)
2013 makedirs(self._pythondir)
2009 makedirs(self._bindir)
2014 makedirs(self._bindir)
2010
2015
2011 vlog("# Running", cmd)
2016 vlog("# Running", cmd)
2012 if os.system(cmd) == 0:
2017 if os.system(cmd) == 0:
2013 if not self.options.verbose:
2018 if not self.options.verbose:
2014 os.remove(installerrs)
2019 os.remove(installerrs)
2015 else:
2020 else:
2016 f = open(installerrs, 'rb')
2021 f = open(installerrs, 'rb')
2017 for line in f:
2022 for line in f:
2018 if sys.version_info[0] > 2:
2023 if sys.version_info[0] > 2:
2019 sys.stdout.buffer.write(line)
2024 sys.stdout.buffer.write(line)
2020 else:
2025 else:
2021 sys.stdout.write(line)
2026 sys.stdout.write(line)
2022 f.close()
2027 f.close()
2023 sys.exit(1)
2028 sys.exit(1)
2024 os.chdir(self._testdir)
2029 os.chdir(self._testdir)
2025
2030
2026 self._usecorrectpython()
2031 self._usecorrectpython()
2027
2032
2028 if self.options.py3k_warnings and not self.options.anycoverage:
2033 if self.options.py3k_warnings and not self.options.anycoverage:
2029 vlog("# Updating hg command to enable Py3k Warnings switch")
2034 vlog("# Updating hg command to enable Py3k Warnings switch")
2030 f = open(os.path.join(self._bindir, 'hg'), 'rb')
2035 f = open(os.path.join(self._bindir, 'hg'), 'rb')
2031 lines = [line.rstrip() for line in f]
2036 lines = [line.rstrip() for line in f]
2032 lines[0] += ' -3'
2037 lines[0] += ' -3'
2033 f.close()
2038 f.close()
2034 f = open(os.path.join(self._bindir, 'hg'), 'wb')
2039 f = open(os.path.join(self._bindir, 'hg'), 'wb')
2035 for line in lines:
2040 for line in lines:
2036 f.write(line + '\n')
2041 f.write(line + '\n')
2037 f.close()
2042 f.close()
2038
2043
2039 hgbat = os.path.join(self._bindir, b'hg.bat')
2044 hgbat = os.path.join(self._bindir, b'hg.bat')
2040 if os.path.isfile(hgbat):
2045 if os.path.isfile(hgbat):
2041 # hg.bat expects to be put in bin/scripts while run-tests.py
2046 # hg.bat expects to be put in bin/scripts while run-tests.py
2042 # installation layout put it in bin/ directly. Fix it
2047 # installation layout put it in bin/ directly. Fix it
2043 f = open(hgbat, 'rb')
2048 f = open(hgbat, 'rb')
2044 data = f.read()
2049 data = f.read()
2045 f.close()
2050 f.close()
2046 if b'"%~dp0..\python" "%~dp0hg" %*' in data:
2051 if b'"%~dp0..\python" "%~dp0hg" %*' in data:
2047 data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*',
2052 data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*',
2048 b'"%~dp0python" "%~dp0hg" %*')
2053 b'"%~dp0python" "%~dp0hg" %*')
2049 f = open(hgbat, 'wb')
2054 f = open(hgbat, 'wb')
2050 f.write(data)
2055 f.write(data)
2051 f.close()
2056 f.close()
2052 else:
2057 else:
2053 print('WARNING: cannot fix hg.bat reference to python.exe')
2058 print('WARNING: cannot fix hg.bat reference to python.exe')
2054
2059
2055 if self.options.anycoverage:
2060 if self.options.anycoverage:
2056 custom = os.path.join(self._testdir, 'sitecustomize.py')
2061 custom = os.path.join(self._testdir, 'sitecustomize.py')
2057 target = os.path.join(self._pythondir, 'sitecustomize.py')
2062 target = os.path.join(self._pythondir, 'sitecustomize.py')
2058 vlog('# Installing coverage trigger to %s' % target)
2063 vlog('# Installing coverage trigger to %s' % target)
2059 shutil.copyfile(custom, target)
2064 shutil.copyfile(custom, target)
2060 rc = os.path.join(self._testdir, '.coveragerc')
2065 rc = os.path.join(self._testdir, '.coveragerc')
2061 vlog('# Installing coverage rc to %s' % rc)
2066 vlog('# Installing coverage rc to %s' % rc)
2062 os.environ['COVERAGE_PROCESS_START'] = rc
2067 os.environ['COVERAGE_PROCESS_START'] = rc
2063 covdir = os.path.join(self._installdir, '..', 'coverage')
2068 covdir = os.path.join(self._installdir, '..', 'coverage')
2064 try:
2069 try:
2065 os.mkdir(covdir)
2070 os.mkdir(covdir)
2066 except OSError as e:
2071 except OSError as e:
2067 if e.errno != errno.EEXIST:
2072 if e.errno != errno.EEXIST:
2068 raise
2073 raise
2069
2074
2070 os.environ['COVERAGE_DIR'] = covdir
2075 os.environ['COVERAGE_DIR'] = covdir
2071
2076
2072 def _checkhglib(self, verb):
2077 def _checkhglib(self, verb):
2073 """Ensure that the 'mercurial' package imported by python is
2078 """Ensure that the 'mercurial' package imported by python is
2074 the one we expect it to be. If not, print a warning to stderr."""
2079 the one we expect it to be. If not, print a warning to stderr."""
2075 if ((self._bindir == self._pythondir) and
2080 if ((self._bindir == self._pythondir) and
2076 (self._bindir != self._tmpbindir)):
2081 (self._bindir != self._tmpbindir)):
2077 # The pythondir has been inferred from --with-hg flag.
2082 # The pythondir has been inferred from --with-hg flag.
2078 # We cannot expect anything sensible here.
2083 # We cannot expect anything sensible here.
2079 return
2084 return
2080 expecthg = os.path.join(self._pythondir, b'mercurial')
2085 expecthg = os.path.join(self._pythondir, b'mercurial')
2081 actualhg = self._gethgpath()
2086 actualhg = self._gethgpath()
2082 if os.path.abspath(actualhg) != os.path.abspath(expecthg):
2087 if os.path.abspath(actualhg) != os.path.abspath(expecthg):
2083 sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n'
2088 sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n'
2084 ' (expected %s)\n'
2089 ' (expected %s)\n'
2085 % (verb, actualhg, expecthg))
2090 % (verb, actualhg, expecthg))
2086 def _gethgpath(self):
2091 def _gethgpath(self):
2087 """Return the path to the mercurial package that is actually found by
2092 """Return the path to the mercurial package that is actually found by
2088 the current Python interpreter."""
2093 the current Python interpreter."""
2089 if self._hgpath is not None:
2094 if self._hgpath is not None:
2090 return self._hgpath
2095 return self._hgpath
2091
2096
2092 cmd = '%s -c "import mercurial; print (mercurial.__path__[0])"'
2097 cmd = '%s -c "import mercurial; print (mercurial.__path__[0])"'
2093 pipe = os.popen(cmd % PYTHON)
2098 pipe = os.popen(cmd % PYTHON)
2094 try:
2099 try:
2095 self._hgpath = pipe.read().strip()
2100 self._hgpath = pipe.read().strip()
2096 finally:
2101 finally:
2097 pipe.close()
2102 pipe.close()
2098
2103
2099 return self._hgpath
2104 return self._hgpath
2100
2105
2101 def _outputcoverage(self):
2106 def _outputcoverage(self):
2102 """Produce code coverage output."""
2107 """Produce code coverage output."""
2103 from coverage import coverage
2108 from coverage import coverage
2104
2109
2105 vlog('# Producing coverage report')
2110 vlog('# Producing coverage report')
2106 # chdir is the easiest way to get short, relative paths in the
2111 # chdir is the easiest way to get short, relative paths in the
2107 # output.
2112 # output.
2108 os.chdir(self._hgroot)
2113 os.chdir(self._hgroot)
2109 covdir = os.path.join(self._installdir, '..', 'coverage')
2114 covdir = os.path.join(self._installdir, '..', 'coverage')
2110 cov = coverage(data_file=os.path.join(covdir, 'cov'))
2115 cov = coverage(data_file=os.path.join(covdir, 'cov'))
2111
2116
2112 # Map install directory paths back to source directory.
2117 # Map install directory paths back to source directory.
2113 cov.config.paths['srcdir'] = ['.', self._pythondir]
2118 cov.config.paths['srcdir'] = ['.', self._pythondir]
2114
2119
2115 cov.combine()
2120 cov.combine()
2116
2121
2117 omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]]
2122 omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]]
2118 cov.report(ignore_errors=True, omit=omit)
2123 cov.report(ignore_errors=True, omit=omit)
2119
2124
2120 if self.options.htmlcov:
2125 if self.options.htmlcov:
2121 htmldir = os.path.join(self._testdir, 'htmlcov')
2126 htmldir = os.path.join(self._testdir, 'htmlcov')
2122 cov.html_report(directory=htmldir, omit=omit)
2127 cov.html_report(directory=htmldir, omit=omit)
2123 if self.options.annotate:
2128 if self.options.annotate:
2124 adir = os.path.join(self._testdir, 'annotated')
2129 adir = os.path.join(self._testdir, 'annotated')
2125 if not os.path.isdir(adir):
2130 if not os.path.isdir(adir):
2126 os.mkdir(adir)
2131 os.mkdir(adir)
2127 cov.annotate(directory=adir, omit=omit)
2132 cov.annotate(directory=adir, omit=omit)
2128
2133
2129 def _findprogram(self, program):
2134 def _findprogram(self, program):
2130 """Search PATH for a executable program"""
2135 """Search PATH for a executable program"""
2131 if sys.version_info[0] > 2:
2136 if sys.version_info[0] > 2:
2132 dpb = os.defpath.encode('utf-8')
2137 dpb = os.defpath.encode('utf-8')
2133 sepb = os.pathsep.encode('utf-8')
2138 sepb = os.pathsep.encode('utf-8')
2134 else:
2139 else:
2135 dpb = os.defpath
2140 dpb = os.defpath
2136 sepb = os.pathsep
2141 sepb = os.pathsep
2137 for p in osenvironb.get(b'PATH', dpb).split(sepb):
2142 for p in osenvironb.get(b'PATH', dpb).split(sepb):
2138 name = os.path.join(p, program)
2143 name = os.path.join(p, program)
2139 if os.name == 'nt' or os.access(name, os.X_OK):
2144 if os.name == 'nt' or os.access(name, os.X_OK):
2140 return name
2145 return name
2141 return None
2146 return None
2142
2147
2143 def _checktools(self):
2148 def _checktools(self):
2144 """Ensure tools required to run tests are present."""
2149 """Ensure tools required to run tests are present."""
2145 for p in self.REQUIREDTOOLS:
2150 for p in self.REQUIREDTOOLS:
2146 if os.name == 'nt' and not p.endswith('.exe'):
2151 if os.name == 'nt' and not p.endswith('.exe'):
2147 p += '.exe'
2152 p += '.exe'
2148 found = self._findprogram(p)
2153 found = self._findprogram(p)
2149 if found:
2154 if found:
2150 vlog("# Found prerequisite", p, "at", found)
2155 vlog("# Found prerequisite", p, "at", found)
2151 else:
2156 else:
2152 print("WARNING: Did not find prerequisite tool: %s " % p)
2157 print("WARNING: Did not find prerequisite tool: %s " % p)
2153
2158
2154 if __name__ == '__main__':
2159 if __name__ == '__main__':
2155 runner = TestRunner()
2160 runner = TestRunner()
2156
2161
2157 try:
2162 try:
2158 import msvcrt
2163 import msvcrt
2159 msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
2164 msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
2160 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
2165 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
2161 msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
2166 msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
2162 except ImportError:
2167 except ImportError:
2163 pass
2168 pass
2164
2169
2165 sys.exit(runner.run(sys.argv[1:]))
2170 sys.exit(runner.run(sys.argv[1:]))
General Comments 0
You need to be logged in to leave comments. Login now