Show More
@@ -1,3315 +1,3316 b'' | |||||
1 | #!/usr/bin/env python |
|
1 | #!/usr/bin/env python | |
2 | # |
|
2 | # | |
3 | # run-tests.py - Run a set of tests on Mercurial |
|
3 | # run-tests.py - Run a set of tests on Mercurial | |
4 | # |
|
4 | # | |
5 | # Copyright 2006 Matt Mackall <mpm@selenic.com> |
|
5 | # Copyright 2006 Matt Mackall <mpm@selenic.com> | |
6 | # |
|
6 | # | |
7 | # This software may be used and distributed according to the terms of the |
|
7 | # This software may be used and distributed according to the terms of the | |
8 | # GNU General Public License version 2 or any later version. |
|
8 | # GNU General Public License version 2 or any later version. | |
9 |
|
9 | |||
10 | # Modifying this script is tricky because it has many modes: |
|
10 | # Modifying this script is tricky because it has many modes: | |
11 | # - serial (default) vs parallel (-jN, N > 1) |
|
11 | # - serial (default) vs parallel (-jN, N > 1) | |
12 | # - no coverage (default) vs coverage (-c, -C, -s) |
|
12 | # - no coverage (default) vs coverage (-c, -C, -s) | |
13 | # - temp install (default) vs specific hg script (--with-hg, --local) |
|
13 | # - temp install (default) vs specific hg script (--with-hg, --local) | |
14 | # - tests are a mix of shell scripts and Python scripts |
|
14 | # - tests are a mix of shell scripts and Python scripts | |
15 | # |
|
15 | # | |
16 | # If you change this script, it is recommended that you ensure you |
|
16 | # If you change this script, it is recommended that you ensure you | |
17 | # haven't broken it by running it in various modes with a representative |
|
17 | # haven't broken it by running it in various modes with a representative | |
18 | # sample of test scripts. For example: |
|
18 | # sample of test scripts. For example: | |
19 | # |
|
19 | # | |
20 | # 1) serial, no coverage, temp install: |
|
20 | # 1) serial, no coverage, temp install: | |
21 | # ./run-tests.py test-s* |
|
21 | # ./run-tests.py test-s* | |
22 | # 2) serial, no coverage, local hg: |
|
22 | # 2) serial, no coverage, local hg: | |
23 | # ./run-tests.py --local test-s* |
|
23 | # ./run-tests.py --local test-s* | |
24 | # 3) serial, coverage, temp install: |
|
24 | # 3) serial, coverage, temp install: | |
25 | # ./run-tests.py -c test-s* |
|
25 | # ./run-tests.py -c test-s* | |
26 | # 4) serial, coverage, local hg: |
|
26 | # 4) serial, coverage, local hg: | |
27 | # ./run-tests.py -c --local test-s* # unsupported |
|
27 | # ./run-tests.py -c --local test-s* # unsupported | |
28 | # 5) parallel, no coverage, temp install: |
|
28 | # 5) parallel, no coverage, temp install: | |
29 | # ./run-tests.py -j2 test-s* |
|
29 | # ./run-tests.py -j2 test-s* | |
30 | # 6) parallel, no coverage, local hg: |
|
30 | # 6) parallel, no coverage, local hg: | |
31 | # ./run-tests.py -j2 --local test-s* |
|
31 | # ./run-tests.py -j2 --local test-s* | |
32 | # 7) parallel, coverage, temp install: |
|
32 | # 7) parallel, coverage, temp install: | |
33 | # ./run-tests.py -j2 -c test-s* # currently broken |
|
33 | # ./run-tests.py -j2 -c test-s* # currently broken | |
34 | # 8) parallel, coverage, local install: |
|
34 | # 8) parallel, coverage, local install: | |
35 | # ./run-tests.py -j2 -c --local test-s* # unsupported (and broken) |
|
35 | # ./run-tests.py -j2 -c --local test-s* # unsupported (and broken) | |
36 | # 9) parallel, custom tmp dir: |
|
36 | # 9) parallel, custom tmp dir: | |
37 | # ./run-tests.py -j2 --tmpdir /tmp/myhgtests |
|
37 | # ./run-tests.py -j2 --tmpdir /tmp/myhgtests | |
38 | # 10) parallel, pure, tests that call run-tests: |
|
38 | # 10) parallel, pure, tests that call run-tests: | |
39 | # ./run-tests.py --pure `grep -l run-tests.py *.t` |
|
39 | # ./run-tests.py --pure `grep -l run-tests.py *.t` | |
40 | # |
|
40 | # | |
41 | # (You could use any subset of the tests: test-s* happens to match |
|
41 | # (You could use any subset of the tests: test-s* happens to match | |
42 | # enough that it's worth doing parallel runs, few enough that it |
|
42 | # enough that it's worth doing parallel runs, few enough that it | |
43 | # completes fairly quickly, includes both shell and Python scripts, and |
|
43 | # completes fairly quickly, includes both shell and Python scripts, and | |
44 | # includes some scripts that run daemon processes.) |
|
44 | # includes some scripts that run daemon processes.) | |
45 |
|
45 | |||
46 | from __future__ import absolute_import, print_function |
|
46 | from __future__ import absolute_import, print_function | |
47 |
|
47 | |||
48 | import argparse |
|
48 | import argparse | |
49 | import collections |
|
49 | import collections | |
50 | import difflib |
|
50 | import difflib | |
51 | import distutils.version as version |
|
51 | import distutils.version as version | |
52 | import errno |
|
52 | import errno | |
53 | import json |
|
53 | import json | |
54 | import multiprocessing |
|
54 | import multiprocessing | |
55 | import os |
|
55 | import os | |
56 | import random |
|
56 | import random | |
57 | import re |
|
57 | import re | |
58 | import shutil |
|
58 | import shutil | |
59 | import signal |
|
59 | import signal | |
60 | import socket |
|
60 | import socket | |
61 | import subprocess |
|
61 | import subprocess | |
62 | import sys |
|
62 | import sys | |
63 | import sysconfig |
|
63 | import sysconfig | |
64 | import tempfile |
|
64 | import tempfile | |
65 | import threading |
|
65 | import threading | |
66 | import time |
|
66 | import time | |
67 | import unittest |
|
67 | import unittest | |
68 | import uuid |
|
68 | import uuid | |
69 | import xml.dom.minidom as minidom |
|
69 | import xml.dom.minidom as minidom | |
70 |
|
70 | |||
71 | try: |
|
71 | try: | |
72 | import Queue as queue |
|
72 | import Queue as queue | |
73 | except ImportError: |
|
73 | except ImportError: | |
74 | import queue |
|
74 | import queue | |
75 |
|
75 | |||
76 | try: |
|
76 | try: | |
77 | import shlex |
|
77 | import shlex | |
78 | shellquote = shlex.quote |
|
78 | shellquote = shlex.quote | |
79 | except (ImportError, AttributeError): |
|
79 | except (ImportError, AttributeError): | |
80 | import pipes |
|
80 | import pipes | |
81 | shellquote = pipes.quote |
|
81 | shellquote = pipes.quote | |
82 |
|
82 | |||
83 | if os.environ.get('RTUNICODEPEDANTRY', False): |
|
83 | if os.environ.get('RTUNICODEPEDANTRY', False): | |
84 | try: |
|
84 | try: | |
85 | reload(sys) |
|
85 | reload(sys) | |
86 | sys.setdefaultencoding("undefined") |
|
86 | sys.setdefaultencoding("undefined") | |
87 | except NameError: |
|
87 | except NameError: | |
88 | pass |
|
88 | pass | |
89 |
|
89 | |||
90 | processlock = threading.Lock() |
|
90 | processlock = threading.Lock() | |
91 |
|
91 | |||
92 | pygmentspresent = False |
|
92 | pygmentspresent = False | |
93 | # ANSI color is unsupported prior to Windows 10 |
|
93 | # ANSI color is unsupported prior to Windows 10 | |
94 | if os.name != 'nt': |
|
94 | if os.name != 'nt': | |
95 | try: # is pygments installed |
|
95 | try: # is pygments installed | |
96 | import pygments |
|
96 | import pygments | |
97 | import pygments.lexers as lexers |
|
97 | import pygments.lexers as lexers | |
98 | import pygments.lexer as lexer |
|
98 | import pygments.lexer as lexer | |
99 | import pygments.formatters as formatters |
|
99 | import pygments.formatters as formatters | |
100 | import pygments.token as token |
|
100 | import pygments.token as token | |
101 | import pygments.style as style |
|
101 | import pygments.style as style | |
102 | pygmentspresent = True |
|
102 | pygmentspresent = True | |
103 | difflexer = lexers.DiffLexer() |
|
103 | difflexer = lexers.DiffLexer() | |
104 | terminal256formatter = formatters.Terminal256Formatter() |
|
104 | terminal256formatter = formatters.Terminal256Formatter() | |
105 | except ImportError: |
|
105 | except ImportError: | |
106 | pass |
|
106 | pass | |
107 |
|
107 | |||
108 | if pygmentspresent: |
|
108 | if pygmentspresent: | |
109 | class TestRunnerStyle(style.Style): |
|
109 | class TestRunnerStyle(style.Style): | |
110 | default_style = "" |
|
110 | default_style = "" | |
111 | skipped = token.string_to_tokentype("Token.Generic.Skipped") |
|
111 | skipped = token.string_to_tokentype("Token.Generic.Skipped") | |
112 | failed = token.string_to_tokentype("Token.Generic.Failed") |
|
112 | failed = token.string_to_tokentype("Token.Generic.Failed") | |
113 | skippedname = token.string_to_tokentype("Token.Generic.SName") |
|
113 | skippedname = token.string_to_tokentype("Token.Generic.SName") | |
114 | failedname = token.string_to_tokentype("Token.Generic.FName") |
|
114 | failedname = token.string_to_tokentype("Token.Generic.FName") | |
115 | styles = { |
|
115 | styles = { | |
116 | skipped: '#e5e5e5', |
|
116 | skipped: '#e5e5e5', | |
117 | skippedname: '#00ffff', |
|
117 | skippedname: '#00ffff', | |
118 | failed: '#7f0000', |
|
118 | failed: '#7f0000', | |
119 | failedname: '#ff0000', |
|
119 | failedname: '#ff0000', | |
120 | } |
|
120 | } | |
121 |
|
121 | |||
122 | class TestRunnerLexer(lexer.RegexLexer): |
|
122 | class TestRunnerLexer(lexer.RegexLexer): | |
123 | testpattern = r'[\w-]+\.(t|py)(#[a-zA-Z0-9_\-\.]+)?' |
|
123 | testpattern = r'[\w-]+\.(t|py)(#[a-zA-Z0-9_\-\.]+)?' | |
124 | tokens = { |
|
124 | tokens = { | |
125 | 'root': [ |
|
125 | 'root': [ | |
126 | (r'^Skipped', token.Generic.Skipped, 'skipped'), |
|
126 | (r'^Skipped', token.Generic.Skipped, 'skipped'), | |
127 | (r'^Failed ', token.Generic.Failed, 'failed'), |
|
127 | (r'^Failed ', token.Generic.Failed, 'failed'), | |
128 | (r'^ERROR: ', token.Generic.Failed, 'failed'), |
|
128 | (r'^ERROR: ', token.Generic.Failed, 'failed'), | |
129 | ], |
|
129 | ], | |
130 | 'skipped': [ |
|
130 | 'skipped': [ | |
131 | (testpattern, token.Generic.SName), |
|
131 | (testpattern, token.Generic.SName), | |
132 | (r':.*', token.Generic.Skipped), |
|
132 | (r':.*', token.Generic.Skipped), | |
133 | ], |
|
133 | ], | |
134 | 'failed': [ |
|
134 | 'failed': [ | |
135 | (testpattern, token.Generic.FName), |
|
135 | (testpattern, token.Generic.FName), | |
136 | (r'(:| ).*', token.Generic.Failed), |
|
136 | (r'(:| ).*', token.Generic.Failed), | |
137 | ] |
|
137 | ] | |
138 | } |
|
138 | } | |
139 |
|
139 | |||
140 | runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle) |
|
140 | runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle) | |
141 | runnerlexer = TestRunnerLexer() |
|
141 | runnerlexer = TestRunnerLexer() | |
142 |
|
142 | |||
143 | origenviron = os.environ.copy() |
|
143 | origenviron = os.environ.copy() | |
144 |
|
144 | |||
145 | if sys.version_info > (3, 5, 0): |
|
145 | if sys.version_info > (3, 5, 0): | |
146 | PYTHON3 = True |
|
146 | PYTHON3 = True | |
147 | xrange = range # we use xrange in one place, and we'd rather not use range |
|
147 | xrange = range # we use xrange in one place, and we'd rather not use range | |
148 | def _bytespath(p): |
|
148 | def _bytespath(p): | |
149 | if p is None: |
|
149 | if p is None: | |
150 | return p |
|
150 | return p | |
151 | return p.encode('utf-8') |
|
151 | return p.encode('utf-8') | |
152 |
|
152 | |||
153 | def _strpath(p): |
|
153 | def _strpath(p): | |
154 | if p is None: |
|
154 | if p is None: | |
155 | return p |
|
155 | return p | |
156 | return p.decode('utf-8') |
|
156 | return p.decode('utf-8') | |
157 |
|
157 | |||
158 | osenvironb = getattr(os, 'environb', None) |
|
158 | osenvironb = getattr(os, 'environb', None) | |
159 | if osenvironb is None: |
|
159 | if osenvironb is None: | |
160 | # Windows lacks os.environb, for instance. A proxy over the real thing |
|
160 | # Windows lacks os.environb, for instance. A proxy over the real thing | |
161 | # instead of a copy allows the environment to be updated via bytes on |
|
161 | # instead of a copy allows the environment to be updated via bytes on | |
162 | # all platforms. |
|
162 | # all platforms. | |
163 | class environbytes(object): |
|
163 | class environbytes(object): | |
164 | def __init__(self, strenv): |
|
164 | def __init__(self, strenv): | |
165 | self.__len__ = strenv.__len__ |
|
165 | self.__len__ = strenv.__len__ | |
166 | self.clear = strenv.clear |
|
166 | self.clear = strenv.clear | |
167 | self._strenv = strenv |
|
167 | self._strenv = strenv | |
168 | def __getitem__(self, k): |
|
168 | def __getitem__(self, k): | |
169 | v = self._strenv.__getitem__(_strpath(k)) |
|
169 | v = self._strenv.__getitem__(_strpath(k)) | |
170 | return _bytespath(v) |
|
170 | return _bytespath(v) | |
171 | def __setitem__(self, k, v): |
|
171 | def __setitem__(self, k, v): | |
172 | self._strenv.__setitem__(_strpath(k), _strpath(v)) |
|
172 | self._strenv.__setitem__(_strpath(k), _strpath(v)) | |
173 | def __delitem__(self, k): |
|
173 | def __delitem__(self, k): | |
174 | self._strenv.__delitem__(_strpath(k)) |
|
174 | self._strenv.__delitem__(_strpath(k)) | |
175 | def __contains__(self, k): |
|
175 | def __contains__(self, k): | |
176 | return self._strenv.__contains__(_strpath(k)) |
|
176 | return self._strenv.__contains__(_strpath(k)) | |
177 | def __iter__(self): |
|
177 | def __iter__(self): | |
178 | return iter([_bytespath(k) for k in iter(self._strenv)]) |
|
178 | return iter([_bytespath(k) for k in iter(self._strenv)]) | |
179 | def get(self, k, default=None): |
|
179 | def get(self, k, default=None): | |
180 | v = self._strenv.get(_strpath(k), _strpath(default)) |
|
180 | v = self._strenv.get(_strpath(k), _strpath(default)) | |
181 | return _bytespath(v) |
|
181 | return _bytespath(v) | |
182 | def pop(self, k, default=None): |
|
182 | def pop(self, k, default=None): | |
183 | v = self._strenv.pop(_strpath(k), _strpath(default)) |
|
183 | v = self._strenv.pop(_strpath(k), _strpath(default)) | |
184 | return _bytespath(v) |
|
184 | return _bytespath(v) | |
185 |
|
185 | |||
186 | osenvironb = environbytes(os.environ) |
|
186 | osenvironb = environbytes(os.environ) | |
187 |
|
187 | |||
188 | getcwdb = getattr(os, 'getcwdb') |
|
188 | getcwdb = getattr(os, 'getcwdb') | |
189 | if not getcwdb or os.name == 'nt': |
|
189 | if not getcwdb or os.name == 'nt': | |
190 | getcwdb = lambda: _bytespath(os.getcwd()) |
|
190 | getcwdb = lambda: _bytespath(os.getcwd()) | |
191 |
|
191 | |||
192 | elif sys.version_info >= (3, 0, 0): |
|
192 | elif sys.version_info >= (3, 0, 0): | |
193 | print('%s is only supported on Python 3.5+ and 2.7, not %s' % |
|
193 | print('%s is only supported on Python 3.5+ and 2.7, not %s' % | |
194 | (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3]))) |
|
194 | (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3]))) | |
195 | sys.exit(70) # EX_SOFTWARE from `man 3 sysexit` |
|
195 | sys.exit(70) # EX_SOFTWARE from `man 3 sysexit` | |
196 | else: |
|
196 | else: | |
197 | PYTHON3 = False |
|
197 | PYTHON3 = False | |
198 |
|
198 | |||
199 | # In python 2.x, path operations are generally done using |
|
199 | # In python 2.x, path operations are generally done using | |
200 | # bytestrings by default, so we don't have to do any extra |
|
200 | # bytestrings by default, so we don't have to do any extra | |
201 | # fiddling there. We define the wrapper functions anyway just to |
|
201 | # fiddling there. We define the wrapper functions anyway just to | |
202 | # help keep code consistent between platforms. |
|
202 | # help keep code consistent between platforms. | |
203 | def _bytespath(p): |
|
203 | def _bytespath(p): | |
204 | return p |
|
204 | return p | |
205 |
|
205 | |||
206 | _strpath = _bytespath |
|
206 | _strpath = _bytespath | |
207 | osenvironb = os.environ |
|
207 | osenvironb = os.environ | |
208 | getcwdb = os.getcwd |
|
208 | getcwdb = os.getcwd | |
209 |
|
209 | |||
210 | # For Windows support |
|
210 | # For Windows support | |
211 | wifexited = getattr(os, "WIFEXITED", lambda x: False) |
|
211 | wifexited = getattr(os, "WIFEXITED", lambda x: False) | |
212 |
|
212 | |||
213 | # Whether to use IPv6 |
|
213 | # Whether to use IPv6 | |
214 | def checksocketfamily(name, port=20058): |
|
214 | def checksocketfamily(name, port=20058): | |
215 | """return true if we can listen on localhost using family=name |
|
215 | """return true if we can listen on localhost using family=name | |
216 |
|
216 | |||
217 | name should be either 'AF_INET', or 'AF_INET6'. |
|
217 | name should be either 'AF_INET', or 'AF_INET6'. | |
218 | port being used is okay - EADDRINUSE is considered as successful. |
|
218 | port being used is okay - EADDRINUSE is considered as successful. | |
219 | """ |
|
219 | """ | |
220 | family = getattr(socket, name, None) |
|
220 | family = getattr(socket, name, None) | |
221 | if family is None: |
|
221 | if family is None: | |
222 | return False |
|
222 | return False | |
223 | try: |
|
223 | try: | |
224 | s = socket.socket(family, socket.SOCK_STREAM) |
|
224 | s = socket.socket(family, socket.SOCK_STREAM) | |
225 | s.bind(('localhost', port)) |
|
225 | s.bind(('localhost', port)) | |
226 | s.close() |
|
226 | s.close() | |
227 | return True |
|
227 | return True | |
228 | except socket.error as exc: |
|
228 | except socket.error as exc: | |
229 | if exc.errno == errno.EADDRINUSE: |
|
229 | if exc.errno == errno.EADDRINUSE: | |
230 | return True |
|
230 | return True | |
231 | elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT): |
|
231 | elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT): | |
232 | return False |
|
232 | return False | |
233 | else: |
|
233 | else: | |
234 | raise |
|
234 | raise | |
235 | else: |
|
235 | else: | |
236 | return False |
|
236 | return False | |
237 |
|
237 | |||
238 | # useipv6 will be set by parseargs |
|
238 | # useipv6 will be set by parseargs | |
239 | useipv6 = None |
|
239 | useipv6 = None | |
240 |
|
240 | |||
241 | def checkportisavailable(port): |
|
241 | def checkportisavailable(port): | |
242 | """return true if a port seems free to bind on localhost""" |
|
242 | """return true if a port seems free to bind on localhost""" | |
243 | if useipv6: |
|
243 | if useipv6: | |
244 | family = socket.AF_INET6 |
|
244 | family = socket.AF_INET6 | |
245 | else: |
|
245 | else: | |
246 | family = socket.AF_INET |
|
246 | family = socket.AF_INET | |
247 | try: |
|
247 | try: | |
248 | s = socket.socket(family, socket.SOCK_STREAM) |
|
248 | s = socket.socket(family, socket.SOCK_STREAM) | |
249 | s.bind(('localhost', port)) |
|
249 | s.bind(('localhost', port)) | |
250 | s.close() |
|
250 | s.close() | |
251 | return True |
|
251 | return True | |
252 | except socket.error as exc: |
|
252 | except socket.error as exc: | |
253 | if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL, |
|
253 | if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL, | |
254 | errno.EPROTONOSUPPORT): |
|
254 | errno.EPROTONOSUPPORT): | |
255 | raise |
|
255 | raise | |
256 | return False |
|
256 | return False | |
257 |
|
257 | |||
258 | closefds = os.name == 'posix' |
|
258 | closefds = os.name == 'posix' | |
259 | def Popen4(cmd, wd, timeout, env=None): |
|
259 | def Popen4(cmd, wd, timeout, env=None): | |
260 | processlock.acquire() |
|
260 | processlock.acquire() | |
261 | p = subprocess.Popen(_strpath(cmd), shell=True, bufsize=-1, |
|
261 | p = subprocess.Popen(_strpath(cmd), shell=True, bufsize=-1, | |
262 | cwd=_strpath(wd), env=env, |
|
262 | cwd=_strpath(wd), env=env, | |
263 | close_fds=closefds, |
|
263 | close_fds=closefds, | |
264 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, |
|
264 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, | |
265 | stderr=subprocess.STDOUT) |
|
265 | stderr=subprocess.STDOUT) | |
266 | processlock.release() |
|
266 | processlock.release() | |
267 |
|
267 | |||
268 | p.fromchild = p.stdout |
|
268 | p.fromchild = p.stdout | |
269 | p.tochild = p.stdin |
|
269 | p.tochild = p.stdin | |
270 | p.childerr = p.stderr |
|
270 | p.childerr = p.stderr | |
271 |
|
271 | |||
272 | p.timeout = False |
|
272 | p.timeout = False | |
273 | if timeout: |
|
273 | if timeout: | |
274 | def t(): |
|
274 | def t(): | |
275 | start = time.time() |
|
275 | start = time.time() | |
276 | while time.time() - start < timeout and p.returncode is None: |
|
276 | while time.time() - start < timeout and p.returncode is None: | |
277 | time.sleep(.1) |
|
277 | time.sleep(.1) | |
278 | p.timeout = True |
|
278 | p.timeout = True | |
279 | if p.returncode is None: |
|
279 | if p.returncode is None: | |
280 | terminate(p) |
|
280 | terminate(p) | |
281 | threading.Thread(target=t).start() |
|
281 | threading.Thread(target=t).start() | |
282 |
|
282 | |||
283 | return p |
|
283 | return p | |
284 |
|
284 | |||
285 | PYTHON = _bytespath(sys.executable.replace('\\', '/')) |
|
285 | PYTHON = _bytespath(sys.executable.replace('\\', '/')) | |
286 | IMPL_PATH = b'PYTHONPATH' |
|
286 | IMPL_PATH = b'PYTHONPATH' | |
287 | if 'java' in sys.platform: |
|
287 | if 'java' in sys.platform: | |
288 | IMPL_PATH = b'JYTHONPATH' |
|
288 | IMPL_PATH = b'JYTHONPATH' | |
289 |
|
289 | |||
290 | defaults = { |
|
290 | defaults = { | |
291 | 'jobs': ('HGTEST_JOBS', multiprocessing.cpu_count()), |
|
291 | 'jobs': ('HGTEST_JOBS', multiprocessing.cpu_count()), | |
292 | 'timeout': ('HGTEST_TIMEOUT', 180), |
|
292 | 'timeout': ('HGTEST_TIMEOUT', 180), | |
293 | 'slowtimeout': ('HGTEST_SLOWTIMEOUT', 1500), |
|
293 | 'slowtimeout': ('HGTEST_SLOWTIMEOUT', 1500), | |
294 | 'port': ('HGTEST_PORT', 20059), |
|
294 | 'port': ('HGTEST_PORT', 20059), | |
295 | 'shell': ('HGTEST_SHELL', 'sh'), |
|
295 | 'shell': ('HGTEST_SHELL', 'sh'), | |
296 | } |
|
296 | } | |
297 |
|
297 | |||
298 | def canonpath(path): |
|
298 | def canonpath(path): | |
299 | return os.path.realpath(os.path.expanduser(path)) |
|
299 | return os.path.realpath(os.path.expanduser(path)) | |
300 |
|
300 | |||
301 | def parselistfiles(files, listtype, warn=True): |
|
301 | def parselistfiles(files, listtype, warn=True): | |
302 | entries = dict() |
|
302 | entries = dict() | |
303 | for filename in files: |
|
303 | for filename in files: | |
304 | try: |
|
304 | try: | |
305 | path = os.path.expanduser(os.path.expandvars(filename)) |
|
305 | path = os.path.expanduser(os.path.expandvars(filename)) | |
306 | f = open(path, "rb") |
|
306 | f = open(path, "rb") | |
307 | except IOError as err: |
|
307 | except IOError as err: | |
308 | if err.errno != errno.ENOENT: |
|
308 | if err.errno != errno.ENOENT: | |
309 | raise |
|
309 | raise | |
310 | if warn: |
|
310 | if warn: | |
311 | print("warning: no such %s file: %s" % (listtype, filename)) |
|
311 | print("warning: no such %s file: %s" % (listtype, filename)) | |
312 | continue |
|
312 | continue | |
313 |
|
313 | |||
314 | for line in f.readlines(): |
|
314 | for line in f.readlines(): | |
315 | line = line.split(b'#', 1)[0].strip() |
|
315 | line = line.split(b'#', 1)[0].strip() | |
316 | if line: |
|
316 | if line: | |
317 | entries[line] = filename |
|
317 | entries[line] = filename | |
318 |
|
318 | |||
319 | f.close() |
|
319 | f.close() | |
320 | return entries |
|
320 | return entries | |
321 |
|
321 | |||
322 | def parsettestcases(path): |
|
322 | def parsettestcases(path): | |
323 | """read a .t test file, return a set of test case names |
|
323 | """read a .t test file, return a set of test case names | |
324 |
|
324 | |||
325 | If path does not exist, return an empty set. |
|
325 | If path does not exist, return an empty set. | |
326 | """ |
|
326 | """ | |
327 | cases = [] |
|
327 | cases = [] | |
328 | try: |
|
328 | try: | |
329 | with open(path, 'rb') as f: |
|
329 | with open(path, 'rb') as f: | |
330 | for l in f: |
|
330 | for l in f: | |
331 | if l.startswith(b'#testcases '): |
|
331 | if l.startswith(b'#testcases '): | |
332 | cases.append(sorted(l[11:].split())) |
|
332 | cases.append(sorted(l[11:].split())) | |
333 | except IOError as ex: |
|
333 | except IOError as ex: | |
334 | if ex.errno != errno.ENOENT: |
|
334 | if ex.errno != errno.ENOENT: | |
335 | raise |
|
335 | raise | |
336 | return cases |
|
336 | return cases | |
337 |
|
337 | |||
338 | def getparser(): |
|
338 | def getparser(): | |
339 | """Obtain the OptionParser used by the CLI.""" |
|
339 | """Obtain the OptionParser used by the CLI.""" | |
340 | parser = argparse.ArgumentParser(usage='%(prog)s [options] [tests]') |
|
340 | parser = argparse.ArgumentParser(usage='%(prog)s [options] [tests]') | |
341 |
|
341 | |||
342 | selection = parser.add_argument_group('Test Selection') |
|
342 | selection = parser.add_argument_group('Test Selection') | |
343 | selection.add_argument('--allow-slow-tests', action='store_true', |
|
343 | selection.add_argument('--allow-slow-tests', action='store_true', | |
344 | help='allow extremely slow tests') |
|
344 | help='allow extremely slow tests') | |
345 | selection.add_argument("--blacklist", action="append", |
|
345 | selection.add_argument("--blacklist", action="append", | |
346 | help="skip tests listed in the specified blacklist file") |
|
346 | help="skip tests listed in the specified blacklist file") | |
347 | selection.add_argument("--changed", |
|
347 | selection.add_argument("--changed", | |
348 | help="run tests that are changed in parent rev or working directory") |
|
348 | help="run tests that are changed in parent rev or working directory") | |
349 | selection.add_argument("-k", "--keywords", |
|
349 | selection.add_argument("-k", "--keywords", | |
350 | help="run tests matching keywords") |
|
350 | help="run tests matching keywords") | |
351 | selection.add_argument("-r", "--retest", action="store_true", |
|
351 | selection.add_argument("-r", "--retest", action="store_true", | |
352 | help = "retest failed tests") |
|
352 | help = "retest failed tests") | |
353 | selection.add_argument("--test-list", action="append", |
|
353 | selection.add_argument("--test-list", action="append", | |
354 | help="read tests to run from the specified file") |
|
354 | help="read tests to run from the specified file") | |
355 | selection.add_argument("--whitelist", action="append", |
|
355 | selection.add_argument("--whitelist", action="append", | |
356 | help="always run tests listed in the specified whitelist file") |
|
356 | help="always run tests listed in the specified whitelist file") | |
357 | selection.add_argument('tests', metavar='TESTS', nargs='*', |
|
357 | selection.add_argument('tests', metavar='TESTS', nargs='*', | |
358 | help='Tests to run') |
|
358 | help='Tests to run') | |
359 |
|
359 | |||
360 | harness = parser.add_argument_group('Test Harness Behavior') |
|
360 | harness = parser.add_argument_group('Test Harness Behavior') | |
361 | harness.add_argument('--bisect-repo', |
|
361 | harness.add_argument('--bisect-repo', | |
362 | metavar='bisect_repo', |
|
362 | metavar='bisect_repo', | |
363 | help=("Path of a repo to bisect. Use together with " |
|
363 | help=("Path of a repo to bisect. Use together with " | |
364 | "--known-good-rev")) |
|
364 | "--known-good-rev")) | |
365 | harness.add_argument("-d", "--debug", action="store_true", |
|
365 | harness.add_argument("-d", "--debug", action="store_true", | |
366 | help="debug mode: write output of test scripts to console" |
|
366 | help="debug mode: write output of test scripts to console" | |
367 | " rather than capturing and diffing it (disables timeout)") |
|
367 | " rather than capturing and diffing it (disables timeout)") | |
368 | harness.add_argument("-f", "--first", action="store_true", |
|
368 | harness.add_argument("-f", "--first", action="store_true", | |
369 | help="exit on the first test failure") |
|
369 | help="exit on the first test failure") | |
370 | harness.add_argument("-i", "--interactive", action="store_true", |
|
370 | harness.add_argument("-i", "--interactive", action="store_true", | |
371 | help="prompt to accept changed output") |
|
371 | help="prompt to accept changed output") | |
372 | harness.add_argument("-j", "--jobs", type=int, |
|
372 | harness.add_argument("-j", "--jobs", type=int, | |
373 | help="number of jobs to run in parallel" |
|
373 | help="number of jobs to run in parallel" | |
374 | " (default: $%s or %d)" % defaults['jobs']) |
|
374 | " (default: $%s or %d)" % defaults['jobs']) | |
375 | harness.add_argument("--keep-tmpdir", action="store_true", |
|
375 | harness.add_argument("--keep-tmpdir", action="store_true", | |
376 | help="keep temporary directory after running tests") |
|
376 | help="keep temporary directory after running tests") | |
377 | harness.add_argument('--known-good-rev', |
|
377 | harness.add_argument('--known-good-rev', | |
378 | metavar="known_good_rev", |
|
378 | metavar="known_good_rev", | |
379 | help=("Automatically bisect any failures using this " |
|
379 | help=("Automatically bisect any failures using this " | |
380 | "revision as a known-good revision.")) |
|
380 | "revision as a known-good revision.")) | |
381 | harness.add_argument("--list-tests", action="store_true", |
|
381 | harness.add_argument("--list-tests", action="store_true", | |
382 | help="list tests instead of running them") |
|
382 | help="list tests instead of running them") | |
383 | harness.add_argument("--loop", action="store_true", |
|
383 | harness.add_argument("--loop", action="store_true", | |
384 | help="loop tests repeatedly") |
|
384 | help="loop tests repeatedly") | |
385 | harness.add_argument('--random', action="store_true", |
|
385 | harness.add_argument('--random', action="store_true", | |
386 | help='run tests in random order') |
|
386 | help='run tests in random order') | |
387 | harness.add_argument('--order-by-runtime', action="store_true", |
|
387 | harness.add_argument('--order-by-runtime', action="store_true", | |
388 | help='run slowest tests first, according to .testtimes') |
|
388 | help='run slowest tests first, according to .testtimes') | |
389 | harness.add_argument("-p", "--port", type=int, |
|
389 | harness.add_argument("-p", "--port", type=int, | |
390 | help="port on which servers should listen" |
|
390 | help="port on which servers should listen" | |
391 | " (default: $%s or %d)" % defaults['port']) |
|
391 | " (default: $%s or %d)" % defaults['port']) | |
392 | harness.add_argument('--profile-runner', action='store_true', |
|
392 | harness.add_argument('--profile-runner', action='store_true', | |
393 | help='run statprof on run-tests') |
|
393 | help='run statprof on run-tests') | |
394 | harness.add_argument("-R", "--restart", action="store_true", |
|
394 | harness.add_argument("-R", "--restart", action="store_true", | |
395 | help="restart at last error") |
|
395 | help="restart at last error") | |
396 | harness.add_argument("--runs-per-test", type=int, dest="runs_per_test", |
|
396 | harness.add_argument("--runs-per-test", type=int, dest="runs_per_test", | |
397 | help="run each test N times (default=1)", default=1) |
|
397 | help="run each test N times (default=1)", default=1) | |
398 | harness.add_argument("--shell", |
|
398 | harness.add_argument("--shell", | |
399 | help="shell to use (default: $%s or %s)" % defaults['shell']) |
|
399 | help="shell to use (default: $%s or %s)" % defaults['shell']) | |
400 | harness.add_argument('--showchannels', action='store_true', |
|
400 | harness.add_argument('--showchannels', action='store_true', | |
401 | help='show scheduling channels') |
|
401 | help='show scheduling channels') | |
402 | harness.add_argument("--slowtimeout", type=int, |
|
402 | harness.add_argument("--slowtimeout", type=int, | |
403 | help="kill errant slow tests after SLOWTIMEOUT seconds" |
|
403 | help="kill errant slow tests after SLOWTIMEOUT seconds" | |
404 | " (default: $%s or %d)" % defaults['slowtimeout']) |
|
404 | " (default: $%s or %d)" % defaults['slowtimeout']) | |
405 | harness.add_argument("-t", "--timeout", type=int, |
|
405 | harness.add_argument("-t", "--timeout", type=int, | |
406 | help="kill errant tests after TIMEOUT seconds" |
|
406 | help="kill errant tests after TIMEOUT seconds" | |
407 | " (default: $%s or %d)" % defaults['timeout']) |
|
407 | " (default: $%s or %d)" % defaults['timeout']) | |
408 | harness.add_argument("--tmpdir", |
|
408 | harness.add_argument("--tmpdir", | |
409 | help="run tests in the given temporary directory" |
|
409 | help="run tests in the given temporary directory" | |
410 | " (implies --keep-tmpdir)") |
|
410 | " (implies --keep-tmpdir)") | |
411 | harness.add_argument("-v", "--verbose", action="store_true", |
|
411 | harness.add_argument("-v", "--verbose", action="store_true", | |
412 | help="output verbose messages") |
|
412 | help="output verbose messages") | |
413 |
|
413 | |||
414 | hgconf = parser.add_argument_group('Mercurial Configuration') |
|
414 | hgconf = parser.add_argument_group('Mercurial Configuration') | |
415 | hgconf.add_argument("--chg", action="store_true", |
|
415 | hgconf.add_argument("--chg", action="store_true", | |
416 | help="install and use chg wrapper in place of hg") |
|
416 | help="install and use chg wrapper in place of hg") | |
417 | hgconf.add_argument("--compiler", |
|
417 | hgconf.add_argument("--compiler", | |
418 | help="compiler to build with") |
|
418 | help="compiler to build with") | |
419 | hgconf.add_argument('--extra-config-opt', action="append", default=[], |
|
419 | hgconf.add_argument('--extra-config-opt', action="append", default=[], | |
420 | help='set the given config opt in the test hgrc') |
|
420 | help='set the given config opt in the test hgrc') | |
421 | hgconf.add_argument("-l", "--local", action="store_true", |
|
421 | hgconf.add_argument("-l", "--local", action="store_true", | |
422 | help="shortcut for --with-hg=<testdir>/../hg, " |
|
422 | help="shortcut for --with-hg=<testdir>/../hg, " | |
423 | "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set") |
|
423 | "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set") | |
424 | hgconf.add_argument("--ipv6", action="store_true", |
|
424 | hgconf.add_argument("--ipv6", action="store_true", | |
425 | help="prefer IPv6 to IPv4 for network related tests") |
|
425 | help="prefer IPv6 to IPv4 for network related tests") | |
426 | hgconf.add_argument("--pure", action="store_true", |
|
426 | hgconf.add_argument("--pure", action="store_true", | |
427 | help="use pure Python code instead of C extensions") |
|
427 | help="use pure Python code instead of C extensions") | |
428 | hgconf.add_argument("-3", "--py3-warnings", action="store_true", |
|
428 | hgconf.add_argument("-3", "--py3-warnings", action="store_true", | |
429 | help="enable Py3k warnings on Python 2.7+") |
|
429 | help="enable Py3k warnings on Python 2.7+") | |
430 | hgconf.add_argument("--with-chg", metavar="CHG", |
|
430 | hgconf.add_argument("--with-chg", metavar="CHG", | |
431 | help="use specified chg wrapper in place of hg") |
|
431 | help="use specified chg wrapper in place of hg") | |
432 | hgconf.add_argument("--with-hg", |
|
432 | hgconf.add_argument("--with-hg", | |
433 | metavar="HG", |
|
433 | metavar="HG", | |
434 | help="test using specified hg script rather than a " |
|
434 | help="test using specified hg script rather than a " | |
435 | "temporary installation") |
|
435 | "temporary installation") | |
436 |
|
436 | |||
437 | reporting = parser.add_argument_group('Results Reporting') |
|
437 | reporting = parser.add_argument_group('Results Reporting') | |
438 | reporting.add_argument("-C", "--annotate", action="store_true", |
|
438 | reporting.add_argument("-C", "--annotate", action="store_true", | |
439 | help="output files annotated with coverage") |
|
439 | help="output files annotated with coverage") | |
440 | reporting.add_argument("--color", choices=["always", "auto", "never"], |
|
440 | reporting.add_argument("--color", choices=["always", "auto", "never"], | |
441 | default=os.environ.get('HGRUNTESTSCOLOR', 'auto'), |
|
441 | default=os.environ.get('HGRUNTESTSCOLOR', 'auto'), | |
442 | help="colorisation: always|auto|never (default: auto)") |
|
442 | help="colorisation: always|auto|never (default: auto)") | |
443 | reporting.add_argument("-c", "--cover", action="store_true", |
|
443 | reporting.add_argument("-c", "--cover", action="store_true", | |
444 | help="print a test coverage report") |
|
444 | help="print a test coverage report") | |
445 | reporting.add_argument('--exceptions', action='store_true', |
|
445 | reporting.add_argument('--exceptions', action='store_true', | |
446 | help='log all exceptions and generate an exception report') |
|
446 | help='log all exceptions and generate an exception report') | |
447 | reporting.add_argument("-H", "--htmlcov", action="store_true", |
|
447 | reporting.add_argument("-H", "--htmlcov", action="store_true", | |
448 | help="create an HTML report of the coverage of the files") |
|
448 | help="create an HTML report of the coverage of the files") | |
449 | reporting.add_argument("--json", action="store_true", |
|
449 | reporting.add_argument("--json", action="store_true", | |
450 | help="store test result data in 'report.json' file") |
|
450 | help="store test result data in 'report.json' file") | |
451 | reporting.add_argument("--outputdir", |
|
451 | reporting.add_argument("--outputdir", | |
452 | help="directory to write error logs to (default=test directory)") |
|
452 | help="directory to write error logs to (default=test directory)") | |
453 | reporting.add_argument("-n", "--nodiff", action="store_true", |
|
453 | reporting.add_argument("-n", "--nodiff", action="store_true", | |
454 | help="skip showing test changes") |
|
454 | help="skip showing test changes") | |
455 | reporting.add_argument("-S", "--noskips", action="store_true", |
|
455 | reporting.add_argument("-S", "--noskips", action="store_true", | |
456 | help="don't report skip tests verbosely") |
|
456 | help="don't report skip tests verbosely") | |
457 | reporting.add_argument("--time", action="store_true", |
|
457 | reporting.add_argument("--time", action="store_true", | |
458 | help="time how long each test takes") |
|
458 | help="time how long each test takes") | |
459 | reporting.add_argument("--view", |
|
459 | reporting.add_argument("--view", | |
460 | help="external diff viewer") |
|
460 | help="external diff viewer") | |
461 | reporting.add_argument("--xunit", |
|
461 | reporting.add_argument("--xunit", | |
462 | help="record xunit results at specified path") |
|
462 | help="record xunit results at specified path") | |
463 |
|
463 | |||
464 | for option, (envvar, default) in defaults.items(): |
|
464 | for option, (envvar, default) in defaults.items(): | |
465 | defaults[option] = type(default)(os.environ.get(envvar, default)) |
|
465 | defaults[option] = type(default)(os.environ.get(envvar, default)) | |
466 | parser.set_defaults(**defaults) |
|
466 | parser.set_defaults(**defaults) | |
467 |
|
467 | |||
468 | return parser |
|
468 | return parser | |
469 |
|
469 | |||
470 | def parseargs(args, parser): |
|
470 | def parseargs(args, parser): | |
471 | """Parse arguments with our OptionParser and validate results.""" |
|
471 | """Parse arguments with our OptionParser and validate results.""" | |
472 | options = parser.parse_args(args) |
|
472 | options = parser.parse_args(args) | |
473 |
|
473 | |||
474 | # jython is always pure |
|
474 | # jython is always pure | |
475 | if 'java' in sys.platform or '__pypy__' in sys.modules: |
|
475 | if 'java' in sys.platform or '__pypy__' in sys.modules: | |
476 | options.pure = True |
|
476 | options.pure = True | |
477 |
|
477 | |||
478 | if options.with_hg: |
|
478 | if options.with_hg: | |
479 | options.with_hg = canonpath(_bytespath(options.with_hg)) |
|
479 | options.with_hg = canonpath(_bytespath(options.with_hg)) | |
480 | if not (os.path.isfile(options.with_hg) and |
|
480 | if not (os.path.isfile(options.with_hg) and | |
481 | os.access(options.with_hg, os.X_OK)): |
|
481 | os.access(options.with_hg, os.X_OK)): | |
482 | parser.error('--with-hg must specify an executable hg script') |
|
482 | parser.error('--with-hg must specify an executable hg script') | |
483 | if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']: |
|
483 | if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']: | |
484 | sys.stderr.write('warning: --with-hg should specify an hg script\n') |
|
484 | sys.stderr.write('warning: --with-hg should specify an hg script\n') | |
485 | sys.stderr.flush() |
|
485 | sys.stderr.flush() | |
486 | if options.local: |
|
486 | if options.local: | |
487 | testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0]))) |
|
487 | testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0]))) | |
488 | reporootdir = os.path.dirname(testdir) |
|
488 | reporootdir = os.path.dirname(testdir) | |
489 | pathandattrs = [(b'hg', 'with_hg')] |
|
489 | pathandattrs = [(b'hg', 'with_hg')] | |
490 | if options.chg: |
|
490 | if options.chg: | |
491 | pathandattrs.append((b'contrib/chg/chg', 'with_chg')) |
|
491 | pathandattrs.append((b'contrib/chg/chg', 'with_chg')) | |
492 | for relpath, attr in pathandattrs: |
|
492 | for relpath, attr in pathandattrs: | |
493 | binpath = os.path.join(reporootdir, relpath) |
|
493 | binpath = os.path.join(reporootdir, relpath) | |
494 | if os.name != 'nt' and not os.access(binpath, os.X_OK): |
|
494 | if os.name != 'nt' and not os.access(binpath, os.X_OK): | |
495 | parser.error('--local specified, but %r not found or ' |
|
495 | parser.error('--local specified, but %r not found or ' | |
496 | 'not executable' % binpath) |
|
496 | 'not executable' % binpath) | |
497 | setattr(options, attr, binpath) |
|
497 | setattr(options, attr, binpath) | |
498 |
|
498 | |||
499 | if (options.chg or options.with_chg) and os.name == 'nt': |
|
499 | if (options.chg or options.with_chg) and os.name == 'nt': | |
500 | parser.error('chg does not work on %s' % os.name) |
|
500 | parser.error('chg does not work on %s' % os.name) | |
501 | if options.with_chg: |
|
501 | if options.with_chg: | |
502 | options.chg = False # no installation to temporary location |
|
502 | options.chg = False # no installation to temporary location | |
503 | options.with_chg = canonpath(_bytespath(options.with_chg)) |
|
503 | options.with_chg = canonpath(_bytespath(options.with_chg)) | |
504 | if not (os.path.isfile(options.with_chg) and |
|
504 | if not (os.path.isfile(options.with_chg) and | |
505 | os.access(options.with_chg, os.X_OK)): |
|
505 | os.access(options.with_chg, os.X_OK)): | |
506 | parser.error('--with-chg must specify a chg executable') |
|
506 | parser.error('--with-chg must specify a chg executable') | |
507 | if options.chg and options.with_hg: |
|
507 | if options.chg and options.with_hg: | |
508 | # chg shares installation location with hg |
|
508 | # chg shares installation location with hg | |
509 | parser.error('--chg does not work when --with-hg is specified ' |
|
509 | parser.error('--chg does not work when --with-hg is specified ' | |
510 | '(use --with-chg instead)') |
|
510 | '(use --with-chg instead)') | |
511 |
|
511 | |||
512 | if options.color == 'always' and not pygmentspresent: |
|
512 | if options.color == 'always' and not pygmentspresent: | |
513 | sys.stderr.write('warning: --color=always ignored because ' |
|
513 | sys.stderr.write('warning: --color=always ignored because ' | |
514 | 'pygments is not installed\n') |
|
514 | 'pygments is not installed\n') | |
515 |
|
515 | |||
516 | if options.bisect_repo and not options.known_good_rev: |
|
516 | if options.bisect_repo and not options.known_good_rev: | |
517 | parser.error("--bisect-repo cannot be used without --known-good-rev") |
|
517 | parser.error("--bisect-repo cannot be used without --known-good-rev") | |
518 |
|
518 | |||
519 | global useipv6 |
|
519 | global useipv6 | |
520 | if options.ipv6: |
|
520 | if options.ipv6: | |
521 | useipv6 = checksocketfamily('AF_INET6') |
|
521 | useipv6 = checksocketfamily('AF_INET6') | |
522 | else: |
|
522 | else: | |
523 | # only use IPv6 if IPv4 is unavailable and IPv6 is available |
|
523 | # only use IPv6 if IPv4 is unavailable and IPv6 is available | |
524 | useipv6 = ((not checksocketfamily('AF_INET')) |
|
524 | useipv6 = ((not checksocketfamily('AF_INET')) | |
525 | and checksocketfamily('AF_INET6')) |
|
525 | and checksocketfamily('AF_INET6')) | |
526 |
|
526 | |||
527 | options.anycoverage = options.cover or options.annotate or options.htmlcov |
|
527 | options.anycoverage = options.cover or options.annotate or options.htmlcov | |
528 | if options.anycoverage: |
|
528 | if options.anycoverage: | |
529 | try: |
|
529 | try: | |
530 | import coverage |
|
530 | import coverage | |
531 | covver = version.StrictVersion(coverage.__version__).version |
|
531 | covver = version.StrictVersion(coverage.__version__).version | |
532 | if covver < (3, 3): |
|
532 | if covver < (3, 3): | |
533 | parser.error('coverage options require coverage 3.3 or later') |
|
533 | parser.error('coverage options require coverage 3.3 or later') | |
534 | except ImportError: |
|
534 | except ImportError: | |
535 | parser.error('coverage options now require the coverage package') |
|
535 | parser.error('coverage options now require the coverage package') | |
536 |
|
536 | |||
537 | if options.anycoverage and options.local: |
|
537 | if options.anycoverage and options.local: | |
538 | # this needs some path mangling somewhere, I guess |
|
538 | # this needs some path mangling somewhere, I guess | |
539 | parser.error("sorry, coverage options do not work when --local " |
|
539 | parser.error("sorry, coverage options do not work when --local " | |
540 | "is specified") |
|
540 | "is specified") | |
541 |
|
541 | |||
542 | if options.anycoverage and options.with_hg: |
|
542 | if options.anycoverage and options.with_hg: | |
543 | parser.error("sorry, coverage options do not work when --with-hg " |
|
543 | parser.error("sorry, coverage options do not work when --with-hg " | |
544 | "is specified") |
|
544 | "is specified") | |
545 |
|
545 | |||
546 | global verbose |
|
546 | global verbose | |
547 | if options.verbose: |
|
547 | if options.verbose: | |
548 | verbose = '' |
|
548 | verbose = '' | |
549 |
|
549 | |||
550 | if options.tmpdir: |
|
550 | if options.tmpdir: | |
551 | options.tmpdir = canonpath(options.tmpdir) |
|
551 | options.tmpdir = canonpath(options.tmpdir) | |
552 |
|
552 | |||
553 | if options.jobs < 1: |
|
553 | if options.jobs < 1: | |
554 | parser.error('--jobs must be positive') |
|
554 | parser.error('--jobs must be positive') | |
555 | if options.interactive and options.debug: |
|
555 | if options.interactive and options.debug: | |
556 | parser.error("-i/--interactive and -d/--debug are incompatible") |
|
556 | parser.error("-i/--interactive and -d/--debug are incompatible") | |
557 | if options.debug: |
|
557 | if options.debug: | |
558 | if options.timeout != defaults['timeout']: |
|
558 | if options.timeout != defaults['timeout']: | |
559 | sys.stderr.write( |
|
559 | sys.stderr.write( | |
560 | 'warning: --timeout option ignored with --debug\n') |
|
560 | 'warning: --timeout option ignored with --debug\n') | |
561 | if options.slowtimeout != defaults['slowtimeout']: |
|
561 | if options.slowtimeout != defaults['slowtimeout']: | |
562 | sys.stderr.write( |
|
562 | sys.stderr.write( | |
563 | 'warning: --slowtimeout option ignored with --debug\n') |
|
563 | 'warning: --slowtimeout option ignored with --debug\n') | |
564 | options.timeout = 0 |
|
564 | options.timeout = 0 | |
565 | options.slowtimeout = 0 |
|
565 | options.slowtimeout = 0 | |
566 | if options.py3_warnings: |
|
566 | if options.py3_warnings: | |
567 | if PYTHON3: |
|
567 | if PYTHON3: | |
568 | parser.error( |
|
568 | parser.error( | |
569 | '--py3-warnings can only be used on Python 2.7') |
|
569 | '--py3-warnings can only be used on Python 2.7') | |
570 |
|
570 | |||
571 | if options.blacklist: |
|
571 | if options.blacklist: | |
572 | options.blacklist = parselistfiles(options.blacklist, 'blacklist') |
|
572 | options.blacklist = parselistfiles(options.blacklist, 'blacklist') | |
573 | if options.whitelist: |
|
573 | if options.whitelist: | |
574 | options.whitelisted = parselistfiles(options.whitelist, 'whitelist') |
|
574 | options.whitelisted = parselistfiles(options.whitelist, 'whitelist') | |
575 | else: |
|
575 | else: | |
576 | options.whitelisted = {} |
|
576 | options.whitelisted = {} | |
577 |
|
577 | |||
578 | if options.showchannels: |
|
578 | if options.showchannels: | |
579 | options.nodiff = True |
|
579 | options.nodiff = True | |
580 |
|
580 | |||
581 | return options |
|
581 | return options | |
582 |
|
582 | |||
583 | def rename(src, dst): |
|
583 | def rename(src, dst): | |
584 | """Like os.rename(), trade atomicity and opened files friendliness |
|
584 | """Like os.rename(), trade atomicity and opened files friendliness | |
585 | for existing destination support. |
|
585 | for existing destination support. | |
586 | """ |
|
586 | """ | |
587 | shutil.copy(src, dst) |
|
587 | shutil.copy(src, dst) | |
588 | os.remove(src) |
|
588 | os.remove(src) | |
589 |
|
589 | |||
590 | def makecleanable(path): |
|
590 | def makecleanable(path): | |
591 | """Try to fix directory permission recursively so that the entire tree |
|
591 | """Try to fix directory permission recursively so that the entire tree | |
592 | can be deleted""" |
|
592 | can be deleted""" | |
593 | for dirpath, dirnames, _filenames in os.walk(path, topdown=True): |
|
593 | for dirpath, dirnames, _filenames in os.walk(path, topdown=True): | |
594 | for d in dirnames: |
|
594 | for d in dirnames: | |
595 | p = os.path.join(dirpath, d) |
|
595 | p = os.path.join(dirpath, d) | |
596 | try: |
|
596 | try: | |
597 | os.chmod(p, os.stat(p).st_mode & 0o777 | 0o700) # chmod u+rwx |
|
597 | os.chmod(p, os.stat(p).st_mode & 0o777 | 0o700) # chmod u+rwx | |
598 | except OSError: |
|
598 | except OSError: | |
599 | pass |
|
599 | pass | |
600 |
|
600 | |||
601 | _unified_diff = difflib.unified_diff |
|
601 | _unified_diff = difflib.unified_diff | |
602 | if PYTHON3: |
|
602 | if PYTHON3: | |
603 | import functools |
|
603 | import functools | |
604 | _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff) |
|
604 | _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff) | |
605 |
|
605 | |||
606 | def getdiff(expected, output, ref, err): |
|
606 | def getdiff(expected, output, ref, err): | |
607 | servefail = False |
|
607 | servefail = False | |
608 | lines = [] |
|
608 | lines = [] | |
609 | for line in _unified_diff(expected, output, ref, err): |
|
609 | for line in _unified_diff(expected, output, ref, err): | |
610 | if line.startswith(b'+++') or line.startswith(b'---'): |
|
610 | if line.startswith(b'+++') or line.startswith(b'---'): | |
611 | line = line.replace(b'\\', b'/') |
|
611 | line = line.replace(b'\\', b'/') | |
612 | if line.endswith(b' \n'): |
|
612 | if line.endswith(b' \n'): | |
613 | line = line[:-2] + b'\n' |
|
613 | line = line[:-2] + b'\n' | |
614 | lines.append(line) |
|
614 | lines.append(line) | |
615 | if not servefail and line.startswith( |
|
615 | if not servefail and line.startswith( | |
616 | b'+ abort: child process failed to start'): |
|
616 | b'+ abort: child process failed to start'): | |
617 | servefail = True |
|
617 | servefail = True | |
618 |
|
618 | |||
619 | return servefail, lines |
|
619 | return servefail, lines | |
620 |
|
620 | |||
621 | verbose = False |
|
621 | verbose = False | |
622 | def vlog(*msg): |
|
622 | def vlog(*msg): | |
623 | """Log only when in verbose mode.""" |
|
623 | """Log only when in verbose mode.""" | |
624 | if verbose is False: |
|
624 | if verbose is False: | |
625 | return |
|
625 | return | |
626 |
|
626 | |||
627 | return log(*msg) |
|
627 | return log(*msg) | |
628 |
|
628 | |||
629 | # Bytes that break XML even in a CDATA block: control characters 0-31 |
|
629 | # Bytes that break XML even in a CDATA block: control characters 0-31 | |
630 | # sans \t, \n and \r |
|
630 | # sans \t, \n and \r | |
631 | CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]") |
|
631 | CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]") | |
632 |
|
632 | |||
633 | # Match feature conditionalized output lines in the form, capturing the feature |
|
633 | # Match feature conditionalized output lines in the form, capturing the feature | |
634 | # list in group 2, and the preceeding line output in group 1: |
|
634 | # list in group 2, and the preceeding line output in group 1: | |
635 | # |
|
635 | # | |
636 | # output..output (feature !)\n |
|
636 | # output..output (feature !)\n | |
637 | optline = re.compile(br'(.*) \((.+?) !\)\n$') |
|
637 | optline = re.compile(br'(.*) \((.+?) !\)\n$') | |
638 |
|
638 | |||
639 | def cdatasafe(data): |
|
639 | def cdatasafe(data): | |
640 | """Make a string safe to include in a CDATA block. |
|
640 | """Make a string safe to include in a CDATA block. | |
641 |
|
641 | |||
642 | Certain control characters are illegal in a CDATA block, and |
|
642 | Certain control characters are illegal in a CDATA block, and | |
643 | there's no way to include a ]]> in a CDATA either. This function |
|
643 | there's no way to include a ]]> in a CDATA either. This function | |
644 | replaces illegal bytes with ? and adds a space between the ]] so |
|
644 | replaces illegal bytes with ? and adds a space between the ]] so | |
645 | that it won't break the CDATA block. |
|
645 | that it won't break the CDATA block. | |
646 | """ |
|
646 | """ | |
647 | return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>') |
|
647 | return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>') | |
648 |
|
648 | |||
649 | def log(*msg): |
|
649 | def log(*msg): | |
650 | """Log something to stdout. |
|
650 | """Log something to stdout. | |
651 |
|
651 | |||
652 | Arguments are strings to print. |
|
652 | Arguments are strings to print. | |
653 | """ |
|
653 | """ | |
654 | with iolock: |
|
654 | with iolock: | |
655 | if verbose: |
|
655 | if verbose: | |
656 | print(verbose, end=' ') |
|
656 | print(verbose, end=' ') | |
657 | for m in msg: |
|
657 | for m in msg: | |
658 | print(m, end=' ') |
|
658 | print(m, end=' ') | |
659 | print() |
|
659 | print() | |
660 | sys.stdout.flush() |
|
660 | sys.stdout.flush() | |
661 |
|
661 | |||
662 | def highlightdiff(line, color): |
|
662 | def highlightdiff(line, color): | |
663 | if not color: |
|
663 | if not color: | |
664 | return line |
|
664 | return line | |
665 | assert pygmentspresent |
|
665 | assert pygmentspresent | |
666 | return pygments.highlight(line.decode('latin1'), difflexer, |
|
666 | return pygments.highlight(line.decode('latin1'), difflexer, | |
667 | terminal256formatter).encode('latin1') |
|
667 | terminal256formatter).encode('latin1') | |
668 |
|
668 | |||
669 | def highlightmsg(msg, color): |
|
669 | def highlightmsg(msg, color): | |
670 | if not color: |
|
670 | if not color: | |
671 | return msg |
|
671 | return msg | |
672 | assert pygmentspresent |
|
672 | assert pygmentspresent | |
673 | return pygments.highlight(msg, runnerlexer, runnerformatter) |
|
673 | return pygments.highlight(msg, runnerlexer, runnerformatter) | |
674 |
|
674 | |||
675 | def terminate(proc): |
|
675 | def terminate(proc): | |
676 | """Terminate subprocess""" |
|
676 | """Terminate subprocess""" | |
677 | vlog('# Terminating process %d' % proc.pid) |
|
677 | vlog('# Terminating process %d' % proc.pid) | |
678 | try: |
|
678 | try: | |
679 | proc.terminate() |
|
679 | proc.terminate() | |
680 | except OSError: |
|
680 | except OSError: | |
681 | pass |
|
681 | pass | |
682 |
|
682 | |||
683 | def killdaemons(pidfile): |
|
683 | def killdaemons(pidfile): | |
684 | import killdaemons as killmod |
|
684 | import killdaemons as killmod | |
685 | return killmod.killdaemons(pidfile, tryhard=False, remove=True, |
|
685 | return killmod.killdaemons(pidfile, tryhard=False, remove=True, | |
686 | logfn=vlog) |
|
686 | logfn=vlog) | |
687 |
|
687 | |||
688 | class Test(unittest.TestCase): |
|
688 | class Test(unittest.TestCase): | |
689 | """Encapsulates a single, runnable test. |
|
689 | """Encapsulates a single, runnable test. | |
690 |
|
690 | |||
691 | While this class conforms to the unittest.TestCase API, it differs in that |
|
691 | While this class conforms to the unittest.TestCase API, it differs in that | |
692 | instances need to be instantiated manually. (Typically, unittest.TestCase |
|
692 | instances need to be instantiated manually. (Typically, unittest.TestCase | |
693 | classes are instantiated automatically by scanning modules.) |
|
693 | classes are instantiated automatically by scanning modules.) | |
694 | """ |
|
694 | """ | |
695 |
|
695 | |||
696 | # Status code reserved for skipped tests (used by hghave). |
|
696 | # Status code reserved for skipped tests (used by hghave). | |
697 | SKIPPED_STATUS = 80 |
|
697 | SKIPPED_STATUS = 80 | |
698 |
|
698 | |||
699 | def __init__(self, path, outputdir, tmpdir, keeptmpdir=False, |
|
699 | def __init__(self, path, outputdir, tmpdir, keeptmpdir=False, | |
700 | debug=False, |
|
700 | debug=False, | |
701 | first=False, |
|
701 | first=False, | |
702 | timeout=None, |
|
702 | timeout=None, | |
703 | startport=None, extraconfigopts=None, |
|
703 | startport=None, extraconfigopts=None, | |
704 | py3warnings=False, shell=None, hgcommand=None, |
|
704 | py3warnings=False, shell=None, hgcommand=None, | |
705 | slowtimeout=None, usechg=False, |
|
705 | slowtimeout=None, usechg=False, | |
706 | useipv6=False): |
|
706 | useipv6=False): | |
707 | """Create a test from parameters. |
|
707 | """Create a test from parameters. | |
708 |
|
708 | |||
709 | path is the full path to the file defining the test. |
|
709 | path is the full path to the file defining the test. | |
710 |
|
710 | |||
711 | tmpdir is the main temporary directory to use for this test. |
|
711 | tmpdir is the main temporary directory to use for this test. | |
712 |
|
712 | |||
713 | keeptmpdir determines whether to keep the test's temporary directory |
|
713 | keeptmpdir determines whether to keep the test's temporary directory | |
714 | after execution. It defaults to removal (False). |
|
714 | after execution. It defaults to removal (False). | |
715 |
|
715 | |||
716 | debug mode will make the test execute verbosely, with unfiltered |
|
716 | debug mode will make the test execute verbosely, with unfiltered | |
717 | output. |
|
717 | output. | |
718 |
|
718 | |||
719 | timeout controls the maximum run time of the test. It is ignored when |
|
719 | timeout controls the maximum run time of the test. It is ignored when | |
720 | debug is True. See slowtimeout for tests with #require slow. |
|
720 | debug is True. See slowtimeout for tests with #require slow. | |
721 |
|
721 | |||
722 | slowtimeout overrides timeout if the test has #require slow. |
|
722 | slowtimeout overrides timeout if the test has #require slow. | |
723 |
|
723 | |||
724 | startport controls the starting port number to use for this test. Each |
|
724 | startport controls the starting port number to use for this test. Each | |
725 | test will reserve 3 port numbers for execution. It is the caller's |
|
725 | test will reserve 3 port numbers for execution. It is the caller's | |
726 | responsibility to allocate a non-overlapping port range to Test |
|
726 | responsibility to allocate a non-overlapping port range to Test | |
727 | instances. |
|
727 | instances. | |
728 |
|
728 | |||
729 | extraconfigopts is an iterable of extra hgrc config options. Values |
|
729 | extraconfigopts is an iterable of extra hgrc config options. Values | |
730 | must have the form "key=value" (something understood by hgrc). Values |
|
730 | must have the form "key=value" (something understood by hgrc). Values | |
731 | of the form "foo.key=value" will result in "[foo] key=value". |
|
731 | of the form "foo.key=value" will result in "[foo] key=value". | |
732 |
|
732 | |||
733 | py3warnings enables Py3k warnings. |
|
733 | py3warnings enables Py3k warnings. | |
734 |
|
734 | |||
735 | shell is the shell to execute tests in. |
|
735 | shell is the shell to execute tests in. | |
736 | """ |
|
736 | """ | |
737 | if timeout is None: |
|
737 | if timeout is None: | |
738 | timeout = defaults['timeout'] |
|
738 | timeout = defaults['timeout'] | |
739 | if startport is None: |
|
739 | if startport is None: | |
740 | startport = defaults['port'] |
|
740 | startport = defaults['port'] | |
741 | if slowtimeout is None: |
|
741 | if slowtimeout is None: | |
742 | slowtimeout = defaults['slowtimeout'] |
|
742 | slowtimeout = defaults['slowtimeout'] | |
743 | self.path = path |
|
743 | self.path = path | |
744 | self.bname = os.path.basename(path) |
|
744 | self.bname = os.path.basename(path) | |
745 | self.name = _strpath(self.bname) |
|
745 | self.name = _strpath(self.bname) | |
746 | self._testdir = os.path.dirname(path) |
|
746 | self._testdir = os.path.dirname(path) | |
747 | self._outputdir = outputdir |
|
747 | self._outputdir = outputdir | |
748 | self._tmpname = os.path.basename(path) |
|
748 | self._tmpname = os.path.basename(path) | |
749 | self.errpath = os.path.join(self._outputdir, b'%s.err' % self.bname) |
|
749 | self.errpath = os.path.join(self._outputdir, b'%s.err' % self.bname) | |
750 |
|
750 | |||
751 | self._threadtmp = tmpdir |
|
751 | self._threadtmp = tmpdir | |
752 | self._keeptmpdir = keeptmpdir |
|
752 | self._keeptmpdir = keeptmpdir | |
753 | self._debug = debug |
|
753 | self._debug = debug | |
754 | self._first = first |
|
754 | self._first = first | |
755 | self._timeout = timeout |
|
755 | self._timeout = timeout | |
756 | self._slowtimeout = slowtimeout |
|
756 | self._slowtimeout = slowtimeout | |
757 | self._startport = startport |
|
757 | self._startport = startport | |
758 | self._extraconfigopts = extraconfigopts or [] |
|
758 | self._extraconfigopts = extraconfigopts or [] | |
759 | self._py3warnings = py3warnings |
|
759 | self._py3warnings = py3warnings | |
760 | self._shell = _bytespath(shell) |
|
760 | self._shell = _bytespath(shell) | |
761 | self._hgcommand = hgcommand or b'hg' |
|
761 | self._hgcommand = hgcommand or b'hg' | |
762 | self._usechg = usechg |
|
762 | self._usechg = usechg | |
763 | self._useipv6 = useipv6 |
|
763 | self._useipv6 = useipv6 | |
764 |
|
764 | |||
765 | self._aborted = False |
|
765 | self._aborted = False | |
766 | self._daemonpids = [] |
|
766 | self._daemonpids = [] | |
767 | self._finished = None |
|
767 | self._finished = None | |
768 | self._ret = None |
|
768 | self._ret = None | |
769 | self._out = None |
|
769 | self._out = None | |
770 | self._skipped = None |
|
770 | self._skipped = None | |
771 | self._testtmp = None |
|
771 | self._testtmp = None | |
772 | self._chgsockdir = None |
|
772 | self._chgsockdir = None | |
773 |
|
773 | |||
774 | self._refout = self.readrefout() |
|
774 | self._refout = self.readrefout() | |
775 |
|
775 | |||
776 | def readrefout(self): |
|
776 | def readrefout(self): | |
777 | """read reference output""" |
|
777 | """read reference output""" | |
778 | # If we're not in --debug mode and reference output file exists, |
|
778 | # If we're not in --debug mode and reference output file exists, | |
779 | # check test output against it. |
|
779 | # check test output against it. | |
780 | if self._debug: |
|
780 | if self._debug: | |
781 | return None # to match "out is None" |
|
781 | return None # to match "out is None" | |
782 | elif os.path.exists(self.refpath): |
|
782 | elif os.path.exists(self.refpath): | |
783 | with open(self.refpath, 'rb') as f: |
|
783 | with open(self.refpath, 'rb') as f: | |
784 | return f.read().splitlines(True) |
|
784 | return f.read().splitlines(True) | |
785 | else: |
|
785 | else: | |
786 | return [] |
|
786 | return [] | |
787 |
|
787 | |||
788 | # needed to get base class __repr__ running |
|
788 | # needed to get base class __repr__ running | |
789 | @property |
|
789 | @property | |
790 | def _testMethodName(self): |
|
790 | def _testMethodName(self): | |
791 | return self.name |
|
791 | return self.name | |
792 |
|
792 | |||
793 | def __str__(self): |
|
793 | def __str__(self): | |
794 | return self.name |
|
794 | return self.name | |
795 |
|
795 | |||
796 | def shortDescription(self): |
|
796 | def shortDescription(self): | |
797 | return self.name |
|
797 | return self.name | |
798 |
|
798 | |||
799 | def setUp(self): |
|
799 | def setUp(self): | |
800 | """Tasks to perform before run().""" |
|
800 | """Tasks to perform before run().""" | |
801 | self._finished = False |
|
801 | self._finished = False | |
802 | self._ret = None |
|
802 | self._ret = None | |
803 | self._out = None |
|
803 | self._out = None | |
804 | self._skipped = None |
|
804 | self._skipped = None | |
805 |
|
805 | |||
806 | try: |
|
806 | try: | |
807 | os.mkdir(self._threadtmp) |
|
807 | os.mkdir(self._threadtmp) | |
808 | except OSError as e: |
|
808 | except OSError as e: | |
809 | if e.errno != errno.EEXIST: |
|
809 | if e.errno != errno.EEXIST: | |
810 | raise |
|
810 | raise | |
811 |
|
811 | |||
812 | name = self._tmpname |
|
812 | name = self._tmpname | |
813 | self._testtmp = os.path.join(self._threadtmp, name) |
|
813 | self._testtmp = os.path.join(self._threadtmp, name) | |
814 | os.mkdir(self._testtmp) |
|
814 | os.mkdir(self._testtmp) | |
815 |
|
815 | |||
816 | # Remove any previous output files. |
|
816 | # Remove any previous output files. | |
817 | if os.path.exists(self.errpath): |
|
817 | if os.path.exists(self.errpath): | |
818 | try: |
|
818 | try: | |
819 | os.remove(self.errpath) |
|
819 | os.remove(self.errpath) | |
820 | except OSError as e: |
|
820 | except OSError as e: | |
821 | # We might have raced another test to clean up a .err |
|
821 | # We might have raced another test to clean up a .err | |
822 | # file, so ignore ENOENT when removing a previous .err |
|
822 | # file, so ignore ENOENT when removing a previous .err | |
823 | # file. |
|
823 | # file. | |
824 | if e.errno != errno.ENOENT: |
|
824 | if e.errno != errno.ENOENT: | |
825 | raise |
|
825 | raise | |
826 |
|
826 | |||
827 | if self._usechg: |
|
827 | if self._usechg: | |
828 | self._chgsockdir = os.path.join(self._threadtmp, |
|
828 | self._chgsockdir = os.path.join(self._threadtmp, | |
829 | b'%s.chgsock' % name) |
|
829 | b'%s.chgsock' % name) | |
830 | os.mkdir(self._chgsockdir) |
|
830 | os.mkdir(self._chgsockdir) | |
831 |
|
831 | |||
832 | def run(self, result): |
|
832 | def run(self, result): | |
833 | """Run this test and report results against a TestResult instance.""" |
|
833 | """Run this test and report results against a TestResult instance.""" | |
834 | # This function is extremely similar to unittest.TestCase.run(). Once |
|
834 | # This function is extremely similar to unittest.TestCase.run(). Once | |
835 | # we require Python 2.7 (or at least its version of unittest), this |
|
835 | # we require Python 2.7 (or at least its version of unittest), this | |
836 | # function can largely go away. |
|
836 | # function can largely go away. | |
837 | self._result = result |
|
837 | self._result = result | |
838 | result.startTest(self) |
|
838 | result.startTest(self) | |
839 | try: |
|
839 | try: | |
840 | try: |
|
840 | try: | |
841 | self.setUp() |
|
841 | self.setUp() | |
842 | except (KeyboardInterrupt, SystemExit): |
|
842 | except (KeyboardInterrupt, SystemExit): | |
843 | self._aborted = True |
|
843 | self._aborted = True | |
844 | raise |
|
844 | raise | |
845 | except Exception: |
|
845 | except Exception: | |
846 | result.addError(self, sys.exc_info()) |
|
846 | result.addError(self, sys.exc_info()) | |
847 | return |
|
847 | return | |
848 |
|
848 | |||
849 | success = False |
|
849 | success = False | |
850 | try: |
|
850 | try: | |
851 | self.runTest() |
|
851 | self.runTest() | |
852 | except KeyboardInterrupt: |
|
852 | except KeyboardInterrupt: | |
853 | self._aborted = True |
|
853 | self._aborted = True | |
854 | raise |
|
854 | raise | |
855 | except unittest.SkipTest as e: |
|
855 | except unittest.SkipTest as e: | |
856 | result.addSkip(self, str(e)) |
|
856 | result.addSkip(self, str(e)) | |
857 | # The base class will have already counted this as a |
|
857 | # The base class will have already counted this as a | |
858 | # test we "ran", but we want to exclude skipped tests |
|
858 | # test we "ran", but we want to exclude skipped tests | |
859 | # from those we count towards those run. |
|
859 | # from those we count towards those run. | |
860 | result.testsRun -= 1 |
|
860 | result.testsRun -= 1 | |
861 | except self.failureException as e: |
|
861 | except self.failureException as e: | |
862 | # This differs from unittest in that we don't capture |
|
862 | # This differs from unittest in that we don't capture | |
863 | # the stack trace. This is for historical reasons and |
|
863 | # the stack trace. This is for historical reasons and | |
864 | # this decision could be revisited in the future, |
|
864 | # this decision could be revisited in the future, | |
865 | # especially for PythonTest instances. |
|
865 | # especially for PythonTest instances. | |
866 | if result.addFailure(self, str(e)): |
|
866 | if result.addFailure(self, str(e)): | |
867 | success = True |
|
867 | success = True | |
868 | except Exception: |
|
868 | except Exception: | |
869 | result.addError(self, sys.exc_info()) |
|
869 | result.addError(self, sys.exc_info()) | |
870 | else: |
|
870 | else: | |
871 | success = True |
|
871 | success = True | |
872 |
|
872 | |||
873 | try: |
|
873 | try: | |
874 | self.tearDown() |
|
874 | self.tearDown() | |
875 | except (KeyboardInterrupt, SystemExit): |
|
875 | except (KeyboardInterrupt, SystemExit): | |
876 | self._aborted = True |
|
876 | self._aborted = True | |
877 | raise |
|
877 | raise | |
878 | except Exception: |
|
878 | except Exception: | |
879 | result.addError(self, sys.exc_info()) |
|
879 | result.addError(self, sys.exc_info()) | |
880 | success = False |
|
880 | success = False | |
881 |
|
881 | |||
882 | if success: |
|
882 | if success: | |
883 | result.addSuccess(self) |
|
883 | result.addSuccess(self) | |
884 | finally: |
|
884 | finally: | |
885 | result.stopTest(self, interrupted=self._aborted) |
|
885 | result.stopTest(self, interrupted=self._aborted) | |
886 |
|
886 | |||
887 | def runTest(self): |
|
887 | def runTest(self): | |
888 | """Run this test instance. |
|
888 | """Run this test instance. | |
889 |
|
889 | |||
890 | This will return a tuple describing the result of the test. |
|
890 | This will return a tuple describing the result of the test. | |
891 | """ |
|
891 | """ | |
892 | env = self._getenv() |
|
892 | env = self._getenv() | |
893 | self._genrestoreenv(env) |
|
893 | self._genrestoreenv(env) | |
894 | self._daemonpids.append(env['DAEMON_PIDS']) |
|
894 | self._daemonpids.append(env['DAEMON_PIDS']) | |
895 | self._createhgrc(env['HGRCPATH']) |
|
895 | self._createhgrc(env['HGRCPATH']) | |
896 |
|
896 | |||
897 | vlog('# Test', self.name) |
|
897 | vlog('# Test', self.name) | |
898 |
|
898 | |||
899 | ret, out = self._run(env) |
|
899 | ret, out = self._run(env) | |
900 | self._finished = True |
|
900 | self._finished = True | |
901 | self._ret = ret |
|
901 | self._ret = ret | |
902 | self._out = out |
|
902 | self._out = out | |
903 |
|
903 | |||
904 | def describe(ret): |
|
904 | def describe(ret): | |
905 | if ret < 0: |
|
905 | if ret < 0: | |
906 | return 'killed by signal: %d' % -ret |
|
906 | return 'killed by signal: %d' % -ret | |
907 | return 'returned error code %d' % ret |
|
907 | return 'returned error code %d' % ret | |
908 |
|
908 | |||
909 | self._skipped = False |
|
909 | self._skipped = False | |
910 |
|
910 | |||
911 | if ret == self.SKIPPED_STATUS: |
|
911 | if ret == self.SKIPPED_STATUS: | |
912 | if out is None: # Debug mode, nothing to parse. |
|
912 | if out is None: # Debug mode, nothing to parse. | |
913 | missing = ['unknown'] |
|
913 | missing = ['unknown'] | |
914 | failed = None |
|
914 | failed = None | |
915 | else: |
|
915 | else: | |
916 | missing, failed = TTest.parsehghaveoutput(out) |
|
916 | missing, failed = TTest.parsehghaveoutput(out) | |
917 |
|
917 | |||
918 | if not missing: |
|
918 | if not missing: | |
919 | missing = ['skipped'] |
|
919 | missing = ['skipped'] | |
920 |
|
920 | |||
921 | if failed: |
|
921 | if failed: | |
922 | self.fail('hg have failed checking for %s' % failed[-1]) |
|
922 | self.fail('hg have failed checking for %s' % failed[-1]) | |
923 | else: |
|
923 | else: | |
924 | self._skipped = True |
|
924 | self._skipped = True | |
925 | raise unittest.SkipTest(missing[-1]) |
|
925 | raise unittest.SkipTest(missing[-1]) | |
926 | elif ret == 'timeout': |
|
926 | elif ret == 'timeout': | |
927 | self.fail('timed out') |
|
927 | self.fail('timed out') | |
928 | elif ret is False: |
|
928 | elif ret is False: | |
929 | self.fail('no result code from test') |
|
929 | self.fail('no result code from test') | |
930 | elif out != self._refout: |
|
930 | elif out != self._refout: | |
931 | # Diff generation may rely on written .err file. |
|
931 | # Diff generation may rely on written .err file. | |
932 | if ((ret != 0 or out != self._refout) and not self._skipped |
|
932 | if ((ret != 0 or out != self._refout) and not self._skipped | |
933 | and not self._debug): |
|
933 | and not self._debug): | |
934 | with open(self.errpath, 'wb') as f: |
|
934 | with open(self.errpath, 'wb') as f: | |
935 | for line in out: |
|
935 | for line in out: | |
936 | f.write(line) |
|
936 | f.write(line) | |
937 |
|
937 | |||
938 | # The result object handles diff calculation for us. |
|
938 | # The result object handles diff calculation for us. | |
939 | with firstlock: |
|
939 | with firstlock: | |
940 | if self._result.addOutputMismatch(self, ret, out, self._refout): |
|
940 | if self._result.addOutputMismatch(self, ret, out, self._refout): | |
941 | # change was accepted, skip failing |
|
941 | # change was accepted, skip failing | |
942 | return |
|
942 | return | |
943 | if self._first: |
|
943 | if self._first: | |
944 | global firsterror |
|
944 | global firsterror | |
945 | firsterror = True |
|
945 | firsterror = True | |
946 |
|
946 | |||
947 | if ret: |
|
947 | if ret: | |
948 | msg = 'output changed and ' + describe(ret) |
|
948 | msg = 'output changed and ' + describe(ret) | |
949 | else: |
|
949 | else: | |
950 | msg = 'output changed' |
|
950 | msg = 'output changed' | |
951 |
|
951 | |||
952 | self.fail(msg) |
|
952 | self.fail(msg) | |
953 | elif ret: |
|
953 | elif ret: | |
954 | self.fail(describe(ret)) |
|
954 | self.fail(describe(ret)) | |
955 |
|
955 | |||
956 | def tearDown(self): |
|
956 | def tearDown(self): | |
957 | """Tasks to perform after run().""" |
|
957 | """Tasks to perform after run().""" | |
958 | for entry in self._daemonpids: |
|
958 | for entry in self._daemonpids: | |
959 | killdaemons(entry) |
|
959 | killdaemons(entry) | |
960 | self._daemonpids = [] |
|
960 | self._daemonpids = [] | |
961 |
|
961 | |||
962 | if self._keeptmpdir: |
|
962 | if self._keeptmpdir: | |
963 | log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' % |
|
963 | log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' % | |
964 | (self._testtmp.decode('utf-8'), |
|
964 | (self._testtmp.decode('utf-8'), | |
965 | self._threadtmp.decode('utf-8'))) |
|
965 | self._threadtmp.decode('utf-8'))) | |
966 | else: |
|
966 | else: | |
967 | try: |
|
967 | try: | |
968 | shutil.rmtree(self._testtmp) |
|
968 | shutil.rmtree(self._testtmp) | |
969 | except OSError: |
|
969 | except OSError: | |
970 | # unreadable directory may be left in $TESTTMP; fix permission |
|
970 | # unreadable directory may be left in $TESTTMP; fix permission | |
971 | # and try again |
|
971 | # and try again | |
972 | makecleanable(self._testtmp) |
|
972 | makecleanable(self._testtmp) | |
973 | shutil.rmtree(self._testtmp, True) |
|
973 | shutil.rmtree(self._testtmp, True) | |
974 | shutil.rmtree(self._threadtmp, True) |
|
974 | shutil.rmtree(self._threadtmp, True) | |
975 |
|
975 | |||
976 | if self._usechg: |
|
976 | if self._usechg: | |
977 | # chgservers will stop automatically after they find the socket |
|
977 | # chgservers will stop automatically after they find the socket | |
978 | # files are deleted |
|
978 | # files are deleted | |
979 | shutil.rmtree(self._chgsockdir, True) |
|
979 | shutil.rmtree(self._chgsockdir, True) | |
980 |
|
980 | |||
981 | if ((self._ret != 0 or self._out != self._refout) and not self._skipped |
|
981 | if ((self._ret != 0 or self._out != self._refout) and not self._skipped | |
982 | and not self._debug and self._out): |
|
982 | and not self._debug and self._out): | |
983 | with open(self.errpath, 'wb') as f: |
|
983 | with open(self.errpath, 'wb') as f: | |
984 | for line in self._out: |
|
984 | for line in self._out: | |
985 | f.write(line) |
|
985 | f.write(line) | |
986 |
|
986 | |||
987 | vlog("# Ret was:", self._ret, '(%s)' % self.name) |
|
987 | vlog("# Ret was:", self._ret, '(%s)' % self.name) | |
988 |
|
988 | |||
989 | def _run(self, env): |
|
989 | def _run(self, env): | |
990 | # This should be implemented in child classes to run tests. |
|
990 | # This should be implemented in child classes to run tests. | |
991 | raise unittest.SkipTest('unknown test type') |
|
991 | raise unittest.SkipTest('unknown test type') | |
992 |
|
992 | |||
993 | def abort(self): |
|
993 | def abort(self): | |
994 | """Terminate execution of this test.""" |
|
994 | """Terminate execution of this test.""" | |
995 | self._aborted = True |
|
995 | self._aborted = True | |
996 |
|
996 | |||
997 | def _portmap(self, i): |
|
997 | def _portmap(self, i): | |
998 | offset = b'' if i == 0 else b'%d' % i |
|
998 | offset = b'' if i == 0 else b'%d' % i | |
999 | return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset) |
|
999 | return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset) | |
1000 |
|
1000 | |||
1001 | def _getreplacements(self): |
|
1001 | def _getreplacements(self): | |
1002 | """Obtain a mapping of text replacements to apply to test output. |
|
1002 | """Obtain a mapping of text replacements to apply to test output. | |
1003 |
|
1003 | |||
1004 | Test output needs to be normalized so it can be compared to expected |
|
1004 | Test output needs to be normalized so it can be compared to expected | |
1005 | output. This function defines how some of that normalization will |
|
1005 | output. This function defines how some of that normalization will | |
1006 | occur. |
|
1006 | occur. | |
1007 | """ |
|
1007 | """ | |
1008 | r = [ |
|
1008 | r = [ | |
1009 | # This list should be parallel to defineport in _getenv |
|
1009 | # This list should be parallel to defineport in _getenv | |
1010 | self._portmap(0), |
|
1010 | self._portmap(0), | |
1011 | self._portmap(1), |
|
1011 | self._portmap(1), | |
1012 | self._portmap(2), |
|
1012 | self._portmap(2), | |
1013 | (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'), |
|
1013 | (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'), | |
1014 | (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'), |
|
1014 | (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'), | |
1015 | ] |
|
1015 | ] | |
1016 | r.append((self._escapepath(self._testtmp), b'$TESTTMP')) |
|
1016 | r.append((self._escapepath(self._testtmp), b'$TESTTMP')) | |
1017 |
|
1017 | |||
1018 | replacementfile = os.path.join(self._testdir, b'common-pattern.py') |
|
1018 | replacementfile = os.path.join(self._testdir, b'common-pattern.py') | |
1019 |
|
1019 | |||
1020 | if os.path.exists(replacementfile): |
|
1020 | if os.path.exists(replacementfile): | |
1021 | data = {} |
|
1021 | data = {} | |
1022 | with open(replacementfile, mode='rb') as source: |
|
1022 | with open(replacementfile, mode='rb') as source: | |
1023 | # the intermediate 'compile' step help with debugging |
|
1023 | # the intermediate 'compile' step help with debugging | |
1024 | code = compile(source.read(), replacementfile, 'exec') |
|
1024 | code = compile(source.read(), replacementfile, 'exec') | |
1025 | exec(code, data) |
|
1025 | exec(code, data) | |
1026 | for value in data.get('substitutions', ()): |
|
1026 | for value in data.get('substitutions', ()): | |
1027 | if len(value) != 2: |
|
1027 | if len(value) != 2: | |
1028 | msg = 'malformatted substitution in %s: %r' |
|
1028 | msg = 'malformatted substitution in %s: %r' | |
1029 | msg %= (replacementfile, value) |
|
1029 | msg %= (replacementfile, value) | |
1030 | raise ValueError(msg) |
|
1030 | raise ValueError(msg) | |
1031 | r.append(value) |
|
1031 | r.append(value) | |
1032 | return r |
|
1032 | return r | |
1033 |
|
1033 | |||
1034 | def _escapepath(self, p): |
|
1034 | def _escapepath(self, p): | |
1035 | if os.name == 'nt': |
|
1035 | if os.name == 'nt': | |
1036 | return ( |
|
1036 | return ( | |
1037 | (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or |
|
1037 | (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or | |
1038 | c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c |
|
1038 | c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c | |
1039 | for c in [p[i:i + 1] for i in range(len(p))])) |
|
1039 | for c in [p[i:i + 1] for i in range(len(p))])) | |
1040 | ) |
|
1040 | ) | |
1041 | else: |
|
1041 | else: | |
1042 | return re.escape(p) |
|
1042 | return re.escape(p) | |
1043 |
|
1043 | |||
1044 | def _localip(self): |
|
1044 | def _localip(self): | |
1045 | if self._useipv6: |
|
1045 | if self._useipv6: | |
1046 | return b'::1' |
|
1046 | return b'::1' | |
1047 | else: |
|
1047 | else: | |
1048 | return b'127.0.0.1' |
|
1048 | return b'127.0.0.1' | |
1049 |
|
1049 | |||
1050 | def _genrestoreenv(self, testenv): |
|
1050 | def _genrestoreenv(self, testenv): | |
1051 | """Generate a script that can be used by tests to restore the original |
|
1051 | """Generate a script that can be used by tests to restore the original | |
1052 | environment.""" |
|
1052 | environment.""" | |
1053 | # Put the restoreenv script inside self._threadtmp |
|
1053 | # Put the restoreenv script inside self._threadtmp | |
1054 | scriptpath = os.path.join(self._threadtmp, b'restoreenv.sh') |
|
1054 | scriptpath = os.path.join(self._threadtmp, b'restoreenv.sh') | |
1055 | testenv['HGTEST_RESTOREENV'] = _strpath(scriptpath) |
|
1055 | testenv['HGTEST_RESTOREENV'] = _strpath(scriptpath) | |
1056 |
|
1056 | |||
1057 | # Only restore environment variable names that the shell allows |
|
1057 | # Only restore environment variable names that the shell allows | |
1058 | # us to export. |
|
1058 | # us to export. | |
1059 | name_regex = re.compile('^[a-zA-Z][a-zA-Z0-9_]*$') |
|
1059 | name_regex = re.compile('^[a-zA-Z][a-zA-Z0-9_]*$') | |
1060 |
|
1060 | |||
1061 | # Do not restore these variables; otherwise tests would fail. |
|
1061 | # Do not restore these variables; otherwise tests would fail. | |
1062 | reqnames = {'PYTHON', 'TESTDIR', 'TESTTMP'} |
|
1062 | reqnames = {'PYTHON', 'TESTDIR', 'TESTTMP'} | |
1063 |
|
1063 | |||
1064 | with open(scriptpath, 'w') as envf: |
|
1064 | with open(scriptpath, 'w') as envf: | |
1065 | for name, value in origenviron.items(): |
|
1065 | for name, value in origenviron.items(): | |
1066 | if not name_regex.match(name): |
|
1066 | if not name_regex.match(name): | |
1067 | # Skip environment variables with unusual names not |
|
1067 | # Skip environment variables with unusual names not | |
1068 | # allowed by most shells. |
|
1068 | # allowed by most shells. | |
1069 | continue |
|
1069 | continue | |
1070 | if name in reqnames: |
|
1070 | if name in reqnames: | |
1071 | continue |
|
1071 | continue | |
1072 | envf.write('%s=%s\n' % (name, shellquote(value))) |
|
1072 | envf.write('%s=%s\n' % (name, shellquote(value))) | |
1073 |
|
1073 | |||
1074 | for name in testenv: |
|
1074 | for name in testenv: | |
1075 | if name in origenviron or name in reqnames: |
|
1075 | if name in origenviron or name in reqnames: | |
1076 | continue |
|
1076 | continue | |
1077 | envf.write('unset %s\n' % (name,)) |
|
1077 | envf.write('unset %s\n' % (name,)) | |
1078 |
|
1078 | |||
1079 | def _getenv(self): |
|
1079 | def _getenv(self): | |
1080 | """Obtain environment variables to use during test execution.""" |
|
1080 | """Obtain environment variables to use during test execution.""" | |
1081 | def defineport(i): |
|
1081 | def defineport(i): | |
1082 | offset = '' if i == 0 else '%s' % i |
|
1082 | offset = '' if i == 0 else '%s' % i | |
1083 | env["HGPORT%s" % offset] = '%s' % (self._startport + i) |
|
1083 | env["HGPORT%s" % offset] = '%s' % (self._startport + i) | |
1084 | env = os.environ.copy() |
|
1084 | env = os.environ.copy() | |
1085 | env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or '' |
|
1085 | env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or '' | |
1086 | env['HGEMITWARNINGS'] = '1' |
|
1086 | env['HGEMITWARNINGS'] = '1' | |
1087 | env['TESTTMP'] = _strpath(self._testtmp) |
|
1087 | env['TESTTMP'] = _strpath(self._testtmp) | |
1088 | env['TESTNAME'] = self.name |
|
1088 | env['TESTNAME'] = self.name | |
1089 | env['HOME'] = _strpath(self._testtmp) |
|
1089 | env['HOME'] = _strpath(self._testtmp) | |
1090 | # This number should match portneeded in _getport |
|
1090 | # This number should match portneeded in _getport | |
1091 | for port in xrange(3): |
|
1091 | for port in xrange(3): | |
1092 | # This list should be parallel to _portmap in _getreplacements |
|
1092 | # This list should be parallel to _portmap in _getreplacements | |
1093 | defineport(port) |
|
1093 | defineport(port) | |
1094 | env["HGRCPATH"] = _strpath(os.path.join(self._threadtmp, b'.hgrc')) |
|
1094 | env["HGRCPATH"] = _strpath(os.path.join(self._threadtmp, b'.hgrc')) | |
1095 | env["DAEMON_PIDS"] = _strpath(os.path.join(self._threadtmp, |
|
1095 | env["DAEMON_PIDS"] = _strpath(os.path.join(self._threadtmp, | |
1096 | b'daemon.pids')) |
|
1096 | b'daemon.pids')) | |
1097 | env["HGEDITOR"] = ('"' + sys.executable + '"' |
|
1097 | env["HGEDITOR"] = ('"' + sys.executable + '"' | |
1098 | + ' -c "import sys; sys.exit(0)"') |
|
1098 | + ' -c "import sys; sys.exit(0)"') | |
1099 | env["HGUSER"] = "test" |
|
1099 | env["HGUSER"] = "test" | |
1100 | env["HGENCODING"] = "ascii" |
|
1100 | env["HGENCODING"] = "ascii" | |
1101 | env["HGENCODINGMODE"] = "strict" |
|
1101 | env["HGENCODINGMODE"] = "strict" | |
1102 | env["HGHOSTNAME"] = "test-hostname" |
|
1102 | env["HGHOSTNAME"] = "test-hostname" | |
1103 | env['HGIPV6'] = str(int(self._useipv6)) |
|
1103 | env['HGIPV6'] = str(int(self._useipv6)) | |
1104 | # See contrib/catapipe.py for how to use this functionality. |
|
1104 | # See contrib/catapipe.py for how to use this functionality. | |
1105 | if 'HGTESTCATAPULTSERVERPIPE' not in env: |
|
1105 | if 'HGTESTCATAPULTSERVERPIPE' not in env: | |
1106 | # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the |
|
1106 | # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the | |
1107 | # non-test one in as a default, otherwise set to devnull |
|
1107 | # non-test one in as a default, otherwise set to devnull | |
1108 | env['HGTESTCATAPULTSERVERPIPE'] = env.get( |
|
1108 | env['HGTESTCATAPULTSERVERPIPE'] = env.get( | |
1109 | 'HGCATAPULTSERVERPIPE', os.devnull) |
|
1109 | 'HGCATAPULTSERVERPIPE', os.devnull) | |
1110 |
|
1110 | |||
1111 | extraextensions = [] |
|
1111 | extraextensions = [] | |
1112 | for opt in self._extraconfigopts: |
|
1112 | for opt in self._extraconfigopts: | |
1113 | section, key = opt.encode('utf-8').split(b'.', 1) |
|
1113 | section, key = opt.encode('utf-8').split(b'.', 1) | |
1114 | if section != 'extensions': |
|
1114 | if section != 'extensions': | |
1115 | continue |
|
1115 | continue | |
1116 | name = key.split(b'=', 1)[0] |
|
1116 | name = key.split(b'=', 1)[0] | |
1117 | extraextensions.append(name) |
|
1117 | extraextensions.append(name) | |
1118 |
|
1118 | |||
1119 | if extraextensions: |
|
1119 | if extraextensions: | |
1120 | env['HGTESTEXTRAEXTENSIONS'] = b' '.join(extraextensions) |
|
1120 | env['HGTESTEXTRAEXTENSIONS'] = b' '.join(extraextensions) | |
1121 |
|
1121 | |||
1122 | # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw |
|
1122 | # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw | |
1123 | # IP addresses. |
|
1123 | # IP addresses. | |
1124 | env['LOCALIP'] = _strpath(self._localip()) |
|
1124 | env['LOCALIP'] = _strpath(self._localip()) | |
1125 |
|
1125 | |||
1126 | # This has the same effect as Py_LegacyWindowsStdioFlag in exewrapper.c, |
|
1126 | # This has the same effect as Py_LegacyWindowsStdioFlag in exewrapper.c, | |
1127 | # but this is needed for testing python instances like dummyssh, |
|
1127 | # but this is needed for testing python instances like dummyssh, | |
1128 | # dummysmtpd.py, and dumbhttp.py. |
|
1128 | # dummysmtpd.py, and dumbhttp.py. | |
1129 | if PYTHON3 and os.name == 'nt': |
|
1129 | if PYTHON3 and os.name == 'nt': | |
1130 | env['PYTHONLEGACYWINDOWSSTDIO'] = '1' |
|
1130 | env['PYTHONLEGACYWINDOWSSTDIO'] = '1' | |
1131 |
|
1131 | |||
1132 | # Reset some environment variables to well-known values so that |
|
1132 | # Reset some environment variables to well-known values so that | |
1133 | # the tests produce repeatable output. |
|
1133 | # the tests produce repeatable output. | |
1134 | env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C' |
|
1134 | env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C' | |
1135 | env['TZ'] = 'GMT' |
|
1135 | env['TZ'] = 'GMT' | |
1136 | env["EMAIL"] = "Foo Bar <foo.bar@example.com>" |
|
1136 | env["EMAIL"] = "Foo Bar <foo.bar@example.com>" | |
1137 | env['COLUMNS'] = '80' |
|
1137 | env['COLUMNS'] = '80' | |
1138 | env['TERM'] = 'xterm' |
|
1138 | env['TERM'] = 'xterm' | |
1139 |
|
1139 | |||
1140 | dropped = [ |
|
1140 | dropped = [ | |
1141 | 'CDPATH', |
|
1141 | 'CDPATH', | |
1142 | 'CHGDEBUG', |
|
1142 | 'CHGDEBUG', | |
1143 | 'EDITOR', |
|
1143 | 'EDITOR', | |
1144 | 'GREP_OPTIONS', |
|
1144 | 'GREP_OPTIONS', | |
1145 | 'HG', |
|
1145 | 'HG', | |
1146 | 'HGMERGE', |
|
1146 | 'HGMERGE', | |
1147 | 'HGPLAIN', |
|
1147 | 'HGPLAIN', | |
1148 | 'HGPLAINEXCEPT', |
|
1148 | 'HGPLAINEXCEPT', | |
1149 | 'HGPROF', |
|
1149 | 'HGPROF', | |
1150 | 'http_proxy', |
|
1150 | 'http_proxy', | |
1151 | 'no_proxy', |
|
1151 | 'no_proxy', | |
1152 | 'NO_PROXY', |
|
1152 | 'NO_PROXY', | |
1153 | 'PAGER', |
|
1153 | 'PAGER', | |
1154 | 'VISUAL', |
|
1154 | 'VISUAL', | |
1155 | ] |
|
1155 | ] | |
1156 |
|
1156 | |||
1157 | for k in dropped: |
|
1157 | for k in dropped: | |
1158 | if k in env: |
|
1158 | if k in env: | |
1159 | del env[k] |
|
1159 | del env[k] | |
1160 |
|
1160 | |||
1161 | # unset env related to hooks |
|
1161 | # unset env related to hooks | |
1162 | for k in list(env): |
|
1162 | for k in list(env): | |
1163 | if k.startswith('HG_'): |
|
1163 | if k.startswith('HG_'): | |
1164 | del env[k] |
|
1164 | del env[k] | |
1165 |
|
1165 | |||
1166 | if self._usechg: |
|
1166 | if self._usechg: | |
1167 | env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server') |
|
1167 | env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server') | |
1168 |
|
1168 | |||
1169 | return env |
|
1169 | return env | |
1170 |
|
1170 | |||
1171 | def _createhgrc(self, path): |
|
1171 | def _createhgrc(self, path): | |
1172 | """Create an hgrc file for this test.""" |
|
1172 | """Create an hgrc file for this test.""" | |
1173 | with open(path, 'wb') as hgrc: |
|
1173 | with open(path, 'wb') as hgrc: | |
1174 | hgrc.write(b'[ui]\n') |
|
1174 | hgrc.write(b'[ui]\n') | |
1175 | hgrc.write(b'slash = True\n') |
|
1175 | hgrc.write(b'slash = True\n') | |
1176 | hgrc.write(b'interactive = False\n') |
|
1176 | hgrc.write(b'interactive = False\n') | |
1177 | hgrc.write(b'merge = internal:merge\n') |
|
1177 | hgrc.write(b'merge = internal:merge\n') | |
1178 | hgrc.write(b'mergemarkers = detailed\n') |
|
1178 | hgrc.write(b'mergemarkers = detailed\n') | |
1179 | hgrc.write(b'promptecho = True\n') |
|
1179 | hgrc.write(b'promptecho = True\n') | |
1180 | hgrc.write(b'[defaults]\n') |
|
1180 | hgrc.write(b'[defaults]\n') | |
1181 | hgrc.write(b'[devel]\n') |
|
1181 | hgrc.write(b'[devel]\n') | |
1182 | hgrc.write(b'all-warnings = true\n') |
|
1182 | hgrc.write(b'all-warnings = true\n') | |
1183 | hgrc.write(b'default-date = 0 0\n') |
|
1183 | hgrc.write(b'default-date = 0 0\n') | |
1184 | hgrc.write(b'[largefiles]\n') |
|
1184 | hgrc.write(b'[largefiles]\n') | |
1185 | hgrc.write(b'usercache = %s\n' % |
|
1185 | hgrc.write(b'usercache = %s\n' % | |
1186 | (os.path.join(self._testtmp, b'.cache/largefiles'))) |
|
1186 | (os.path.join(self._testtmp, b'.cache/largefiles'))) | |
1187 | hgrc.write(b'[lfs]\n') |
|
1187 | hgrc.write(b'[lfs]\n') | |
1188 | hgrc.write(b'usercache = %s\n' % |
|
1188 | hgrc.write(b'usercache = %s\n' % | |
1189 | (os.path.join(self._testtmp, b'.cache/lfs'))) |
|
1189 | (os.path.join(self._testtmp, b'.cache/lfs'))) | |
1190 | hgrc.write(b'[web]\n') |
|
1190 | hgrc.write(b'[web]\n') | |
1191 | hgrc.write(b'address = localhost\n') |
|
1191 | hgrc.write(b'address = localhost\n') | |
1192 | hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii')) |
|
1192 | hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii')) | |
1193 | hgrc.write(b'server-header = testing stub value\n') |
|
1193 | hgrc.write(b'server-header = testing stub value\n') | |
1194 |
|
1194 | |||
1195 | for opt in self._extraconfigopts: |
|
1195 | for opt in self._extraconfigopts: | |
1196 | section, key = opt.encode('utf-8').split(b'.', 1) |
|
1196 | section, key = opt.encode('utf-8').split(b'.', 1) | |
1197 | assert b'=' in key, ('extra config opt %s must ' |
|
1197 | assert b'=' in key, ('extra config opt %s must ' | |
1198 | 'have an = for assignment' % opt) |
|
1198 | 'have an = for assignment' % opt) | |
1199 | hgrc.write(b'[%s]\n%s\n' % (section, key)) |
|
1199 | hgrc.write(b'[%s]\n%s\n' % (section, key)) | |
1200 |
|
1200 | |||
1201 | def fail(self, msg): |
|
1201 | def fail(self, msg): | |
1202 | # unittest differentiates between errored and failed. |
|
1202 | # unittest differentiates between errored and failed. | |
1203 | # Failed is denoted by AssertionError (by default at least). |
|
1203 | # Failed is denoted by AssertionError (by default at least). | |
1204 | raise AssertionError(msg) |
|
1204 | raise AssertionError(msg) | |
1205 |
|
1205 | |||
1206 | def _runcommand(self, cmd, env, normalizenewlines=False): |
|
1206 | def _runcommand(self, cmd, env, normalizenewlines=False): | |
1207 | """Run command in a sub-process, capturing the output (stdout and |
|
1207 | """Run command in a sub-process, capturing the output (stdout and | |
1208 | stderr). |
|
1208 | stderr). | |
1209 |
|
1209 | |||
1210 | Return a tuple (exitcode, output). output is None in debug mode. |
|
1210 | Return a tuple (exitcode, output). output is None in debug mode. | |
1211 | """ |
|
1211 | """ | |
1212 | if self._debug: |
|
1212 | if self._debug: | |
1213 | proc = subprocess.Popen(_strpath(cmd), shell=True, |
|
1213 | proc = subprocess.Popen(_strpath(cmd), shell=True, | |
1214 | cwd=_strpath(self._testtmp), |
|
1214 | cwd=_strpath(self._testtmp), | |
1215 | env=env) |
|
1215 | env=env) | |
1216 | ret = proc.wait() |
|
1216 | ret = proc.wait() | |
1217 | return (ret, None) |
|
1217 | return (ret, None) | |
1218 |
|
1218 | |||
1219 | proc = Popen4(cmd, self._testtmp, self._timeout, env) |
|
1219 | proc = Popen4(cmd, self._testtmp, self._timeout, env) | |
1220 | def cleanup(): |
|
1220 | def cleanup(): | |
1221 | terminate(proc) |
|
1221 | terminate(proc) | |
1222 | ret = proc.wait() |
|
1222 | ret = proc.wait() | |
1223 | if ret == 0: |
|
1223 | if ret == 0: | |
1224 | ret = signal.SIGTERM << 8 |
|
1224 | ret = signal.SIGTERM << 8 | |
1225 | killdaemons(env['DAEMON_PIDS']) |
|
1225 | killdaemons(env['DAEMON_PIDS']) | |
1226 | return ret |
|
1226 | return ret | |
1227 |
|
1227 | |||
1228 | proc.tochild.close() |
|
1228 | proc.tochild.close() | |
1229 |
|
1229 | |||
1230 | try: |
|
1230 | try: | |
1231 | output = proc.fromchild.read() |
|
1231 | output = proc.fromchild.read() | |
1232 | except KeyboardInterrupt: |
|
1232 | except KeyboardInterrupt: | |
1233 | vlog('# Handling keyboard interrupt') |
|
1233 | vlog('# Handling keyboard interrupt') | |
1234 | cleanup() |
|
1234 | cleanup() | |
1235 | raise |
|
1235 | raise | |
1236 |
|
1236 | |||
1237 | ret = proc.wait() |
|
1237 | ret = proc.wait() | |
1238 | if wifexited(ret): |
|
1238 | if wifexited(ret): | |
1239 | ret = os.WEXITSTATUS(ret) |
|
1239 | ret = os.WEXITSTATUS(ret) | |
1240 |
|
1240 | |||
1241 | if proc.timeout: |
|
1241 | if proc.timeout: | |
1242 | ret = 'timeout' |
|
1242 | ret = 'timeout' | |
1243 |
|
1243 | |||
1244 | if ret: |
|
1244 | if ret: | |
1245 | killdaemons(env['DAEMON_PIDS']) |
|
1245 | killdaemons(env['DAEMON_PIDS']) | |
1246 |
|
1246 | |||
1247 | for s, r in self._getreplacements(): |
|
1247 | for s, r in self._getreplacements(): | |
1248 | output = re.sub(s, r, output) |
|
1248 | output = re.sub(s, r, output) | |
1249 |
|
1249 | |||
1250 | if normalizenewlines: |
|
1250 | if normalizenewlines: | |
1251 | output = output.replace(b'\r\n', b'\n') |
|
1251 | output = output.replace(b'\r\n', b'\n') | |
1252 |
|
1252 | |||
1253 | return ret, output.splitlines(True) |
|
1253 | return ret, output.splitlines(True) | |
1254 |
|
1254 | |||
1255 | class PythonTest(Test): |
|
1255 | class PythonTest(Test): | |
1256 | """A Python-based test.""" |
|
1256 | """A Python-based test.""" | |
1257 |
|
1257 | |||
1258 | @property |
|
1258 | @property | |
1259 | def refpath(self): |
|
1259 | def refpath(self): | |
1260 | return os.path.join(self._testdir, b'%s.out' % self.bname) |
|
1260 | return os.path.join(self._testdir, b'%s.out' % self.bname) | |
1261 |
|
1261 | |||
1262 | def _run(self, env): |
|
1262 | def _run(self, env): | |
1263 | py3switch = self._py3warnings and b' -3' or b'' |
|
1263 | py3switch = self._py3warnings and b' -3' or b'' | |
1264 | # Quote the python(3) executable for Windows |
|
1264 | # Quote the python(3) executable for Windows | |
1265 | cmd = b'"%s"%s "%s"' % (PYTHON, py3switch, self.path) |
|
1265 | cmd = b'"%s"%s "%s"' % (PYTHON, py3switch, self.path) | |
1266 | vlog("# Running", cmd) |
|
1266 | vlog("# Running", cmd) | |
1267 | normalizenewlines = os.name == 'nt' |
|
1267 | normalizenewlines = os.name == 'nt' | |
1268 | result = self._runcommand(cmd, env, |
|
1268 | result = self._runcommand(cmd, env, | |
1269 | normalizenewlines=normalizenewlines) |
|
1269 | normalizenewlines=normalizenewlines) | |
1270 | if self._aborted: |
|
1270 | if self._aborted: | |
1271 | raise KeyboardInterrupt() |
|
1271 | raise KeyboardInterrupt() | |
1272 |
|
1272 | |||
1273 | return result |
|
1273 | return result | |
1274 |
|
1274 | |||
1275 | # Some glob patterns apply only in some circumstances, so the script |
|
1275 | # Some glob patterns apply only in some circumstances, so the script | |
1276 | # might want to remove (glob) annotations that otherwise should be |
|
1276 | # might want to remove (glob) annotations that otherwise should be | |
1277 | # retained. |
|
1277 | # retained. | |
1278 | checkcodeglobpats = [ |
|
1278 | checkcodeglobpats = [ | |
1279 | # On Windows it looks like \ doesn't require a (glob), but we know |
|
1279 | # On Windows it looks like \ doesn't require a (glob), but we know | |
1280 | # better. |
|
1280 | # better. | |
1281 | re.compile(br'^pushing to \$TESTTMP/.*[^)]$'), |
|
1281 | re.compile(br'^pushing to \$TESTTMP/.*[^)]$'), | |
1282 | re.compile(br'^moving \S+/.*[^)]$'), |
|
1282 | re.compile(br'^moving \S+/.*[^)]$'), | |
1283 | re.compile(br'^pulling from \$TESTTMP/.*[^)]$'), |
|
1283 | re.compile(br'^pulling from \$TESTTMP/.*[^)]$'), | |
1284 | # Not all platforms have 127.0.0.1 as loopback (though most do), |
|
1284 | # Not all platforms have 127.0.0.1 as loopback (though most do), | |
1285 | # so we always glob that too. |
|
1285 | # so we always glob that too. | |
1286 | re.compile(br'.*\$LOCALIP.*$'), |
|
1286 | re.compile(br'.*\$LOCALIP.*$'), | |
1287 | ] |
|
1287 | ] | |
1288 |
|
1288 | |||
1289 | bchr = chr |
|
1289 | bchr = chr | |
1290 | if PYTHON3: |
|
1290 | if PYTHON3: | |
1291 | bchr = lambda x: bytes([x]) |
|
1291 | bchr = lambda x: bytes([x]) | |
1292 |
|
1292 | |||
1293 | class TTest(Test): |
|
1293 | class TTest(Test): | |
1294 | """A "t test" is a test backed by a .t file.""" |
|
1294 | """A "t test" is a test backed by a .t file.""" | |
1295 |
|
1295 | |||
1296 | SKIPPED_PREFIX = b'skipped: ' |
|
1296 | SKIPPED_PREFIX = b'skipped: ' | |
1297 | FAILED_PREFIX = b'hghave check failed: ' |
|
1297 | FAILED_PREFIX = b'hghave check failed: ' | |
1298 | NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search |
|
1298 | NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search | |
1299 |
|
1299 | |||
1300 | ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub |
|
1300 | ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub | |
1301 | ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256)) |
|
1301 | ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256)) | |
1302 | ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'}) |
|
1302 | ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'}) | |
1303 |
|
1303 | |||
1304 | def __init__(self, path, *args, **kwds): |
|
1304 | def __init__(self, path, *args, **kwds): | |
1305 | # accept an extra "case" parameter |
|
1305 | # accept an extra "case" parameter | |
1306 | case = kwds.pop('case', []) |
|
1306 | case = kwds.pop('case', []) | |
1307 | self._case = case |
|
1307 | self._case = case | |
1308 | self._allcases = {x for y in parsettestcases(path) for x in y} |
|
1308 | self._allcases = {x for y in parsettestcases(path) for x in y} | |
1309 | super(TTest, self).__init__(path, *args, **kwds) |
|
1309 | super(TTest, self).__init__(path, *args, **kwds) | |
1310 | if case: |
|
1310 | if case: | |
1311 | casepath = b'#'.join(case) |
|
1311 | casepath = b'#'.join(case) | |
1312 | self.name = '%s#%s' % (self.name, _strpath(casepath)) |
|
1312 | self.name = '%s#%s' % (self.name, _strpath(casepath)) | |
1313 | self.errpath = b'%s#%s.err' % (self.errpath[:-4], casepath) |
|
1313 | self.errpath = b'%s#%s.err' % (self.errpath[:-4], casepath) | |
1314 | self._tmpname += b'-%s' % casepath |
|
1314 | self._tmpname += b'-%s' % casepath | |
1315 | self._have = {} |
|
1315 | self._have = {} | |
1316 |
|
1316 | |||
1317 | @property |
|
1317 | @property | |
1318 | def refpath(self): |
|
1318 | def refpath(self): | |
1319 | return os.path.join(self._testdir, self.bname) |
|
1319 | return os.path.join(self._testdir, self.bname) | |
1320 |
|
1320 | |||
1321 | def _run(self, env): |
|
1321 | def _run(self, env): | |
1322 | with open(self.path, 'rb') as f: |
|
1322 | with open(self.path, 'rb') as f: | |
1323 | lines = f.readlines() |
|
1323 | lines = f.readlines() | |
1324 |
|
1324 | |||
1325 | # .t file is both reference output and the test input, keep reference |
|
1325 | # .t file is both reference output and the test input, keep reference | |
1326 | # output updated with the the test input. This avoids some race |
|
1326 | # output updated with the the test input. This avoids some race | |
1327 | # conditions where the reference output does not match the actual test. |
|
1327 | # conditions where the reference output does not match the actual test. | |
1328 | if self._refout is not None: |
|
1328 | if self._refout is not None: | |
1329 | self._refout = lines |
|
1329 | self._refout = lines | |
1330 |
|
1330 | |||
1331 | salt, script, after, expected = self._parsetest(lines) |
|
1331 | salt, script, after, expected = self._parsetest(lines) | |
1332 |
|
1332 | |||
1333 | # Write out the generated script. |
|
1333 | # Write out the generated script. | |
1334 | fname = b'%s.sh' % self._testtmp |
|
1334 | fname = b'%s.sh' % self._testtmp | |
1335 | with open(fname, 'wb') as f: |
|
1335 | with open(fname, 'wb') as f: | |
1336 | for l in script: |
|
1336 | for l in script: | |
1337 | f.write(l) |
|
1337 | f.write(l) | |
1338 |
|
1338 | |||
1339 | cmd = b'%s "%s"' % (self._shell, fname) |
|
1339 | cmd = b'%s "%s"' % (self._shell, fname) | |
1340 | vlog("# Running", cmd) |
|
1340 | vlog("# Running", cmd) | |
1341 |
|
1341 | |||
1342 | exitcode, output = self._runcommand(cmd, env) |
|
1342 | exitcode, output = self._runcommand(cmd, env) | |
1343 |
|
1343 | |||
1344 | if self._aborted: |
|
1344 | if self._aborted: | |
1345 | raise KeyboardInterrupt() |
|
1345 | raise KeyboardInterrupt() | |
1346 |
|
1346 | |||
1347 | # Do not merge output if skipped. Return hghave message instead. |
|
1347 | # Do not merge output if skipped. Return hghave message instead. | |
1348 | # Similarly, with --debug, output is None. |
|
1348 | # Similarly, with --debug, output is None. | |
1349 | if exitcode == self.SKIPPED_STATUS or output is None: |
|
1349 | if exitcode == self.SKIPPED_STATUS or output is None: | |
1350 | return exitcode, output |
|
1350 | return exitcode, output | |
1351 |
|
1351 | |||
1352 | return self._processoutput(exitcode, output, salt, after, expected) |
|
1352 | return self._processoutput(exitcode, output, salt, after, expected) | |
1353 |
|
1353 | |||
1354 | def _hghave(self, reqs): |
|
1354 | def _hghave(self, reqs): | |
1355 | allreqs = b' '.join(reqs) |
|
1355 | allreqs = b' '.join(reqs) | |
1356 |
|
1356 | |||
1357 | self._detectslow(reqs) |
|
1357 | self._detectslow(reqs) | |
1358 |
|
1358 | |||
1359 | if allreqs in self._have: |
|
1359 | if allreqs in self._have: | |
1360 | return self._have.get(allreqs) |
|
1360 | return self._have.get(allreqs) | |
1361 |
|
1361 | |||
1362 | # TODO do something smarter when all other uses of hghave are gone. |
|
1362 | # TODO do something smarter when all other uses of hghave are gone. | |
1363 | runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__))) |
|
1363 | runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__))) | |
1364 | tdir = runtestdir.replace(b'\\', b'/') |
|
1364 | tdir = runtestdir.replace(b'\\', b'/') | |
1365 | proc = Popen4(b'%s -c "%s/hghave %s"' % |
|
1365 | proc = Popen4(b'%s -c "%s/hghave %s"' % | |
1366 | (self._shell, tdir, allreqs), |
|
1366 | (self._shell, tdir, allreqs), | |
1367 | self._testtmp, 0, self._getenv()) |
|
1367 | self._testtmp, 0, self._getenv()) | |
1368 | stdout, stderr = proc.communicate() |
|
1368 | stdout, stderr = proc.communicate() | |
1369 | ret = proc.wait() |
|
1369 | ret = proc.wait() | |
1370 | if wifexited(ret): |
|
1370 | if wifexited(ret): | |
1371 | ret = os.WEXITSTATUS(ret) |
|
1371 | ret = os.WEXITSTATUS(ret) | |
1372 | if ret == 2: |
|
1372 | if ret == 2: | |
1373 | print(stdout.decode('utf-8')) |
|
1373 | print(stdout.decode('utf-8')) | |
1374 | sys.exit(1) |
|
1374 | sys.exit(1) | |
1375 |
|
1375 | |||
1376 | if ret != 0: |
|
1376 | if ret != 0: | |
1377 | self._have[allreqs] = (False, stdout) |
|
1377 | self._have[allreqs] = (False, stdout) | |
1378 | return False, stdout |
|
1378 | return False, stdout | |
1379 |
|
1379 | |||
1380 | self._have[allreqs] = (True, None) |
|
1380 | self._have[allreqs] = (True, None) | |
1381 | return True, None |
|
1381 | return True, None | |
1382 |
|
1382 | |||
1383 | def _detectslow(self, reqs): |
|
1383 | def _detectslow(self, reqs): | |
1384 | """update the timeout of slow test when appropriate""" |
|
1384 | """update the timeout of slow test when appropriate""" | |
1385 | if b'slow' in reqs: |
|
1385 | if b'slow' in reqs: | |
1386 | self._timeout = self._slowtimeout |
|
1386 | self._timeout = self._slowtimeout | |
1387 |
|
1387 | |||
1388 | def _iftest(self, args): |
|
1388 | def _iftest(self, args): | |
1389 | # implements "#if" |
|
1389 | # implements "#if" | |
1390 | reqs = [] |
|
1390 | reqs = [] | |
1391 | for arg in args: |
|
1391 | for arg in args: | |
1392 | if arg.startswith(b'no-') and arg[3:] in self._allcases: |
|
1392 | if arg.startswith(b'no-') and arg[3:] in self._allcases: | |
1393 | if arg[3:] in self._case: |
|
1393 | if arg[3:] in self._case: | |
1394 | return False |
|
1394 | return False | |
1395 | elif arg in self._allcases: |
|
1395 | elif arg in self._allcases: | |
1396 | if arg not in self._case: |
|
1396 | if arg not in self._case: | |
1397 | return False |
|
1397 | return False | |
1398 | else: |
|
1398 | else: | |
1399 | reqs.append(arg) |
|
1399 | reqs.append(arg) | |
1400 | self._detectslow(reqs) |
|
1400 | self._detectslow(reqs) | |
1401 | return self._hghave(reqs)[0] |
|
1401 | return self._hghave(reqs)[0] | |
1402 |
|
1402 | |||
1403 | def _parsetest(self, lines): |
|
1403 | def _parsetest(self, lines): | |
1404 | # We generate a shell script which outputs unique markers to line |
|
1404 | # We generate a shell script which outputs unique markers to line | |
1405 | # up script results with our source. These markers include input |
|
1405 | # up script results with our source. These markers include input | |
1406 | # line number and the last return code. |
|
1406 | # line number and the last return code. | |
1407 | salt = b"SALT%d" % time.time() |
|
1407 | salt = b"SALT%d" % time.time() | |
1408 | def addsalt(line, inpython): |
|
1408 | def addsalt(line, inpython): | |
1409 | if inpython: |
|
1409 | if inpython: | |
1410 | script.append(b'%s %d 0\n' % (salt, line)) |
|
1410 | script.append(b'%s %d 0\n' % (salt, line)) | |
1411 | else: |
|
1411 | else: | |
1412 | script.append(b'echo %s %d $?\n' % (salt, line)) |
|
1412 | script.append(b'echo %s %d $?\n' % (salt, line)) | |
1413 | activetrace = [] |
|
1413 | activetrace = [] | |
1414 | session = str(uuid.uuid4()) |
|
1414 | session = str(uuid.uuid4()) | |
1415 | if PYTHON3: |
|
1415 | if PYTHON3: | |
1416 | session = session.encode('ascii') |
|
1416 | session = session.encode('ascii') | |
1417 | hgcatapult = (os.getenv('HGTESTCATAPULTSERVERPIPE') or |
|
1417 | hgcatapult = (os.getenv('HGTESTCATAPULTSERVERPIPE') or | |
1418 | os.getenv('HGCATAPULTSERVERPIPE')) |
|
1418 | os.getenv('HGCATAPULTSERVERPIPE')) | |
1419 | def toggletrace(cmd=None): |
|
1419 | def toggletrace(cmd=None): | |
1420 | if not hgcatapult or hgcatapult == os.devnull: |
|
1420 | if not hgcatapult or hgcatapult == os.devnull: | |
1421 | return |
|
1421 | return | |
1422 |
|
1422 | |||
1423 | if activetrace: |
|
1423 | if activetrace: | |
1424 | script.append( |
|
1424 | script.append( | |
1425 | b'echo END %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % ( |
|
1425 | b'echo END %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % ( | |
1426 | session, activetrace[0])) |
|
1426 | session, activetrace[0])) | |
1427 | if cmd is None: |
|
1427 | if cmd is None: | |
1428 | return |
|
1428 | return | |
1429 |
|
1429 | |||
1430 | if isinstance(cmd, str): |
|
1430 | if isinstance(cmd, str): | |
1431 | quoted = shellquote(cmd.strip()) |
|
1431 | quoted = shellquote(cmd.strip()) | |
1432 | else: |
|
1432 | else: | |
1433 | quoted = shellquote(cmd.strip().decode('utf8')).encode('utf8') |
|
1433 | quoted = shellquote(cmd.strip().decode('utf8')).encode('utf8') | |
1434 | quoted = quoted.replace(b'\\', b'\\\\') |
|
1434 | quoted = quoted.replace(b'\\', b'\\\\') | |
1435 | script.append( |
|
1435 | script.append( | |
1436 | b'echo START %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % ( |
|
1436 | b'echo START %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' % ( | |
1437 | session, quoted)) |
|
1437 | session, quoted)) | |
1438 | activetrace[0:] = [quoted] |
|
1438 | activetrace[0:] = [quoted] | |
1439 |
|
1439 | |||
1440 | script = [] |
|
1440 | script = [] | |
1441 |
|
1441 | |||
1442 | # After we run the shell script, we re-unify the script output |
|
1442 | # After we run the shell script, we re-unify the script output | |
1443 | # with non-active parts of the source, with synchronization by our |
|
1443 | # with non-active parts of the source, with synchronization by our | |
1444 | # SALT line number markers. The after table contains the non-active |
|
1444 | # SALT line number markers. The after table contains the non-active | |
1445 | # components, ordered by line number. |
|
1445 | # components, ordered by line number. | |
1446 | after = {} |
|
1446 | after = {} | |
1447 |
|
1447 | |||
1448 | # Expected shell script output. |
|
1448 | # Expected shell script output. | |
1449 | expected = {} |
|
1449 | expected = {} | |
1450 |
|
1450 | |||
1451 | pos = prepos = -1 |
|
1451 | pos = prepos = -1 | |
1452 |
|
1452 | |||
1453 | # True or False when in a true or false conditional section |
|
1453 | # True or False when in a true or false conditional section | |
1454 | skipping = None |
|
1454 | skipping = None | |
1455 |
|
1455 | |||
1456 | # We keep track of whether or not we're in a Python block so we |
|
1456 | # We keep track of whether or not we're in a Python block so we | |
1457 | # can generate the surrounding doctest magic. |
|
1457 | # can generate the surrounding doctest magic. | |
1458 | inpython = False |
|
1458 | inpython = False | |
1459 |
|
1459 | |||
1460 | if self._debug: |
|
1460 | if self._debug: | |
1461 | script.append(b'set -x\n') |
|
1461 | script.append(b'set -x\n') | |
1462 | if self._hgcommand != b'hg': |
|
1462 | if self._hgcommand != b'hg': | |
1463 | script.append(b'alias hg="%s"\n' % self._hgcommand) |
|
1463 | script.append(b'alias hg="%s"\n' % self._hgcommand) | |
1464 | if os.getenv('MSYSTEM'): |
|
1464 | if os.getenv('MSYSTEM'): | |
1465 | script.append(b'alias pwd="pwd -W"\n') |
|
1465 | script.append(b'alias pwd="pwd -W"\n') | |
1466 |
|
1466 | |||
1467 | if hgcatapult and hgcatapult != os.devnull: |
|
1467 | if hgcatapult and hgcatapult != os.devnull: | |
1468 | # Kludge: use a while loop to keep the pipe from getting |
|
1468 | # Kludge: use a while loop to keep the pipe from getting | |
1469 | # closed by our echo commands. The still-running file gets |
|
1469 | # closed by our echo commands. The still-running file gets | |
1470 | # reaped at the end of the script, which causes the while |
|
1470 | # reaped at the end of the script, which causes the while | |
1471 | # loop to exit and closes the pipe. Sigh. |
|
1471 | # loop to exit and closes the pipe. Sigh. | |
1472 | script.append( |
|
1472 | script.append( | |
1473 | b'rtendtracing() {\n' |
|
1473 | b'rtendtracing() {\n' | |
1474 | b' echo END %(session)s %(name)s >> %(catapult)s\n' |
|
1474 | b' echo END %(session)s %(name)s >> %(catapult)s\n' | |
1475 | b' rm -f "$TESTTMP/.still-running"\n' |
|
1475 | b' rm -f "$TESTTMP/.still-running"\n' | |
1476 | b'}\n' |
|
1476 | b'}\n' | |
1477 | b'trap "rtendtracing" 0\n' |
|
1477 | b'trap "rtendtracing" 0\n' | |
1478 | b'touch "$TESTTMP/.still-running"\n' |
|
1478 | b'touch "$TESTTMP/.still-running"\n' | |
1479 | b'while [ -f "$TESTTMP/.still-running" ]; do sleep 1; done ' |
|
1479 | b'while [ -f "$TESTTMP/.still-running" ]; do sleep 1; done ' | |
1480 | b'> %(catapult)s &\n' |
|
1480 | b'> %(catapult)s &\n' | |
1481 | b'HGCATAPULTSESSION=%(session)s ; export HGCATAPULTSESSION\n' |
|
1481 | b'HGCATAPULTSESSION=%(session)s ; export HGCATAPULTSESSION\n' | |
1482 | b'echo START %(session)s %(name)s >> %(catapult)s\n' |
|
1482 | b'echo START %(session)s %(name)s >> %(catapult)s\n' | |
1483 | % { |
|
1483 | % { | |
1484 | 'name': self.name, |
|
1484 | 'name': self.name, | |
1485 | 'session': session, |
|
1485 | 'session': session, | |
1486 | 'catapult': hgcatapult, |
|
1486 | 'catapult': hgcatapult, | |
1487 | } |
|
1487 | } | |
1488 | ) |
|
1488 | ) | |
1489 |
|
1489 | |||
1490 | if self._case: |
|
1490 | if self._case: | |
1491 | casestr = b'#'.join(self._case) |
|
1491 | casestr = b'#'.join(self._case) | |
1492 | if isinstance(self._case, str): |
|
1492 | if isinstance(self._case, str): | |
1493 | quoted = shellquote(casestr) |
|
1493 | quoted = shellquote(casestr) | |
1494 | else: |
|
1494 | else: | |
1495 | quoted = shellquote(casestr.decode('utf8')).encode('utf8') |
|
1495 | quoted = shellquote(casestr.decode('utf8')).encode('utf8') | |
1496 | script.append(b'TESTCASE=%s\n' % quoted) |
|
1496 | script.append(b'TESTCASE=%s\n' % quoted) | |
1497 | script.append(b'export TESTCASE\n') |
|
1497 | script.append(b'export TESTCASE\n') | |
1498 |
|
1498 | |||
1499 | n = 0 |
|
1499 | n = 0 | |
1500 | for n, l in enumerate(lines): |
|
1500 | for n, l in enumerate(lines): | |
1501 | if not l.endswith(b'\n'): |
|
1501 | if not l.endswith(b'\n'): | |
1502 | l += b'\n' |
|
1502 | l += b'\n' | |
1503 | if l.startswith(b'#require'): |
|
1503 | if l.startswith(b'#require'): | |
1504 | lsplit = l.split() |
|
1504 | lsplit = l.split() | |
1505 | if len(lsplit) < 2 or lsplit[0] != b'#require': |
|
1505 | if len(lsplit) < 2 or lsplit[0] != b'#require': | |
1506 | after.setdefault(pos, []).append(' !!! invalid #require\n') |
|
1506 | after.setdefault(pos, []).append(' !!! invalid #require\n') | |
1507 | if not skipping: |
|
1507 | if not skipping: | |
1508 | haveresult, message = self._hghave(lsplit[1:]) |
|
1508 | haveresult, message = self._hghave(lsplit[1:]) | |
1509 | if not haveresult: |
|
1509 | if not haveresult: | |
1510 | script = [b'echo "%s"\nexit 80\n' % message] |
|
1510 | script = [b'echo "%s"\nexit 80\n' % message] | |
1511 | break |
|
1511 | break | |
1512 | after.setdefault(pos, []).append(l) |
|
1512 | after.setdefault(pos, []).append(l) | |
1513 | elif l.startswith(b'#if'): |
|
1513 | elif l.startswith(b'#if'): | |
1514 | lsplit = l.split() |
|
1514 | lsplit = l.split() | |
1515 | if len(lsplit) < 2 or lsplit[0] != b'#if': |
|
1515 | if len(lsplit) < 2 or lsplit[0] != b'#if': | |
1516 | after.setdefault(pos, []).append(' !!! invalid #if\n') |
|
1516 | after.setdefault(pos, []).append(' !!! invalid #if\n') | |
1517 | if skipping is not None: |
|
1517 | if skipping is not None: | |
1518 | after.setdefault(pos, []).append(' !!! nested #if\n') |
|
1518 | after.setdefault(pos, []).append(' !!! nested #if\n') | |
1519 | skipping = not self._iftest(lsplit[1:]) |
|
1519 | skipping = not self._iftest(lsplit[1:]) | |
1520 | after.setdefault(pos, []).append(l) |
|
1520 | after.setdefault(pos, []).append(l) | |
1521 | elif l.startswith(b'#else'): |
|
1521 | elif l.startswith(b'#else'): | |
1522 | if skipping is None: |
|
1522 | if skipping is None: | |
1523 | after.setdefault(pos, []).append(' !!! missing #if\n') |
|
1523 | after.setdefault(pos, []).append(' !!! missing #if\n') | |
1524 | skipping = not skipping |
|
1524 | skipping = not skipping | |
1525 | after.setdefault(pos, []).append(l) |
|
1525 | after.setdefault(pos, []).append(l) | |
1526 | elif l.startswith(b'#endif'): |
|
1526 | elif l.startswith(b'#endif'): | |
1527 | if skipping is None: |
|
1527 | if skipping is None: | |
1528 | after.setdefault(pos, []).append(' !!! missing #if\n') |
|
1528 | after.setdefault(pos, []).append(' !!! missing #if\n') | |
1529 | skipping = None |
|
1529 | skipping = None | |
1530 | after.setdefault(pos, []).append(l) |
|
1530 | after.setdefault(pos, []).append(l) | |
1531 | elif skipping: |
|
1531 | elif skipping: | |
1532 | after.setdefault(pos, []).append(l) |
|
1532 | after.setdefault(pos, []).append(l) | |
1533 | elif l.startswith(b' >>> '): # python inlines |
|
1533 | elif l.startswith(b' >>> '): # python inlines | |
1534 | after.setdefault(pos, []).append(l) |
|
1534 | after.setdefault(pos, []).append(l) | |
1535 | prepos = pos |
|
1535 | prepos = pos | |
1536 | pos = n |
|
1536 | pos = n | |
1537 | if not inpython: |
|
1537 | if not inpython: | |
1538 | # We've just entered a Python block. Add the header. |
|
1538 | # We've just entered a Python block. Add the header. | |
1539 | inpython = True |
|
1539 | inpython = True | |
1540 | addsalt(prepos, False) # Make sure we report the exit code. |
|
1540 | addsalt(prepos, False) # Make sure we report the exit code. | |
1541 | script.append(b'"%s" -m heredoctest <<EOF\n' % PYTHON) |
|
1541 | script.append(b'"%s" -m heredoctest <<EOF\n' % PYTHON) | |
1542 | addsalt(n, True) |
|
1542 | addsalt(n, True) | |
1543 | script.append(l[2:]) |
|
1543 | script.append(l[2:]) | |
1544 | elif l.startswith(b' ... '): # python inlines |
|
1544 | elif l.startswith(b' ... '): # python inlines | |
1545 | after.setdefault(prepos, []).append(l) |
|
1545 | after.setdefault(prepos, []).append(l) | |
1546 | script.append(l[2:]) |
|
1546 | script.append(l[2:]) | |
1547 | elif l.startswith(b' $ '): # commands |
|
1547 | elif l.startswith(b' $ '): # commands | |
1548 | if inpython: |
|
1548 | if inpython: | |
1549 | script.append(b'EOF\n') |
|
1549 | script.append(b'EOF\n') | |
1550 | inpython = False |
|
1550 | inpython = False | |
1551 | after.setdefault(pos, []).append(l) |
|
1551 | after.setdefault(pos, []).append(l) | |
1552 | prepos = pos |
|
1552 | prepos = pos | |
1553 | pos = n |
|
1553 | pos = n | |
1554 | addsalt(n, False) |
|
1554 | addsalt(n, False) | |
1555 | rawcmd = l[4:] |
|
1555 | rawcmd = l[4:] | |
1556 | cmd = rawcmd.split() |
|
1556 | cmd = rawcmd.split() | |
1557 | toggletrace(rawcmd) |
|
1557 | toggletrace(rawcmd) | |
1558 | if len(cmd) == 2 and cmd[0] == b'cd': |
|
1558 | if len(cmd) == 2 and cmd[0] == b'cd': | |
1559 | l = b' $ cd %s || exit 1\n' % cmd[1] |
|
1559 | l = b' $ cd %s || exit 1\n' % cmd[1] | |
1560 | script.append(rawcmd) |
|
1560 | script.append(rawcmd) | |
1561 | elif l.startswith(b' > '): # continuations |
|
1561 | elif l.startswith(b' > '): # continuations | |
1562 | after.setdefault(prepos, []).append(l) |
|
1562 | after.setdefault(prepos, []).append(l) | |
1563 | script.append(l[4:]) |
|
1563 | script.append(l[4:]) | |
1564 | elif l.startswith(b' '): # results |
|
1564 | elif l.startswith(b' '): # results | |
1565 | # Queue up a list of expected results. |
|
1565 | # Queue up a list of expected results. | |
1566 | expected.setdefault(pos, []).append(l[2:]) |
|
1566 | expected.setdefault(pos, []).append(l[2:]) | |
1567 | else: |
|
1567 | else: | |
1568 | if inpython: |
|
1568 | if inpython: | |
1569 | script.append(b'EOF\n') |
|
1569 | script.append(b'EOF\n') | |
1570 | inpython = False |
|
1570 | inpython = False | |
1571 | # Non-command/result. Queue up for merged output. |
|
1571 | # Non-command/result. Queue up for merged output. | |
1572 | after.setdefault(pos, []).append(l) |
|
1572 | after.setdefault(pos, []).append(l) | |
1573 |
|
1573 | |||
1574 | if inpython: |
|
1574 | if inpython: | |
1575 | script.append(b'EOF\n') |
|
1575 | script.append(b'EOF\n') | |
1576 | if skipping is not None: |
|
1576 | if skipping is not None: | |
1577 | after.setdefault(pos, []).append(' !!! missing #endif\n') |
|
1577 | after.setdefault(pos, []).append(' !!! missing #endif\n') | |
1578 | addsalt(n + 1, False) |
|
1578 | addsalt(n + 1, False) | |
1579 | # Need to end any current per-command trace |
|
1579 | # Need to end any current per-command trace | |
1580 | if activetrace: |
|
1580 | if activetrace: | |
1581 | toggletrace() |
|
1581 | toggletrace() | |
1582 | return salt, script, after, expected |
|
1582 | return salt, script, after, expected | |
1583 |
|
1583 | |||
1584 | def _processoutput(self, exitcode, output, salt, after, expected): |
|
1584 | def _processoutput(self, exitcode, output, salt, after, expected): | |
1585 | # Merge the script output back into a unified test. |
|
1585 | # Merge the script output back into a unified test. | |
1586 | warnonly = 1 # 1: not yet; 2: yes; 3: for sure not |
|
1586 | warnonly = 1 # 1: not yet; 2: yes; 3: for sure not | |
1587 | if exitcode != 0: |
|
1587 | if exitcode != 0: | |
1588 | warnonly = 3 |
|
1588 | warnonly = 3 | |
1589 |
|
1589 | |||
1590 | pos = -1 |
|
1590 | pos = -1 | |
1591 | postout = [] |
|
1591 | postout = [] | |
1592 | for l in output: |
|
1592 | for l in output: | |
1593 | lout, lcmd = l, None |
|
1593 | lout, lcmd = l, None | |
1594 | if salt in l: |
|
1594 | if salt in l: | |
1595 | lout, lcmd = l.split(salt, 1) |
|
1595 | lout, lcmd = l.split(salt, 1) | |
1596 |
|
1596 | |||
1597 | while lout: |
|
1597 | while lout: | |
1598 | if not lout.endswith(b'\n'): |
|
1598 | if not lout.endswith(b'\n'): | |
1599 | lout += b' (no-eol)\n' |
|
1599 | lout += b' (no-eol)\n' | |
1600 |
|
1600 | |||
1601 | # Find the expected output at the current position. |
|
1601 | # Find the expected output at the current position. | |
1602 | els = [None] |
|
1602 | els = [None] | |
1603 | if expected.get(pos, None): |
|
1603 | if expected.get(pos, None): | |
1604 | els = expected[pos] |
|
1604 | els = expected[pos] | |
1605 |
|
1605 | |||
1606 | optional = [] |
|
1606 | optional = [] | |
1607 | for i, el in enumerate(els): |
|
1607 | for i, el in enumerate(els): | |
1608 | r = False |
|
1608 | r = False | |
1609 | if el: |
|
1609 | if el: | |
1610 | r, exact = self.linematch(el, lout) |
|
1610 | r, exact = self.linematch(el, lout) | |
1611 | if isinstance(r, str): |
|
1611 | if isinstance(r, str): | |
1612 | if r == '-glob': |
|
1612 | if r == '-glob': | |
1613 | lout = ''.join(el.rsplit(' (glob)', 1)) |
|
1613 | lout = ''.join(el.rsplit(' (glob)', 1)) | |
1614 | r = '' # Warn only this line. |
|
1614 | r = '' # Warn only this line. | |
1615 | elif r == "retry": |
|
1615 | elif r == "retry": | |
1616 | postout.append(b' ' + el) |
|
1616 | postout.append(b' ' + el) | |
1617 | else: |
|
1617 | else: | |
1618 | log('\ninfo, unknown linematch result: %r\n' % r) |
|
1618 | log('\ninfo, unknown linematch result: %r\n' % r) | |
1619 | r = False |
|
1619 | r = False | |
1620 | if r: |
|
1620 | if r: | |
1621 | els.pop(i) |
|
1621 | els.pop(i) | |
1622 | break |
|
1622 | break | |
1623 | if el: |
|
1623 | if el: | |
1624 | if el.endswith(b" (?)\n"): |
|
1624 | if el.endswith(b" (?)\n"): | |
1625 | optional.append(i) |
|
1625 | optional.append(i) | |
1626 | else: |
|
1626 | else: | |
1627 | m = optline.match(el) |
|
1627 | m = optline.match(el) | |
1628 | if m: |
|
1628 | if m: | |
1629 | conditions = [ |
|
1629 | conditions = [ | |
1630 | c for c in m.group(2).split(b' ')] |
|
1630 | c for c in m.group(2).split(b' ')] | |
1631 |
|
1631 | |||
1632 | if not self._iftest(conditions): |
|
1632 | if not self._iftest(conditions): | |
1633 | optional.append(i) |
|
1633 | optional.append(i) | |
1634 | if exact: |
|
1634 | if exact: | |
1635 | # Don't allow line to be matches against a later |
|
1635 | # Don't allow line to be matches against a later | |
1636 | # line in the output |
|
1636 | # line in the output | |
1637 | els.pop(i) |
|
1637 | els.pop(i) | |
1638 | break |
|
1638 | break | |
1639 |
|
1639 | |||
1640 | if r: |
|
1640 | if r: | |
1641 | if r == "retry": |
|
1641 | if r == "retry": | |
1642 | continue |
|
1642 | continue | |
1643 | # clean up any optional leftovers |
|
1643 | # clean up any optional leftovers | |
1644 | for i in optional: |
|
1644 | for i in optional: | |
1645 | postout.append(b' ' + els[i]) |
|
1645 | postout.append(b' ' + els[i]) | |
1646 | for i in reversed(optional): |
|
1646 | for i in reversed(optional): | |
1647 | del els[i] |
|
1647 | del els[i] | |
1648 | postout.append(b' ' + el) |
|
1648 | postout.append(b' ' + el) | |
1649 | else: |
|
1649 | else: | |
1650 | if self.NEEDESCAPE(lout): |
|
1650 | if self.NEEDESCAPE(lout): | |
1651 | lout = TTest._stringescape(b'%s (esc)\n' % |
|
1651 | lout = TTest._stringescape(b'%s (esc)\n' % | |
1652 | lout.rstrip(b'\n')) |
|
1652 | lout.rstrip(b'\n')) | |
1653 | postout.append(b' ' + lout) # Let diff deal with it. |
|
1653 | postout.append(b' ' + lout) # Let diff deal with it. | |
1654 | if r != '': # If line failed. |
|
1654 | if r != '': # If line failed. | |
1655 | warnonly = 3 # for sure not |
|
1655 | warnonly = 3 # for sure not | |
1656 | elif warnonly == 1: # Is "not yet" and line is warn only. |
|
1656 | elif warnonly == 1: # Is "not yet" and line is warn only. | |
1657 | warnonly = 2 # Yes do warn. |
|
1657 | warnonly = 2 # Yes do warn. | |
1658 | break |
|
1658 | break | |
1659 | else: |
|
1659 | else: | |
1660 | # clean up any optional leftovers |
|
1660 | # clean up any optional leftovers | |
1661 | while expected.get(pos, None): |
|
1661 | while expected.get(pos, None): | |
1662 | el = expected[pos].pop(0) |
|
1662 | el = expected[pos].pop(0) | |
1663 | if el: |
|
1663 | if el: | |
1664 | if not el.endswith(b" (?)\n"): |
|
1664 | if not el.endswith(b" (?)\n"): | |
1665 | m = optline.match(el) |
|
1665 | m = optline.match(el) | |
1666 | if m: |
|
1666 | if m: | |
1667 | conditions = [c for c in m.group(2).split(b' ')] |
|
1667 | conditions = [c for c in m.group(2).split(b' ')] | |
1668 |
|
1668 | |||
1669 | if self._iftest(conditions): |
|
1669 | if self._iftest(conditions): | |
1670 | # Don't append as optional line |
|
1670 | # Don't append as optional line | |
1671 | continue |
|
1671 | continue | |
1672 | else: |
|
1672 | else: | |
1673 | continue |
|
1673 | continue | |
1674 | postout.append(b' ' + el) |
|
1674 | postout.append(b' ' + el) | |
1675 |
|
1675 | |||
1676 | if lcmd: |
|
1676 | if lcmd: | |
1677 | # Add on last return code. |
|
1677 | # Add on last return code. | |
1678 | ret = int(lcmd.split()[1]) |
|
1678 | ret = int(lcmd.split()[1]) | |
1679 | if ret != 0: |
|
1679 | if ret != 0: | |
1680 | postout.append(b' [%d]\n' % ret) |
|
1680 | postout.append(b' [%d]\n' % ret) | |
1681 | if pos in after: |
|
1681 | if pos in after: | |
1682 | # Merge in non-active test bits. |
|
1682 | # Merge in non-active test bits. | |
1683 | postout += after.pop(pos) |
|
1683 | postout += after.pop(pos) | |
1684 | pos = int(lcmd.split()[0]) |
|
1684 | pos = int(lcmd.split()[0]) | |
1685 |
|
1685 | |||
1686 | if pos in after: |
|
1686 | if pos in after: | |
1687 | postout += after.pop(pos) |
|
1687 | postout += after.pop(pos) | |
1688 |
|
1688 | |||
1689 | if warnonly == 2: |
|
1689 | if warnonly == 2: | |
1690 | exitcode = False # Set exitcode to warned. |
|
1690 | exitcode = False # Set exitcode to warned. | |
1691 |
|
1691 | |||
1692 | return exitcode, postout |
|
1692 | return exitcode, postout | |
1693 |
|
1693 | |||
1694 | @staticmethod |
|
1694 | @staticmethod | |
1695 | def rematch(el, l): |
|
1695 | def rematch(el, l): | |
1696 | try: |
|
1696 | try: | |
1697 | el = b'(?:' + el + b')' |
|
1697 | el = b'(?:' + el + b')' | |
1698 | # use \Z to ensure that the regex matches to the end of the string |
|
1698 | # use \Z to ensure that the regex matches to the end of the string | |
1699 | if os.name == 'nt': |
|
1699 | if os.name == 'nt': | |
1700 | return re.match(el + br'\r?\n\Z', l) |
|
1700 | return re.match(el + br'\r?\n\Z', l) | |
1701 | return re.match(el + br'\n\Z', l) |
|
1701 | return re.match(el + br'\n\Z', l) | |
1702 | except re.error: |
|
1702 | except re.error: | |
1703 | # el is an invalid regex |
|
1703 | # el is an invalid regex | |
1704 | return False |
|
1704 | return False | |
1705 |
|
1705 | |||
1706 | @staticmethod |
|
1706 | @staticmethod | |
1707 | def globmatch(el, l): |
|
1707 | def globmatch(el, l): | |
1708 | # The only supported special characters are * and ? plus / which also |
|
1708 | # The only supported special characters are * and ? plus / which also | |
1709 | # matches \ on windows. Escaping of these characters is supported. |
|
1709 | # matches \ on windows. Escaping of these characters is supported. | |
1710 | if el + b'\n' == l: |
|
1710 | if el + b'\n' == l: | |
1711 | if os.altsep: |
|
1711 | if os.altsep: | |
1712 | # matching on "/" is not needed for this line |
|
1712 | # matching on "/" is not needed for this line | |
1713 | for pat in checkcodeglobpats: |
|
1713 | for pat in checkcodeglobpats: | |
1714 | if pat.match(el): |
|
1714 | if pat.match(el): | |
1715 | return True |
|
1715 | return True | |
1716 | return b'-glob' |
|
1716 | return b'-glob' | |
1717 | return True |
|
1717 | return True | |
1718 | el = el.replace(b'$LOCALIP', b'*') |
|
1718 | el = el.replace(b'$LOCALIP', b'*') | |
1719 | i, n = 0, len(el) |
|
1719 | i, n = 0, len(el) | |
1720 | res = b'' |
|
1720 | res = b'' | |
1721 | while i < n: |
|
1721 | while i < n: | |
1722 | c = el[i:i + 1] |
|
1722 | c = el[i:i + 1] | |
1723 | i += 1 |
|
1723 | i += 1 | |
1724 | if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/': |
|
1724 | if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/': | |
1725 | res += el[i - 1:i + 1] |
|
1725 | res += el[i - 1:i + 1] | |
1726 | i += 1 |
|
1726 | i += 1 | |
1727 | elif c == b'*': |
|
1727 | elif c == b'*': | |
1728 | res += b'.*' |
|
1728 | res += b'.*' | |
1729 | elif c == b'?': |
|
1729 | elif c == b'?': | |
1730 | res += b'.' |
|
1730 | res += b'.' | |
1731 | elif c == b'/' and os.altsep: |
|
1731 | elif c == b'/' and os.altsep: | |
1732 | res += b'[/\\\\]' |
|
1732 | res += b'[/\\\\]' | |
1733 | else: |
|
1733 | else: | |
1734 | res += re.escape(c) |
|
1734 | res += re.escape(c) | |
1735 | return TTest.rematch(res, l) |
|
1735 | return TTest.rematch(res, l) | |
1736 |
|
1736 | |||
1737 | def linematch(self, el, l): |
|
1737 | def linematch(self, el, l): | |
1738 | if el == l: # perfect match (fast) |
|
1738 | if el == l: # perfect match (fast) | |
1739 | return True, True |
|
1739 | return True, True | |
1740 | retry = False |
|
1740 | retry = False | |
1741 | if el.endswith(b" (?)\n"): |
|
1741 | if el.endswith(b" (?)\n"): | |
1742 | retry = "retry" |
|
1742 | retry = "retry" | |
1743 | el = el[:-5] + b"\n" |
|
1743 | el = el[:-5] + b"\n" | |
1744 | else: |
|
1744 | else: | |
1745 | m = optline.match(el) |
|
1745 | m = optline.match(el) | |
1746 | if m: |
|
1746 | if m: | |
1747 | conditions = [c for c in m.group(2).split(b' ')] |
|
1747 | conditions = [c for c in m.group(2).split(b' ')] | |
1748 |
|
1748 | |||
1749 | el = m.group(1) + b"\n" |
|
1749 | el = m.group(1) + b"\n" | |
1750 | if not self._iftest(conditions): |
|
1750 | if not self._iftest(conditions): | |
1751 | retry = "retry" # Not required by listed features |
|
1751 | # listed feature missing, should not match | |
|
1752 | return "retry", False | |||
1752 |
|
1753 | |||
1753 | if el.endswith(b" (esc)\n"): |
|
1754 | if el.endswith(b" (esc)\n"): | |
1754 | if PYTHON3: |
|
1755 | if PYTHON3: | |
1755 | el = el[:-7].decode('unicode_escape') + '\n' |
|
1756 | el = el[:-7].decode('unicode_escape') + '\n' | |
1756 | el = el.encode('utf-8') |
|
1757 | el = el.encode('utf-8') | |
1757 | else: |
|
1758 | else: | |
1758 | el = el[:-7].decode('string-escape') + '\n' |
|
1759 | el = el[:-7].decode('string-escape') + '\n' | |
1759 | if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l: |
|
1760 | if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l: | |
1760 | return True, True |
|
1761 | return True, True | |
1761 | if el.endswith(b" (re)\n"): |
|
1762 | if el.endswith(b" (re)\n"): | |
1762 | return (TTest.rematch(el[:-6], l) or retry), False |
|
1763 | return (TTest.rematch(el[:-6], l) or retry), False | |
1763 | if el.endswith(b" (glob)\n"): |
|
1764 | if el.endswith(b" (glob)\n"): | |
1764 | # ignore '(glob)' added to l by 'replacements' |
|
1765 | # ignore '(glob)' added to l by 'replacements' | |
1765 | if l.endswith(b" (glob)\n"): |
|
1766 | if l.endswith(b" (glob)\n"): | |
1766 | l = l[:-8] + b"\n" |
|
1767 | l = l[:-8] + b"\n" | |
1767 | return (TTest.globmatch(el[:-8], l) or retry), False |
|
1768 | return (TTest.globmatch(el[:-8], l) or retry), False | |
1768 | if os.altsep: |
|
1769 | if os.altsep: | |
1769 | _l = l.replace(b'\\', b'/') |
|
1770 | _l = l.replace(b'\\', b'/') | |
1770 | if el == _l or os.name == 'nt' and el[:-1] + b'\r\n' == _l: |
|
1771 | if el == _l or os.name == 'nt' and el[:-1] + b'\r\n' == _l: | |
1771 | return True, True |
|
1772 | return True, True | |
1772 | return retry, True |
|
1773 | return retry, True | |
1773 |
|
1774 | |||
1774 | @staticmethod |
|
1775 | @staticmethod | |
1775 | def parsehghaveoutput(lines): |
|
1776 | def parsehghaveoutput(lines): | |
1776 | '''Parse hghave log lines. |
|
1777 | '''Parse hghave log lines. | |
1777 |
|
1778 | |||
1778 | Return tuple of lists (missing, failed): |
|
1779 | Return tuple of lists (missing, failed): | |
1779 | * the missing/unknown features |
|
1780 | * the missing/unknown features | |
1780 | * the features for which existence check failed''' |
|
1781 | * the features for which existence check failed''' | |
1781 | missing = [] |
|
1782 | missing = [] | |
1782 | failed = [] |
|
1783 | failed = [] | |
1783 | for line in lines: |
|
1784 | for line in lines: | |
1784 | if line.startswith(TTest.SKIPPED_PREFIX): |
|
1785 | if line.startswith(TTest.SKIPPED_PREFIX): | |
1785 | line = line.splitlines()[0] |
|
1786 | line = line.splitlines()[0] | |
1786 | missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8')) |
|
1787 | missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8')) | |
1787 | elif line.startswith(TTest.FAILED_PREFIX): |
|
1788 | elif line.startswith(TTest.FAILED_PREFIX): | |
1788 | line = line.splitlines()[0] |
|
1789 | line = line.splitlines()[0] | |
1789 | failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8')) |
|
1790 | failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8')) | |
1790 |
|
1791 | |||
1791 | return missing, failed |
|
1792 | return missing, failed | |
1792 |
|
1793 | |||
1793 | @staticmethod |
|
1794 | @staticmethod | |
1794 | def _escapef(m): |
|
1795 | def _escapef(m): | |
1795 | return TTest.ESCAPEMAP[m.group(0)] |
|
1796 | return TTest.ESCAPEMAP[m.group(0)] | |
1796 |
|
1797 | |||
1797 | @staticmethod |
|
1798 | @staticmethod | |
1798 | def _stringescape(s): |
|
1799 | def _stringescape(s): | |
1799 | return TTest.ESCAPESUB(TTest._escapef, s) |
|
1800 | return TTest.ESCAPESUB(TTest._escapef, s) | |
1800 |
|
1801 | |||
1801 | iolock = threading.RLock() |
|
1802 | iolock = threading.RLock() | |
1802 | firstlock = threading.RLock() |
|
1803 | firstlock = threading.RLock() | |
1803 | firsterror = False |
|
1804 | firsterror = False | |
1804 |
|
1805 | |||
1805 | class TestResult(unittest._TextTestResult): |
|
1806 | class TestResult(unittest._TextTestResult): | |
1806 | """Holds results when executing via unittest.""" |
|
1807 | """Holds results when executing via unittest.""" | |
1807 | # Don't worry too much about accessing the non-public _TextTestResult. |
|
1808 | # Don't worry too much about accessing the non-public _TextTestResult. | |
1808 | # It is relatively common in Python testing tools. |
|
1809 | # It is relatively common in Python testing tools. | |
1809 | def __init__(self, options, *args, **kwargs): |
|
1810 | def __init__(self, options, *args, **kwargs): | |
1810 | super(TestResult, self).__init__(*args, **kwargs) |
|
1811 | super(TestResult, self).__init__(*args, **kwargs) | |
1811 |
|
1812 | |||
1812 | self._options = options |
|
1813 | self._options = options | |
1813 |
|
1814 | |||
1814 | # unittest.TestResult didn't have skipped until 2.7. We need to |
|
1815 | # unittest.TestResult didn't have skipped until 2.7. We need to | |
1815 | # polyfill it. |
|
1816 | # polyfill it. | |
1816 | self.skipped = [] |
|
1817 | self.skipped = [] | |
1817 |
|
1818 | |||
1818 | # We have a custom "ignored" result that isn't present in any Python |
|
1819 | # We have a custom "ignored" result that isn't present in any Python | |
1819 | # unittest implementation. It is very similar to skipped. It may make |
|
1820 | # unittest implementation. It is very similar to skipped. It may make | |
1820 | # sense to map it into skip some day. |
|
1821 | # sense to map it into skip some day. | |
1821 | self.ignored = [] |
|
1822 | self.ignored = [] | |
1822 |
|
1823 | |||
1823 | self.times = [] |
|
1824 | self.times = [] | |
1824 | self._firststarttime = None |
|
1825 | self._firststarttime = None | |
1825 | # Data stored for the benefit of generating xunit reports. |
|
1826 | # Data stored for the benefit of generating xunit reports. | |
1826 | self.successes = [] |
|
1827 | self.successes = [] | |
1827 | self.faildata = {} |
|
1828 | self.faildata = {} | |
1828 |
|
1829 | |||
1829 | if options.color == 'auto': |
|
1830 | if options.color == 'auto': | |
1830 | self.color = pygmentspresent and self.stream.isatty() |
|
1831 | self.color = pygmentspresent and self.stream.isatty() | |
1831 | elif options.color == 'never': |
|
1832 | elif options.color == 'never': | |
1832 | self.color = False |
|
1833 | self.color = False | |
1833 | else: # 'always', for testing purposes |
|
1834 | else: # 'always', for testing purposes | |
1834 | self.color = pygmentspresent |
|
1835 | self.color = pygmentspresent | |
1835 |
|
1836 | |||
1836 | def onStart(self, test): |
|
1837 | def onStart(self, test): | |
1837 | """ Can be overriden by custom TestResult |
|
1838 | """ Can be overriden by custom TestResult | |
1838 | """ |
|
1839 | """ | |
1839 |
|
1840 | |||
1840 | def onEnd(self): |
|
1841 | def onEnd(self): | |
1841 | """ Can be overriden by custom TestResult |
|
1842 | """ Can be overriden by custom TestResult | |
1842 | """ |
|
1843 | """ | |
1843 |
|
1844 | |||
1844 | def addFailure(self, test, reason): |
|
1845 | def addFailure(self, test, reason): | |
1845 | self.failures.append((test, reason)) |
|
1846 | self.failures.append((test, reason)) | |
1846 |
|
1847 | |||
1847 | if self._options.first: |
|
1848 | if self._options.first: | |
1848 | self.stop() |
|
1849 | self.stop() | |
1849 | else: |
|
1850 | else: | |
1850 | with iolock: |
|
1851 | with iolock: | |
1851 | if reason == "timed out": |
|
1852 | if reason == "timed out": | |
1852 | self.stream.write('t') |
|
1853 | self.stream.write('t') | |
1853 | else: |
|
1854 | else: | |
1854 | if not self._options.nodiff: |
|
1855 | if not self._options.nodiff: | |
1855 | self.stream.write('\n') |
|
1856 | self.stream.write('\n') | |
1856 | # Exclude the '\n' from highlighting to lex correctly |
|
1857 | # Exclude the '\n' from highlighting to lex correctly | |
1857 | formatted = 'ERROR: %s output changed\n' % test |
|
1858 | formatted = 'ERROR: %s output changed\n' % test | |
1858 | self.stream.write(highlightmsg(formatted, self.color)) |
|
1859 | self.stream.write(highlightmsg(formatted, self.color)) | |
1859 | self.stream.write('!') |
|
1860 | self.stream.write('!') | |
1860 |
|
1861 | |||
1861 | self.stream.flush() |
|
1862 | self.stream.flush() | |
1862 |
|
1863 | |||
1863 | def addSuccess(self, test): |
|
1864 | def addSuccess(self, test): | |
1864 | with iolock: |
|
1865 | with iolock: | |
1865 | super(TestResult, self).addSuccess(test) |
|
1866 | super(TestResult, self).addSuccess(test) | |
1866 | self.successes.append(test) |
|
1867 | self.successes.append(test) | |
1867 |
|
1868 | |||
1868 | def addError(self, test, err): |
|
1869 | def addError(self, test, err): | |
1869 | super(TestResult, self).addError(test, err) |
|
1870 | super(TestResult, self).addError(test, err) | |
1870 | if self._options.first: |
|
1871 | if self._options.first: | |
1871 | self.stop() |
|
1872 | self.stop() | |
1872 |
|
1873 | |||
1873 | # Polyfill. |
|
1874 | # Polyfill. | |
1874 | def addSkip(self, test, reason): |
|
1875 | def addSkip(self, test, reason): | |
1875 | self.skipped.append((test, reason)) |
|
1876 | self.skipped.append((test, reason)) | |
1876 | with iolock: |
|
1877 | with iolock: | |
1877 | if self.showAll: |
|
1878 | if self.showAll: | |
1878 | self.stream.writeln('skipped %s' % reason) |
|
1879 | self.stream.writeln('skipped %s' % reason) | |
1879 | else: |
|
1880 | else: | |
1880 | self.stream.write('s') |
|
1881 | self.stream.write('s') | |
1881 | self.stream.flush() |
|
1882 | self.stream.flush() | |
1882 |
|
1883 | |||
1883 | def addIgnore(self, test, reason): |
|
1884 | def addIgnore(self, test, reason): | |
1884 | self.ignored.append((test, reason)) |
|
1885 | self.ignored.append((test, reason)) | |
1885 | with iolock: |
|
1886 | with iolock: | |
1886 | if self.showAll: |
|
1887 | if self.showAll: | |
1887 | self.stream.writeln('ignored %s' % reason) |
|
1888 | self.stream.writeln('ignored %s' % reason) | |
1888 | else: |
|
1889 | else: | |
1889 | if reason not in ('not retesting', "doesn't match keyword"): |
|
1890 | if reason not in ('not retesting', "doesn't match keyword"): | |
1890 | self.stream.write('i') |
|
1891 | self.stream.write('i') | |
1891 | else: |
|
1892 | else: | |
1892 | self.testsRun += 1 |
|
1893 | self.testsRun += 1 | |
1893 | self.stream.flush() |
|
1894 | self.stream.flush() | |
1894 |
|
1895 | |||
1895 | def addOutputMismatch(self, test, ret, got, expected): |
|
1896 | def addOutputMismatch(self, test, ret, got, expected): | |
1896 | """Record a mismatch in test output for a particular test.""" |
|
1897 | """Record a mismatch in test output for a particular test.""" | |
1897 | if self.shouldStop or firsterror: |
|
1898 | if self.shouldStop or firsterror: | |
1898 | # don't print, some other test case already failed and |
|
1899 | # don't print, some other test case already failed and | |
1899 | # printed, we're just stale and probably failed due to our |
|
1900 | # printed, we're just stale and probably failed due to our | |
1900 | # temp dir getting cleaned up. |
|
1901 | # temp dir getting cleaned up. | |
1901 | return |
|
1902 | return | |
1902 |
|
1903 | |||
1903 | accepted = False |
|
1904 | accepted = False | |
1904 | lines = [] |
|
1905 | lines = [] | |
1905 |
|
1906 | |||
1906 | with iolock: |
|
1907 | with iolock: | |
1907 | if self._options.nodiff: |
|
1908 | if self._options.nodiff: | |
1908 | pass |
|
1909 | pass | |
1909 | elif self._options.view: |
|
1910 | elif self._options.view: | |
1910 | v = self._options.view |
|
1911 | v = self._options.view | |
1911 | subprocess.call(r'"%s" "%s" "%s"' % |
|
1912 | subprocess.call(r'"%s" "%s" "%s"' % | |
1912 | (v, _strpath(test.refpath), |
|
1913 | (v, _strpath(test.refpath), | |
1913 | _strpath(test.errpath)), shell=True) |
|
1914 | _strpath(test.errpath)), shell=True) | |
1914 | else: |
|
1915 | else: | |
1915 | servefail, lines = getdiff(expected, got, |
|
1916 | servefail, lines = getdiff(expected, got, | |
1916 | test.refpath, test.errpath) |
|
1917 | test.refpath, test.errpath) | |
1917 | self.stream.write('\n') |
|
1918 | self.stream.write('\n') | |
1918 | for line in lines: |
|
1919 | for line in lines: | |
1919 | line = highlightdiff(line, self.color) |
|
1920 | line = highlightdiff(line, self.color) | |
1920 | if PYTHON3: |
|
1921 | if PYTHON3: | |
1921 | self.stream.flush() |
|
1922 | self.stream.flush() | |
1922 | self.stream.buffer.write(line) |
|
1923 | self.stream.buffer.write(line) | |
1923 | self.stream.buffer.flush() |
|
1924 | self.stream.buffer.flush() | |
1924 | else: |
|
1925 | else: | |
1925 | self.stream.write(line) |
|
1926 | self.stream.write(line) | |
1926 | self.stream.flush() |
|
1927 | self.stream.flush() | |
1927 |
|
1928 | |||
1928 | if servefail: |
|
1929 | if servefail: | |
1929 | raise test.failureException( |
|
1930 | raise test.failureException( | |
1930 | 'server failed to start (HGPORT=%s)' % test._startport) |
|
1931 | 'server failed to start (HGPORT=%s)' % test._startport) | |
1931 |
|
1932 | |||
1932 | # handle interactive prompt without releasing iolock |
|
1933 | # handle interactive prompt without releasing iolock | |
1933 | if self._options.interactive: |
|
1934 | if self._options.interactive: | |
1934 | if test.readrefout() != expected: |
|
1935 | if test.readrefout() != expected: | |
1935 | self.stream.write( |
|
1936 | self.stream.write( | |
1936 | 'Reference output has changed (run again to prompt ' |
|
1937 | 'Reference output has changed (run again to prompt ' | |
1937 | 'changes)') |
|
1938 | 'changes)') | |
1938 | else: |
|
1939 | else: | |
1939 | self.stream.write('Accept this change? [n] ') |
|
1940 | self.stream.write('Accept this change? [n] ') | |
1940 | self.stream.flush() |
|
1941 | self.stream.flush() | |
1941 | answer = sys.stdin.readline().strip() |
|
1942 | answer = sys.stdin.readline().strip() | |
1942 | if answer.lower() in ('y', 'yes'): |
|
1943 | if answer.lower() in ('y', 'yes'): | |
1943 | if test.path.endswith(b'.t'): |
|
1944 | if test.path.endswith(b'.t'): | |
1944 | rename(test.errpath, test.path) |
|
1945 | rename(test.errpath, test.path) | |
1945 | else: |
|
1946 | else: | |
1946 | rename(test.errpath, '%s.out' % test.path) |
|
1947 | rename(test.errpath, '%s.out' % test.path) | |
1947 | accepted = True |
|
1948 | accepted = True | |
1948 | if not accepted: |
|
1949 | if not accepted: | |
1949 | self.faildata[test.name] = b''.join(lines) |
|
1950 | self.faildata[test.name] = b''.join(lines) | |
1950 |
|
1951 | |||
1951 | return accepted |
|
1952 | return accepted | |
1952 |
|
1953 | |||
1953 | def startTest(self, test): |
|
1954 | def startTest(self, test): | |
1954 | super(TestResult, self).startTest(test) |
|
1955 | super(TestResult, self).startTest(test) | |
1955 |
|
1956 | |||
1956 | # os.times module computes the user time and system time spent by |
|
1957 | # os.times module computes the user time and system time spent by | |
1957 | # child's processes along with real elapsed time taken by a process. |
|
1958 | # child's processes along with real elapsed time taken by a process. | |
1958 | # This module has one limitation. It can only work for Linux user |
|
1959 | # This module has one limitation. It can only work for Linux user | |
1959 | # and not for Windows. |
|
1960 | # and not for Windows. | |
1960 | test.started = os.times() |
|
1961 | test.started = os.times() | |
1961 | if self._firststarttime is None: # thread racy but irrelevant |
|
1962 | if self._firststarttime is None: # thread racy but irrelevant | |
1962 | self._firststarttime = test.started[4] |
|
1963 | self._firststarttime = test.started[4] | |
1963 |
|
1964 | |||
1964 | def stopTest(self, test, interrupted=False): |
|
1965 | def stopTest(self, test, interrupted=False): | |
1965 | super(TestResult, self).stopTest(test) |
|
1966 | super(TestResult, self).stopTest(test) | |
1966 |
|
1967 | |||
1967 | test.stopped = os.times() |
|
1968 | test.stopped = os.times() | |
1968 |
|
1969 | |||
1969 | starttime = test.started |
|
1970 | starttime = test.started | |
1970 | endtime = test.stopped |
|
1971 | endtime = test.stopped | |
1971 | origin = self._firststarttime |
|
1972 | origin = self._firststarttime | |
1972 | self.times.append((test.name, |
|
1973 | self.times.append((test.name, | |
1973 | endtime[2] - starttime[2], # user space CPU time |
|
1974 | endtime[2] - starttime[2], # user space CPU time | |
1974 | endtime[3] - starttime[3], # sys space CPU time |
|
1975 | endtime[3] - starttime[3], # sys space CPU time | |
1975 | endtime[4] - starttime[4], # real time |
|
1976 | endtime[4] - starttime[4], # real time | |
1976 | starttime[4] - origin, # start date in run context |
|
1977 | starttime[4] - origin, # start date in run context | |
1977 | endtime[4] - origin, # end date in run context |
|
1978 | endtime[4] - origin, # end date in run context | |
1978 | )) |
|
1979 | )) | |
1979 |
|
1980 | |||
1980 | if interrupted: |
|
1981 | if interrupted: | |
1981 | with iolock: |
|
1982 | with iolock: | |
1982 | self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % ( |
|
1983 | self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % ( | |
1983 | test.name, self.times[-1][3])) |
|
1984 | test.name, self.times[-1][3])) | |
1984 |
|
1985 | |||
1985 | def getTestResult(): |
|
1986 | def getTestResult(): | |
1986 | """ |
|
1987 | """ | |
1987 | Returns the relevant test result |
|
1988 | Returns the relevant test result | |
1988 | """ |
|
1989 | """ | |
1989 | if "CUSTOM_TEST_RESULT" in os.environ: |
|
1990 | if "CUSTOM_TEST_RESULT" in os.environ: | |
1990 | testresultmodule = __import__(os.environ["CUSTOM_TEST_RESULT"]) |
|
1991 | testresultmodule = __import__(os.environ["CUSTOM_TEST_RESULT"]) | |
1991 | return testresultmodule.TestResult |
|
1992 | return testresultmodule.TestResult | |
1992 | else: |
|
1993 | else: | |
1993 | return TestResult |
|
1994 | return TestResult | |
1994 |
|
1995 | |||
1995 | class TestSuite(unittest.TestSuite): |
|
1996 | class TestSuite(unittest.TestSuite): | |
1996 | """Custom unittest TestSuite that knows how to execute Mercurial tests.""" |
|
1997 | """Custom unittest TestSuite that knows how to execute Mercurial tests.""" | |
1997 |
|
1998 | |||
1998 | def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None, |
|
1999 | def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None, | |
1999 | retest=False, keywords=None, loop=False, runs_per_test=1, |
|
2000 | retest=False, keywords=None, loop=False, runs_per_test=1, | |
2000 | loadtest=None, showchannels=False, |
|
2001 | loadtest=None, showchannels=False, | |
2001 | *args, **kwargs): |
|
2002 | *args, **kwargs): | |
2002 | """Create a new instance that can run tests with a configuration. |
|
2003 | """Create a new instance that can run tests with a configuration. | |
2003 |
|
2004 | |||
2004 | testdir specifies the directory where tests are executed from. This |
|
2005 | testdir specifies the directory where tests are executed from. This | |
2005 | is typically the ``tests`` directory from Mercurial's source |
|
2006 | is typically the ``tests`` directory from Mercurial's source | |
2006 | repository. |
|
2007 | repository. | |
2007 |
|
2008 | |||
2008 | jobs specifies the number of jobs to run concurrently. Each test |
|
2009 | jobs specifies the number of jobs to run concurrently. Each test | |
2009 | executes on its own thread. Tests actually spawn new processes, so |
|
2010 | executes on its own thread. Tests actually spawn new processes, so | |
2010 | state mutation should not be an issue. |
|
2011 | state mutation should not be an issue. | |
2011 |
|
2012 | |||
2012 | If there is only one job, it will use the main thread. |
|
2013 | If there is only one job, it will use the main thread. | |
2013 |
|
2014 | |||
2014 | whitelist and blacklist denote tests that have been whitelisted and |
|
2015 | whitelist and blacklist denote tests that have been whitelisted and | |
2015 | blacklisted, respectively. These arguments don't belong in TestSuite. |
|
2016 | blacklisted, respectively. These arguments don't belong in TestSuite. | |
2016 | Instead, whitelist and blacklist should be handled by the thing that |
|
2017 | Instead, whitelist and blacklist should be handled by the thing that | |
2017 | populates the TestSuite with tests. They are present to preserve |
|
2018 | populates the TestSuite with tests. They are present to preserve | |
2018 | backwards compatible behavior which reports skipped tests as part |
|
2019 | backwards compatible behavior which reports skipped tests as part | |
2019 | of the results. |
|
2020 | of the results. | |
2020 |
|
2021 | |||
2021 | retest denotes whether to retest failed tests. This arguably belongs |
|
2022 | retest denotes whether to retest failed tests. This arguably belongs | |
2022 | outside of TestSuite. |
|
2023 | outside of TestSuite. | |
2023 |
|
2024 | |||
2024 | keywords denotes key words that will be used to filter which tests |
|
2025 | keywords denotes key words that will be used to filter which tests | |
2025 | to execute. This arguably belongs outside of TestSuite. |
|
2026 | to execute. This arguably belongs outside of TestSuite. | |
2026 |
|
2027 | |||
2027 | loop denotes whether to loop over tests forever. |
|
2028 | loop denotes whether to loop over tests forever. | |
2028 | """ |
|
2029 | """ | |
2029 | super(TestSuite, self).__init__(*args, **kwargs) |
|
2030 | super(TestSuite, self).__init__(*args, **kwargs) | |
2030 |
|
2031 | |||
2031 | self._jobs = jobs |
|
2032 | self._jobs = jobs | |
2032 | self._whitelist = whitelist |
|
2033 | self._whitelist = whitelist | |
2033 | self._blacklist = blacklist |
|
2034 | self._blacklist = blacklist | |
2034 | self._retest = retest |
|
2035 | self._retest = retest | |
2035 | self._keywords = keywords |
|
2036 | self._keywords = keywords | |
2036 | self._loop = loop |
|
2037 | self._loop = loop | |
2037 | self._runs_per_test = runs_per_test |
|
2038 | self._runs_per_test = runs_per_test | |
2038 | self._loadtest = loadtest |
|
2039 | self._loadtest = loadtest | |
2039 | self._showchannels = showchannels |
|
2040 | self._showchannels = showchannels | |
2040 |
|
2041 | |||
2041 | def run(self, result): |
|
2042 | def run(self, result): | |
2042 | # We have a number of filters that need to be applied. We do this |
|
2043 | # We have a number of filters that need to be applied. We do this | |
2043 | # here instead of inside Test because it makes the running logic for |
|
2044 | # here instead of inside Test because it makes the running logic for | |
2044 | # Test simpler. |
|
2045 | # Test simpler. | |
2045 | tests = [] |
|
2046 | tests = [] | |
2046 | num_tests = [0] |
|
2047 | num_tests = [0] | |
2047 | for test in self._tests: |
|
2048 | for test in self._tests: | |
2048 | def get(): |
|
2049 | def get(): | |
2049 | num_tests[0] += 1 |
|
2050 | num_tests[0] += 1 | |
2050 | if getattr(test, 'should_reload', False): |
|
2051 | if getattr(test, 'should_reload', False): | |
2051 | return self._loadtest(test, num_tests[0]) |
|
2052 | return self._loadtest(test, num_tests[0]) | |
2052 | return test |
|
2053 | return test | |
2053 | if not os.path.exists(test.path): |
|
2054 | if not os.path.exists(test.path): | |
2054 | result.addSkip(test, "Doesn't exist") |
|
2055 | result.addSkip(test, "Doesn't exist") | |
2055 | continue |
|
2056 | continue | |
2056 |
|
2057 | |||
2057 | if not (self._whitelist and test.bname in self._whitelist): |
|
2058 | if not (self._whitelist and test.bname in self._whitelist): | |
2058 | if self._blacklist and test.bname in self._blacklist: |
|
2059 | if self._blacklist and test.bname in self._blacklist: | |
2059 | result.addSkip(test, 'blacklisted') |
|
2060 | result.addSkip(test, 'blacklisted') | |
2060 | continue |
|
2061 | continue | |
2061 |
|
2062 | |||
2062 | if self._retest and not os.path.exists(test.errpath): |
|
2063 | if self._retest and not os.path.exists(test.errpath): | |
2063 | result.addIgnore(test, 'not retesting') |
|
2064 | result.addIgnore(test, 'not retesting') | |
2064 | continue |
|
2065 | continue | |
2065 |
|
2066 | |||
2066 | if self._keywords: |
|
2067 | if self._keywords: | |
2067 | with open(test.path, 'rb') as f: |
|
2068 | with open(test.path, 'rb') as f: | |
2068 | t = f.read().lower() + test.bname.lower() |
|
2069 | t = f.read().lower() + test.bname.lower() | |
2069 | ignored = False |
|
2070 | ignored = False | |
2070 | for k in self._keywords.lower().split(): |
|
2071 | for k in self._keywords.lower().split(): | |
2071 | if k not in t: |
|
2072 | if k not in t: | |
2072 | result.addIgnore(test, "doesn't match keyword") |
|
2073 | result.addIgnore(test, "doesn't match keyword") | |
2073 | ignored = True |
|
2074 | ignored = True | |
2074 | break |
|
2075 | break | |
2075 |
|
2076 | |||
2076 | if ignored: |
|
2077 | if ignored: | |
2077 | continue |
|
2078 | continue | |
2078 | for _ in xrange(self._runs_per_test): |
|
2079 | for _ in xrange(self._runs_per_test): | |
2079 | tests.append(get()) |
|
2080 | tests.append(get()) | |
2080 |
|
2081 | |||
2081 | runtests = list(tests) |
|
2082 | runtests = list(tests) | |
2082 | done = queue.Queue() |
|
2083 | done = queue.Queue() | |
2083 | running = 0 |
|
2084 | running = 0 | |
2084 |
|
2085 | |||
2085 | channels = [""] * self._jobs |
|
2086 | channels = [""] * self._jobs | |
2086 |
|
2087 | |||
2087 | def job(test, result): |
|
2088 | def job(test, result): | |
2088 | for n, v in enumerate(channels): |
|
2089 | for n, v in enumerate(channels): | |
2089 | if not v: |
|
2090 | if not v: | |
2090 | channel = n |
|
2091 | channel = n | |
2091 | break |
|
2092 | break | |
2092 | else: |
|
2093 | else: | |
2093 | raise ValueError('Could not find output channel') |
|
2094 | raise ValueError('Could not find output channel') | |
2094 | channels[channel] = "=" + test.name[5:].split(".")[0] |
|
2095 | channels[channel] = "=" + test.name[5:].split(".")[0] | |
2095 | try: |
|
2096 | try: | |
2096 | test(result) |
|
2097 | test(result) | |
2097 | done.put(None) |
|
2098 | done.put(None) | |
2098 | except KeyboardInterrupt: |
|
2099 | except KeyboardInterrupt: | |
2099 | pass |
|
2100 | pass | |
2100 | except: # re-raises |
|
2101 | except: # re-raises | |
2101 | done.put(('!', test, 'run-test raised an error, see traceback')) |
|
2102 | done.put(('!', test, 'run-test raised an error, see traceback')) | |
2102 | raise |
|
2103 | raise | |
2103 | finally: |
|
2104 | finally: | |
2104 | try: |
|
2105 | try: | |
2105 | channels[channel] = '' |
|
2106 | channels[channel] = '' | |
2106 | except IndexError: |
|
2107 | except IndexError: | |
2107 | pass |
|
2108 | pass | |
2108 |
|
2109 | |||
2109 | def stat(): |
|
2110 | def stat(): | |
2110 | count = 0 |
|
2111 | count = 0 | |
2111 | while channels: |
|
2112 | while channels: | |
2112 | d = '\n%03s ' % count |
|
2113 | d = '\n%03s ' % count | |
2113 | for n, v in enumerate(channels): |
|
2114 | for n, v in enumerate(channels): | |
2114 | if v: |
|
2115 | if v: | |
2115 | d += v[0] |
|
2116 | d += v[0] | |
2116 | channels[n] = v[1:] or '.' |
|
2117 | channels[n] = v[1:] or '.' | |
2117 | else: |
|
2118 | else: | |
2118 | d += ' ' |
|
2119 | d += ' ' | |
2119 | d += ' ' |
|
2120 | d += ' ' | |
2120 | with iolock: |
|
2121 | with iolock: | |
2121 | sys.stdout.write(d + ' ') |
|
2122 | sys.stdout.write(d + ' ') | |
2122 | sys.stdout.flush() |
|
2123 | sys.stdout.flush() | |
2123 | for x in xrange(10): |
|
2124 | for x in xrange(10): | |
2124 | if channels: |
|
2125 | if channels: | |
2125 | time.sleep(.1) |
|
2126 | time.sleep(.1) | |
2126 | count += 1 |
|
2127 | count += 1 | |
2127 |
|
2128 | |||
2128 | stoppedearly = False |
|
2129 | stoppedearly = False | |
2129 |
|
2130 | |||
2130 | if self._showchannels: |
|
2131 | if self._showchannels: | |
2131 | statthread = threading.Thread(target=stat, name="stat") |
|
2132 | statthread = threading.Thread(target=stat, name="stat") | |
2132 | statthread.start() |
|
2133 | statthread.start() | |
2133 |
|
2134 | |||
2134 | try: |
|
2135 | try: | |
2135 | while tests or running: |
|
2136 | while tests or running: | |
2136 | if not done.empty() or running == self._jobs or not tests: |
|
2137 | if not done.empty() or running == self._jobs or not tests: | |
2137 | try: |
|
2138 | try: | |
2138 | done.get(True, 1) |
|
2139 | done.get(True, 1) | |
2139 | running -= 1 |
|
2140 | running -= 1 | |
2140 | if result and result.shouldStop: |
|
2141 | if result and result.shouldStop: | |
2141 | stoppedearly = True |
|
2142 | stoppedearly = True | |
2142 | break |
|
2143 | break | |
2143 | except queue.Empty: |
|
2144 | except queue.Empty: | |
2144 | continue |
|
2145 | continue | |
2145 | if tests and not running == self._jobs: |
|
2146 | if tests and not running == self._jobs: | |
2146 | test = tests.pop(0) |
|
2147 | test = tests.pop(0) | |
2147 | if self._loop: |
|
2148 | if self._loop: | |
2148 | if getattr(test, 'should_reload', False): |
|
2149 | if getattr(test, 'should_reload', False): | |
2149 | num_tests[0] += 1 |
|
2150 | num_tests[0] += 1 | |
2150 | tests.append( |
|
2151 | tests.append( | |
2151 | self._loadtest(test, num_tests[0])) |
|
2152 | self._loadtest(test, num_tests[0])) | |
2152 | else: |
|
2153 | else: | |
2153 | tests.append(test) |
|
2154 | tests.append(test) | |
2154 | if self._jobs == 1: |
|
2155 | if self._jobs == 1: | |
2155 | job(test, result) |
|
2156 | job(test, result) | |
2156 | else: |
|
2157 | else: | |
2157 | t = threading.Thread(target=job, name=test.name, |
|
2158 | t = threading.Thread(target=job, name=test.name, | |
2158 | args=(test, result)) |
|
2159 | args=(test, result)) | |
2159 | t.start() |
|
2160 | t.start() | |
2160 | running += 1 |
|
2161 | running += 1 | |
2161 |
|
2162 | |||
2162 | # If we stop early we still need to wait on started tests to |
|
2163 | # If we stop early we still need to wait on started tests to | |
2163 | # finish. Otherwise, there is a race between the test completing |
|
2164 | # finish. Otherwise, there is a race between the test completing | |
2164 | # and the test's cleanup code running. This could result in the |
|
2165 | # and the test's cleanup code running. This could result in the | |
2165 | # test reporting incorrect. |
|
2166 | # test reporting incorrect. | |
2166 | if stoppedearly: |
|
2167 | if stoppedearly: | |
2167 | while running: |
|
2168 | while running: | |
2168 | try: |
|
2169 | try: | |
2169 | done.get(True, 1) |
|
2170 | done.get(True, 1) | |
2170 | running -= 1 |
|
2171 | running -= 1 | |
2171 | except queue.Empty: |
|
2172 | except queue.Empty: | |
2172 | continue |
|
2173 | continue | |
2173 | except KeyboardInterrupt: |
|
2174 | except KeyboardInterrupt: | |
2174 | for test in runtests: |
|
2175 | for test in runtests: | |
2175 | test.abort() |
|
2176 | test.abort() | |
2176 |
|
2177 | |||
2177 | channels = [] |
|
2178 | channels = [] | |
2178 |
|
2179 | |||
2179 | return result |
|
2180 | return result | |
2180 |
|
2181 | |||
2181 | # Save the most recent 5 wall-clock runtimes of each test to a |
|
2182 | # Save the most recent 5 wall-clock runtimes of each test to a | |
2182 | # human-readable text file named .testtimes. Tests are sorted |
|
2183 | # human-readable text file named .testtimes. Tests are sorted | |
2183 | # alphabetically, while times for each test are listed from oldest to |
|
2184 | # alphabetically, while times for each test are listed from oldest to | |
2184 | # newest. |
|
2185 | # newest. | |
2185 |
|
2186 | |||
2186 | def loadtimes(outputdir): |
|
2187 | def loadtimes(outputdir): | |
2187 | times = [] |
|
2188 | times = [] | |
2188 | try: |
|
2189 | try: | |
2189 | with open(os.path.join(outputdir, b'.testtimes')) as fp: |
|
2190 | with open(os.path.join(outputdir, b'.testtimes')) as fp: | |
2190 | for line in fp: |
|
2191 | for line in fp: | |
2191 | m = re.match('(.*?) ([0-9. ]+)', line) |
|
2192 | m = re.match('(.*?) ([0-9. ]+)', line) | |
2192 | times.append((m.group(1), |
|
2193 | times.append((m.group(1), | |
2193 | [float(t) for t in m.group(2).split()])) |
|
2194 | [float(t) for t in m.group(2).split()])) | |
2194 | except IOError as err: |
|
2195 | except IOError as err: | |
2195 | if err.errno != errno.ENOENT: |
|
2196 | if err.errno != errno.ENOENT: | |
2196 | raise |
|
2197 | raise | |
2197 | return times |
|
2198 | return times | |
2198 |
|
2199 | |||
2199 | def savetimes(outputdir, result): |
|
2200 | def savetimes(outputdir, result): | |
2200 | saved = dict(loadtimes(outputdir)) |
|
2201 | saved = dict(loadtimes(outputdir)) | |
2201 | maxruns = 5 |
|
2202 | maxruns = 5 | |
2202 | skipped = set([str(t[0]) for t in result.skipped]) |
|
2203 | skipped = set([str(t[0]) for t in result.skipped]) | |
2203 | for tdata in result.times: |
|
2204 | for tdata in result.times: | |
2204 | test, real = tdata[0], tdata[3] |
|
2205 | test, real = tdata[0], tdata[3] | |
2205 | if test not in skipped: |
|
2206 | if test not in skipped: | |
2206 | ts = saved.setdefault(test, []) |
|
2207 | ts = saved.setdefault(test, []) | |
2207 | ts.append(real) |
|
2208 | ts.append(real) | |
2208 | ts[:] = ts[-maxruns:] |
|
2209 | ts[:] = ts[-maxruns:] | |
2209 |
|
2210 | |||
2210 | fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes', |
|
2211 | fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes', | |
2211 | dir=outputdir, text=True) |
|
2212 | dir=outputdir, text=True) | |
2212 | with os.fdopen(fd, 'w') as fp: |
|
2213 | with os.fdopen(fd, 'w') as fp: | |
2213 | for name, ts in sorted(saved.items()): |
|
2214 | for name, ts in sorted(saved.items()): | |
2214 | fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts]))) |
|
2215 | fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts]))) | |
2215 | timepath = os.path.join(outputdir, b'.testtimes') |
|
2216 | timepath = os.path.join(outputdir, b'.testtimes') | |
2216 | try: |
|
2217 | try: | |
2217 | os.unlink(timepath) |
|
2218 | os.unlink(timepath) | |
2218 | except OSError: |
|
2219 | except OSError: | |
2219 | pass |
|
2220 | pass | |
2220 | try: |
|
2221 | try: | |
2221 | os.rename(tmpname, timepath) |
|
2222 | os.rename(tmpname, timepath) | |
2222 | except OSError: |
|
2223 | except OSError: | |
2223 | pass |
|
2224 | pass | |
2224 |
|
2225 | |||
2225 | class TextTestRunner(unittest.TextTestRunner): |
|
2226 | class TextTestRunner(unittest.TextTestRunner): | |
2226 | """Custom unittest test runner that uses appropriate settings.""" |
|
2227 | """Custom unittest test runner that uses appropriate settings.""" | |
2227 |
|
2228 | |||
2228 | def __init__(self, runner, *args, **kwargs): |
|
2229 | def __init__(self, runner, *args, **kwargs): | |
2229 | super(TextTestRunner, self).__init__(*args, **kwargs) |
|
2230 | super(TextTestRunner, self).__init__(*args, **kwargs) | |
2230 |
|
2231 | |||
2231 | self._runner = runner |
|
2232 | self._runner = runner | |
2232 |
|
2233 | |||
2233 | self._result = getTestResult()(self._runner.options, self.stream, |
|
2234 | self._result = getTestResult()(self._runner.options, self.stream, | |
2234 | self.descriptions, self.verbosity) |
|
2235 | self.descriptions, self.verbosity) | |
2235 |
|
2236 | |||
2236 | def listtests(self, test): |
|
2237 | def listtests(self, test): | |
2237 | test = sorted(test, key=lambda t: t.name) |
|
2238 | test = sorted(test, key=lambda t: t.name) | |
2238 |
|
2239 | |||
2239 | self._result.onStart(test) |
|
2240 | self._result.onStart(test) | |
2240 |
|
2241 | |||
2241 | for t in test: |
|
2242 | for t in test: | |
2242 | print(t.name) |
|
2243 | print(t.name) | |
2243 | self._result.addSuccess(t) |
|
2244 | self._result.addSuccess(t) | |
2244 |
|
2245 | |||
2245 | if self._runner.options.xunit: |
|
2246 | if self._runner.options.xunit: | |
2246 | with open(self._runner.options.xunit, "wb") as xuf: |
|
2247 | with open(self._runner.options.xunit, "wb") as xuf: | |
2247 | self._writexunit(self._result, xuf) |
|
2248 | self._writexunit(self._result, xuf) | |
2248 |
|
2249 | |||
2249 | if self._runner.options.json: |
|
2250 | if self._runner.options.json: | |
2250 | jsonpath = os.path.join(self._runner._outputdir, b'report.json') |
|
2251 | jsonpath = os.path.join(self._runner._outputdir, b'report.json') | |
2251 | with open(jsonpath, 'w') as fp: |
|
2252 | with open(jsonpath, 'w') as fp: | |
2252 | self._writejson(self._result, fp) |
|
2253 | self._writejson(self._result, fp) | |
2253 |
|
2254 | |||
2254 | return self._result |
|
2255 | return self._result | |
2255 |
|
2256 | |||
2256 | def run(self, test): |
|
2257 | def run(self, test): | |
2257 | self._result.onStart(test) |
|
2258 | self._result.onStart(test) | |
2258 | test(self._result) |
|
2259 | test(self._result) | |
2259 |
|
2260 | |||
2260 | failed = len(self._result.failures) |
|
2261 | failed = len(self._result.failures) | |
2261 | skipped = len(self._result.skipped) |
|
2262 | skipped = len(self._result.skipped) | |
2262 | ignored = len(self._result.ignored) |
|
2263 | ignored = len(self._result.ignored) | |
2263 |
|
2264 | |||
2264 | with iolock: |
|
2265 | with iolock: | |
2265 | self.stream.writeln('') |
|
2266 | self.stream.writeln('') | |
2266 |
|
2267 | |||
2267 | if not self._runner.options.noskips: |
|
2268 | if not self._runner.options.noskips: | |
2268 | for test, msg in sorted(self._result.skipped, |
|
2269 | for test, msg in sorted(self._result.skipped, | |
2269 | key=lambda s: s[0].name): |
|
2270 | key=lambda s: s[0].name): | |
2270 | formatted = 'Skipped %s: %s\n' % (test.name, msg) |
|
2271 | formatted = 'Skipped %s: %s\n' % (test.name, msg) | |
2271 | msg = highlightmsg(formatted, self._result.color) |
|
2272 | msg = highlightmsg(formatted, self._result.color) | |
2272 | self.stream.write(msg) |
|
2273 | self.stream.write(msg) | |
2273 | for test, msg in sorted(self._result.failures, |
|
2274 | for test, msg in sorted(self._result.failures, | |
2274 | key=lambda f: f[0].name): |
|
2275 | key=lambda f: f[0].name): | |
2275 | formatted = 'Failed %s: %s\n' % (test.name, msg) |
|
2276 | formatted = 'Failed %s: %s\n' % (test.name, msg) | |
2276 | self.stream.write(highlightmsg(formatted, self._result.color)) |
|
2277 | self.stream.write(highlightmsg(formatted, self._result.color)) | |
2277 | for test, msg in sorted(self._result.errors, |
|
2278 | for test, msg in sorted(self._result.errors, | |
2278 | key=lambda e: e[0].name): |
|
2279 | key=lambda e: e[0].name): | |
2279 | self.stream.writeln('Errored %s: %s' % (test.name, msg)) |
|
2280 | self.stream.writeln('Errored %s: %s' % (test.name, msg)) | |
2280 |
|
2281 | |||
2281 | if self._runner.options.xunit: |
|
2282 | if self._runner.options.xunit: | |
2282 | with open(self._runner.options.xunit, "wb") as xuf: |
|
2283 | with open(self._runner.options.xunit, "wb") as xuf: | |
2283 | self._writexunit(self._result, xuf) |
|
2284 | self._writexunit(self._result, xuf) | |
2284 |
|
2285 | |||
2285 | if self._runner.options.json: |
|
2286 | if self._runner.options.json: | |
2286 | jsonpath = os.path.join(self._runner._outputdir, b'report.json') |
|
2287 | jsonpath = os.path.join(self._runner._outputdir, b'report.json') | |
2287 | with open(jsonpath, 'w') as fp: |
|
2288 | with open(jsonpath, 'w') as fp: | |
2288 | self._writejson(self._result, fp) |
|
2289 | self._writejson(self._result, fp) | |
2289 |
|
2290 | |||
2290 | self._runner._checkhglib('Tested') |
|
2291 | self._runner._checkhglib('Tested') | |
2291 |
|
2292 | |||
2292 | savetimes(self._runner._outputdir, self._result) |
|
2293 | savetimes(self._runner._outputdir, self._result) | |
2293 |
|
2294 | |||
2294 | if failed and self._runner.options.known_good_rev: |
|
2295 | if failed and self._runner.options.known_good_rev: | |
2295 | self._bisecttests(t for t, m in self._result.failures) |
|
2296 | self._bisecttests(t for t, m in self._result.failures) | |
2296 | self.stream.writeln( |
|
2297 | self.stream.writeln( | |
2297 | '# Ran %d tests, %d skipped, %d failed.' |
|
2298 | '# Ran %d tests, %d skipped, %d failed.' | |
2298 | % (self._result.testsRun, skipped + ignored, failed)) |
|
2299 | % (self._result.testsRun, skipped + ignored, failed)) | |
2299 | if failed: |
|
2300 | if failed: | |
2300 | self.stream.writeln('python hash seed: %s' % |
|
2301 | self.stream.writeln('python hash seed: %s' % | |
2301 | os.environ['PYTHONHASHSEED']) |
|
2302 | os.environ['PYTHONHASHSEED']) | |
2302 | if self._runner.options.time: |
|
2303 | if self._runner.options.time: | |
2303 | self.printtimes(self._result.times) |
|
2304 | self.printtimes(self._result.times) | |
2304 |
|
2305 | |||
2305 | if self._runner.options.exceptions: |
|
2306 | if self._runner.options.exceptions: | |
2306 | exceptions = aggregateexceptions( |
|
2307 | exceptions = aggregateexceptions( | |
2307 | os.path.join(self._runner._outputdir, b'exceptions')) |
|
2308 | os.path.join(self._runner._outputdir, b'exceptions')) | |
2308 |
|
2309 | |||
2309 | self.stream.writeln('Exceptions Report:') |
|
2310 | self.stream.writeln('Exceptions Report:') | |
2310 | self.stream.writeln('%d total from %d frames' % |
|
2311 | self.stream.writeln('%d total from %d frames' % | |
2311 | (exceptions['total'], |
|
2312 | (exceptions['total'], | |
2312 | len(exceptions['exceptioncounts']))) |
|
2313 | len(exceptions['exceptioncounts']))) | |
2313 | combined = exceptions['combined'] |
|
2314 | combined = exceptions['combined'] | |
2314 | for key in sorted(combined, key=combined.get, reverse=True): |
|
2315 | for key in sorted(combined, key=combined.get, reverse=True): | |
2315 | frame, line, exc = key |
|
2316 | frame, line, exc = key | |
2316 | totalcount, testcount, leastcount, leasttest = combined[key] |
|
2317 | totalcount, testcount, leastcount, leasttest = combined[key] | |
2317 |
|
2318 | |||
2318 | self.stream.writeln('%d (%d tests)\t%s: %s (%s - %d total)' |
|
2319 | self.stream.writeln('%d (%d tests)\t%s: %s (%s - %d total)' | |
2319 | % (totalcount, |
|
2320 | % (totalcount, | |
2320 | testcount, |
|
2321 | testcount, | |
2321 | frame, exc, |
|
2322 | frame, exc, | |
2322 | leasttest, leastcount)) |
|
2323 | leasttest, leastcount)) | |
2323 |
|
2324 | |||
2324 | self.stream.flush() |
|
2325 | self.stream.flush() | |
2325 |
|
2326 | |||
2326 | return self._result |
|
2327 | return self._result | |
2327 |
|
2328 | |||
2328 | def _bisecttests(self, tests): |
|
2329 | def _bisecttests(self, tests): | |
2329 | bisectcmd = ['hg', 'bisect'] |
|
2330 | bisectcmd = ['hg', 'bisect'] | |
2330 | bisectrepo = self._runner.options.bisect_repo |
|
2331 | bisectrepo = self._runner.options.bisect_repo | |
2331 | if bisectrepo: |
|
2332 | if bisectrepo: | |
2332 | bisectcmd.extend(['-R', os.path.abspath(bisectrepo)]) |
|
2333 | bisectcmd.extend(['-R', os.path.abspath(bisectrepo)]) | |
2333 | def pread(args): |
|
2334 | def pread(args): | |
2334 | env = os.environ.copy() |
|
2335 | env = os.environ.copy() | |
2335 | env['HGPLAIN'] = '1' |
|
2336 | env['HGPLAIN'] = '1' | |
2336 | p = subprocess.Popen(args, stderr=subprocess.STDOUT, |
|
2337 | p = subprocess.Popen(args, stderr=subprocess.STDOUT, | |
2337 | stdout=subprocess.PIPE, env=env) |
|
2338 | stdout=subprocess.PIPE, env=env) | |
2338 | data = p.stdout.read() |
|
2339 | data = p.stdout.read() | |
2339 | p.wait() |
|
2340 | p.wait() | |
2340 | return data |
|
2341 | return data | |
2341 | for test in tests: |
|
2342 | for test in tests: | |
2342 | pread(bisectcmd + ['--reset']), |
|
2343 | pread(bisectcmd + ['--reset']), | |
2343 | pread(bisectcmd + ['--bad', '.']) |
|
2344 | pread(bisectcmd + ['--bad', '.']) | |
2344 | pread(bisectcmd + ['--good', self._runner.options.known_good_rev]) |
|
2345 | pread(bisectcmd + ['--good', self._runner.options.known_good_rev]) | |
2345 | # TODO: we probably need to forward more options |
|
2346 | # TODO: we probably need to forward more options | |
2346 | # that alter hg's behavior inside the tests. |
|
2347 | # that alter hg's behavior inside the tests. | |
2347 | opts = '' |
|
2348 | opts = '' | |
2348 | withhg = self._runner.options.with_hg |
|
2349 | withhg = self._runner.options.with_hg | |
2349 | if withhg: |
|
2350 | if withhg: | |
2350 | opts += ' --with-hg=%s ' % shellquote(_strpath(withhg)) |
|
2351 | opts += ' --with-hg=%s ' % shellquote(_strpath(withhg)) | |
2351 | rtc = '%s %s %s %s' % (sys.executable, sys.argv[0], opts, |
|
2352 | rtc = '%s %s %s %s' % (sys.executable, sys.argv[0], opts, | |
2352 | test) |
|
2353 | test) | |
2353 | data = pread(bisectcmd + ['--command', rtc]) |
|
2354 | data = pread(bisectcmd + ['--command', rtc]) | |
2354 | m = re.search( |
|
2355 | m = re.search( | |
2355 | (br'\nThe first (?P<goodbad>bad|good) revision ' |
|
2356 | (br'\nThe first (?P<goodbad>bad|good) revision ' | |
2356 | br'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n' |
|
2357 | br'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n' | |
2357 | br'summary: +(?P<summary>[^\n]+)\n'), |
|
2358 | br'summary: +(?P<summary>[^\n]+)\n'), | |
2358 | data, (re.MULTILINE | re.DOTALL)) |
|
2359 | data, (re.MULTILINE | re.DOTALL)) | |
2359 | if m is None: |
|
2360 | if m is None: | |
2360 | self.stream.writeln( |
|
2361 | self.stream.writeln( | |
2361 | 'Failed to identify failure point for %s' % test) |
|
2362 | 'Failed to identify failure point for %s' % test) | |
2362 | continue |
|
2363 | continue | |
2363 | dat = m.groupdict() |
|
2364 | dat = m.groupdict() | |
2364 | verb = 'broken' if dat['goodbad'] == b'bad' else 'fixed' |
|
2365 | verb = 'broken' if dat['goodbad'] == b'bad' else 'fixed' | |
2365 | self.stream.writeln( |
|
2366 | self.stream.writeln( | |
2366 | '%s %s by %s (%s)' % ( |
|
2367 | '%s %s by %s (%s)' % ( | |
2367 | test, verb, dat['node'].decode('ascii'), |
|
2368 | test, verb, dat['node'].decode('ascii'), | |
2368 | dat['summary'].decode('utf8', 'ignore'))) |
|
2369 | dat['summary'].decode('utf8', 'ignore'))) | |
2369 |
|
2370 | |||
2370 | def printtimes(self, times): |
|
2371 | def printtimes(self, times): | |
2371 | # iolock held by run |
|
2372 | # iolock held by run | |
2372 | self.stream.writeln('# Producing time report') |
|
2373 | self.stream.writeln('# Producing time report') | |
2373 | times.sort(key=lambda t: (t[3])) |
|
2374 | times.sort(key=lambda t: (t[3])) | |
2374 | cols = '%7.3f %7.3f %7.3f %7.3f %7.3f %s' |
|
2375 | cols = '%7.3f %7.3f %7.3f %7.3f %7.3f %s' | |
2375 | self.stream.writeln('%-7s %-7s %-7s %-7s %-7s %s' % |
|
2376 | self.stream.writeln('%-7s %-7s %-7s %-7s %-7s %s' % | |
2376 | ('start', 'end', 'cuser', 'csys', 'real', 'Test')) |
|
2377 | ('start', 'end', 'cuser', 'csys', 'real', 'Test')) | |
2377 | for tdata in times: |
|
2378 | for tdata in times: | |
2378 | test = tdata[0] |
|
2379 | test = tdata[0] | |
2379 | cuser, csys, real, start, end = tdata[1:6] |
|
2380 | cuser, csys, real, start, end = tdata[1:6] | |
2380 | self.stream.writeln(cols % (start, end, cuser, csys, real, test)) |
|
2381 | self.stream.writeln(cols % (start, end, cuser, csys, real, test)) | |
2381 |
|
2382 | |||
2382 | @staticmethod |
|
2383 | @staticmethod | |
2383 | def _writexunit(result, outf): |
|
2384 | def _writexunit(result, outf): | |
2384 | # See http://llg.cubic.org/docs/junit/ for a reference. |
|
2385 | # See http://llg.cubic.org/docs/junit/ for a reference. | |
2385 | timesd = dict((t[0], t[3]) for t in result.times) |
|
2386 | timesd = dict((t[0], t[3]) for t in result.times) | |
2386 | doc = minidom.Document() |
|
2387 | doc = minidom.Document() | |
2387 | s = doc.createElement('testsuite') |
|
2388 | s = doc.createElement('testsuite') | |
2388 | s.setAttribute('errors', "0") # TODO |
|
2389 | s.setAttribute('errors', "0") # TODO | |
2389 | s.setAttribute('failures', str(len(result.failures))) |
|
2390 | s.setAttribute('failures', str(len(result.failures))) | |
2390 | s.setAttribute('name', 'run-tests') |
|
2391 | s.setAttribute('name', 'run-tests') | |
2391 | s.setAttribute('skipped', str(len(result.skipped) + |
|
2392 | s.setAttribute('skipped', str(len(result.skipped) + | |
2392 | len(result.ignored))) |
|
2393 | len(result.ignored))) | |
2393 | s.setAttribute('tests', str(result.testsRun)) |
|
2394 | s.setAttribute('tests', str(result.testsRun)) | |
2394 | doc.appendChild(s) |
|
2395 | doc.appendChild(s) | |
2395 | for tc in result.successes: |
|
2396 | for tc in result.successes: | |
2396 | t = doc.createElement('testcase') |
|
2397 | t = doc.createElement('testcase') | |
2397 | t.setAttribute('name', tc.name) |
|
2398 | t.setAttribute('name', tc.name) | |
2398 | tctime = timesd.get(tc.name) |
|
2399 | tctime = timesd.get(tc.name) | |
2399 | if tctime is not None: |
|
2400 | if tctime is not None: | |
2400 | t.setAttribute('time', '%.3f' % tctime) |
|
2401 | t.setAttribute('time', '%.3f' % tctime) | |
2401 | s.appendChild(t) |
|
2402 | s.appendChild(t) | |
2402 | for tc, err in sorted(result.faildata.items()): |
|
2403 | for tc, err in sorted(result.faildata.items()): | |
2403 | t = doc.createElement('testcase') |
|
2404 | t = doc.createElement('testcase') | |
2404 | t.setAttribute('name', tc) |
|
2405 | t.setAttribute('name', tc) | |
2405 | tctime = timesd.get(tc) |
|
2406 | tctime = timesd.get(tc) | |
2406 | if tctime is not None: |
|
2407 | if tctime is not None: | |
2407 | t.setAttribute('time', '%.3f' % tctime) |
|
2408 | t.setAttribute('time', '%.3f' % tctime) | |
2408 | # createCDATASection expects a unicode or it will |
|
2409 | # createCDATASection expects a unicode or it will | |
2409 | # convert using default conversion rules, which will |
|
2410 | # convert using default conversion rules, which will | |
2410 | # fail if string isn't ASCII. |
|
2411 | # fail if string isn't ASCII. | |
2411 | err = cdatasafe(err).decode('utf-8', 'replace') |
|
2412 | err = cdatasafe(err).decode('utf-8', 'replace') | |
2412 | cd = doc.createCDATASection(err) |
|
2413 | cd = doc.createCDATASection(err) | |
2413 | # Use 'failure' here instead of 'error' to match errors = 0, |
|
2414 | # Use 'failure' here instead of 'error' to match errors = 0, | |
2414 | # failures = len(result.failures) in the testsuite element. |
|
2415 | # failures = len(result.failures) in the testsuite element. | |
2415 | failelem = doc.createElement('failure') |
|
2416 | failelem = doc.createElement('failure') | |
2416 | failelem.setAttribute('message', 'output changed') |
|
2417 | failelem.setAttribute('message', 'output changed') | |
2417 | failelem.setAttribute('type', 'output-mismatch') |
|
2418 | failelem.setAttribute('type', 'output-mismatch') | |
2418 | failelem.appendChild(cd) |
|
2419 | failelem.appendChild(cd) | |
2419 | t.appendChild(failelem) |
|
2420 | t.appendChild(failelem) | |
2420 | s.appendChild(t) |
|
2421 | s.appendChild(t) | |
2421 | for tc, message in result.skipped: |
|
2422 | for tc, message in result.skipped: | |
2422 | # According to the schema, 'skipped' has no attributes. So store |
|
2423 | # According to the schema, 'skipped' has no attributes. So store | |
2423 | # the skip message as a text node instead. |
|
2424 | # the skip message as a text node instead. | |
2424 | t = doc.createElement('testcase') |
|
2425 | t = doc.createElement('testcase') | |
2425 | t.setAttribute('name', tc.name) |
|
2426 | t.setAttribute('name', tc.name) | |
2426 | binmessage = message.encode('utf-8') |
|
2427 | binmessage = message.encode('utf-8') | |
2427 | message = cdatasafe(binmessage).decode('utf-8', 'replace') |
|
2428 | message = cdatasafe(binmessage).decode('utf-8', 'replace') | |
2428 | cd = doc.createCDATASection(message) |
|
2429 | cd = doc.createCDATASection(message) | |
2429 | skipelem = doc.createElement('skipped') |
|
2430 | skipelem = doc.createElement('skipped') | |
2430 | skipelem.appendChild(cd) |
|
2431 | skipelem.appendChild(cd) | |
2431 | t.appendChild(skipelem) |
|
2432 | t.appendChild(skipelem) | |
2432 | s.appendChild(t) |
|
2433 | s.appendChild(t) | |
2433 | outf.write(doc.toprettyxml(indent=' ', encoding='utf-8')) |
|
2434 | outf.write(doc.toprettyxml(indent=' ', encoding='utf-8')) | |
2434 |
|
2435 | |||
2435 | @staticmethod |
|
2436 | @staticmethod | |
2436 | def _writejson(result, outf): |
|
2437 | def _writejson(result, outf): | |
2437 | timesd = {} |
|
2438 | timesd = {} | |
2438 | for tdata in result.times: |
|
2439 | for tdata in result.times: | |
2439 | test = tdata[0] |
|
2440 | test = tdata[0] | |
2440 | timesd[test] = tdata[1:] |
|
2441 | timesd[test] = tdata[1:] | |
2441 |
|
2442 | |||
2442 | outcome = {} |
|
2443 | outcome = {} | |
2443 | groups = [('success', ((tc, None) |
|
2444 | groups = [('success', ((tc, None) | |
2444 | for tc in result.successes)), |
|
2445 | for tc in result.successes)), | |
2445 | ('failure', result.failures), |
|
2446 | ('failure', result.failures), | |
2446 | ('skip', result.skipped)] |
|
2447 | ('skip', result.skipped)] | |
2447 | for res, testcases in groups: |
|
2448 | for res, testcases in groups: | |
2448 | for tc, __ in testcases: |
|
2449 | for tc, __ in testcases: | |
2449 | if tc.name in timesd: |
|
2450 | if tc.name in timesd: | |
2450 | diff = result.faildata.get(tc.name, b'') |
|
2451 | diff = result.faildata.get(tc.name, b'') | |
2451 | try: |
|
2452 | try: | |
2452 | diff = diff.decode('unicode_escape') |
|
2453 | diff = diff.decode('unicode_escape') | |
2453 | except UnicodeDecodeError as e: |
|
2454 | except UnicodeDecodeError as e: | |
2454 | diff = '%r decoding diff, sorry' % e |
|
2455 | diff = '%r decoding diff, sorry' % e | |
2455 | tres = {'result': res, |
|
2456 | tres = {'result': res, | |
2456 | 'time': ('%0.3f' % timesd[tc.name][2]), |
|
2457 | 'time': ('%0.3f' % timesd[tc.name][2]), | |
2457 | 'cuser': ('%0.3f' % timesd[tc.name][0]), |
|
2458 | 'cuser': ('%0.3f' % timesd[tc.name][0]), | |
2458 | 'csys': ('%0.3f' % timesd[tc.name][1]), |
|
2459 | 'csys': ('%0.3f' % timesd[tc.name][1]), | |
2459 | 'start': ('%0.3f' % timesd[tc.name][3]), |
|
2460 | 'start': ('%0.3f' % timesd[tc.name][3]), | |
2460 | 'end': ('%0.3f' % timesd[tc.name][4]), |
|
2461 | 'end': ('%0.3f' % timesd[tc.name][4]), | |
2461 | 'diff': diff, |
|
2462 | 'diff': diff, | |
2462 | } |
|
2463 | } | |
2463 | else: |
|
2464 | else: | |
2464 | # blacklisted test |
|
2465 | # blacklisted test | |
2465 | tres = {'result': res} |
|
2466 | tres = {'result': res} | |
2466 |
|
2467 | |||
2467 | outcome[tc.name] = tres |
|
2468 | outcome[tc.name] = tres | |
2468 | jsonout = json.dumps(outcome, sort_keys=True, indent=4, |
|
2469 | jsonout = json.dumps(outcome, sort_keys=True, indent=4, | |
2469 | separators=(',', ': ')) |
|
2470 | separators=(',', ': ')) | |
2470 | outf.writelines(("testreport =", jsonout)) |
|
2471 | outf.writelines(("testreport =", jsonout)) | |
2471 |
|
2472 | |||
2472 | def sorttests(testdescs, previoustimes, shuffle=False): |
|
2473 | def sorttests(testdescs, previoustimes, shuffle=False): | |
2473 | """Do an in-place sort of tests.""" |
|
2474 | """Do an in-place sort of tests.""" | |
2474 | if shuffle: |
|
2475 | if shuffle: | |
2475 | random.shuffle(testdescs) |
|
2476 | random.shuffle(testdescs) | |
2476 | return |
|
2477 | return | |
2477 |
|
2478 | |||
2478 | if previoustimes: |
|
2479 | if previoustimes: | |
2479 | def sortkey(f): |
|
2480 | def sortkey(f): | |
2480 | f = f['path'] |
|
2481 | f = f['path'] | |
2481 | if f in previoustimes: |
|
2482 | if f in previoustimes: | |
2482 | # Use most recent time as estimate |
|
2483 | # Use most recent time as estimate | |
2483 | return -previoustimes[f][-1] |
|
2484 | return -previoustimes[f][-1] | |
2484 | else: |
|
2485 | else: | |
2485 | # Default to a rather arbitrary value of 1 second for new tests |
|
2486 | # Default to a rather arbitrary value of 1 second for new tests | |
2486 | return -1.0 |
|
2487 | return -1.0 | |
2487 | else: |
|
2488 | else: | |
2488 | # keywords for slow tests |
|
2489 | # keywords for slow tests | |
2489 | slow = {b'svn': 10, |
|
2490 | slow = {b'svn': 10, | |
2490 | b'cvs': 10, |
|
2491 | b'cvs': 10, | |
2491 | b'hghave': 10, |
|
2492 | b'hghave': 10, | |
2492 | b'largefiles-update': 10, |
|
2493 | b'largefiles-update': 10, | |
2493 | b'run-tests': 10, |
|
2494 | b'run-tests': 10, | |
2494 | b'corruption': 10, |
|
2495 | b'corruption': 10, | |
2495 | b'race': 10, |
|
2496 | b'race': 10, | |
2496 | b'i18n': 10, |
|
2497 | b'i18n': 10, | |
2497 | b'check': 100, |
|
2498 | b'check': 100, | |
2498 | b'gendoc': 100, |
|
2499 | b'gendoc': 100, | |
2499 | b'contrib-perf': 200, |
|
2500 | b'contrib-perf': 200, | |
2500 | } |
|
2501 | } | |
2501 | perf = {} |
|
2502 | perf = {} | |
2502 |
|
2503 | |||
2503 | def sortkey(f): |
|
2504 | def sortkey(f): | |
2504 | # run largest tests first, as they tend to take the longest |
|
2505 | # run largest tests first, as they tend to take the longest | |
2505 | f = f['path'] |
|
2506 | f = f['path'] | |
2506 | try: |
|
2507 | try: | |
2507 | return perf[f] |
|
2508 | return perf[f] | |
2508 | except KeyError: |
|
2509 | except KeyError: | |
2509 | try: |
|
2510 | try: | |
2510 | val = -os.stat(f).st_size |
|
2511 | val = -os.stat(f).st_size | |
2511 | except OSError as e: |
|
2512 | except OSError as e: | |
2512 | if e.errno != errno.ENOENT: |
|
2513 | if e.errno != errno.ENOENT: | |
2513 | raise |
|
2514 | raise | |
2514 | perf[f] = -1e9 # file does not exist, tell early |
|
2515 | perf[f] = -1e9 # file does not exist, tell early | |
2515 | return -1e9 |
|
2516 | return -1e9 | |
2516 | for kw, mul in slow.items(): |
|
2517 | for kw, mul in slow.items(): | |
2517 | if kw in f: |
|
2518 | if kw in f: | |
2518 | val *= mul |
|
2519 | val *= mul | |
2519 | if f.endswith(b'.py'): |
|
2520 | if f.endswith(b'.py'): | |
2520 | val /= 10.0 |
|
2521 | val /= 10.0 | |
2521 | perf[f] = val / 1000.0 |
|
2522 | perf[f] = val / 1000.0 | |
2522 | return perf[f] |
|
2523 | return perf[f] | |
2523 |
|
2524 | |||
2524 | testdescs.sort(key=sortkey) |
|
2525 | testdescs.sort(key=sortkey) | |
2525 |
|
2526 | |||
2526 | class TestRunner(object): |
|
2527 | class TestRunner(object): | |
2527 | """Holds context for executing tests. |
|
2528 | """Holds context for executing tests. | |
2528 |
|
2529 | |||
2529 | Tests rely on a lot of state. This object holds it for them. |
|
2530 | Tests rely on a lot of state. This object holds it for them. | |
2530 | """ |
|
2531 | """ | |
2531 |
|
2532 | |||
2532 | # Programs required to run tests. |
|
2533 | # Programs required to run tests. | |
2533 | REQUIREDTOOLS = [ |
|
2534 | REQUIREDTOOLS = [ | |
2534 | b'diff', |
|
2535 | b'diff', | |
2535 | b'grep', |
|
2536 | b'grep', | |
2536 | b'unzip', |
|
2537 | b'unzip', | |
2537 | b'gunzip', |
|
2538 | b'gunzip', | |
2538 | b'bunzip2', |
|
2539 | b'bunzip2', | |
2539 | b'sed', |
|
2540 | b'sed', | |
2540 | ] |
|
2541 | ] | |
2541 |
|
2542 | |||
2542 | # Maps file extensions to test class. |
|
2543 | # Maps file extensions to test class. | |
2543 | TESTTYPES = [ |
|
2544 | TESTTYPES = [ | |
2544 | (b'.py', PythonTest), |
|
2545 | (b'.py', PythonTest), | |
2545 | (b'.t', TTest), |
|
2546 | (b'.t', TTest), | |
2546 | ] |
|
2547 | ] | |
2547 |
|
2548 | |||
2548 | def __init__(self): |
|
2549 | def __init__(self): | |
2549 | self.options = None |
|
2550 | self.options = None | |
2550 | self._hgroot = None |
|
2551 | self._hgroot = None | |
2551 | self._testdir = None |
|
2552 | self._testdir = None | |
2552 | self._outputdir = None |
|
2553 | self._outputdir = None | |
2553 | self._hgtmp = None |
|
2554 | self._hgtmp = None | |
2554 | self._installdir = None |
|
2555 | self._installdir = None | |
2555 | self._bindir = None |
|
2556 | self._bindir = None | |
2556 | self._tmpbinddir = None |
|
2557 | self._tmpbinddir = None | |
2557 | self._pythondir = None |
|
2558 | self._pythondir = None | |
2558 | self._coveragefile = None |
|
2559 | self._coveragefile = None | |
2559 | self._createdfiles = [] |
|
2560 | self._createdfiles = [] | |
2560 | self._hgcommand = None |
|
2561 | self._hgcommand = None | |
2561 | self._hgpath = None |
|
2562 | self._hgpath = None | |
2562 | self._portoffset = 0 |
|
2563 | self._portoffset = 0 | |
2563 | self._ports = {} |
|
2564 | self._ports = {} | |
2564 |
|
2565 | |||
2565 | def run(self, args, parser=None): |
|
2566 | def run(self, args, parser=None): | |
2566 | """Run the test suite.""" |
|
2567 | """Run the test suite.""" | |
2567 | oldmask = os.umask(0o22) |
|
2568 | oldmask = os.umask(0o22) | |
2568 | try: |
|
2569 | try: | |
2569 | parser = parser or getparser() |
|
2570 | parser = parser or getparser() | |
2570 | options = parseargs(args, parser) |
|
2571 | options = parseargs(args, parser) | |
2571 | tests = [_bytespath(a) for a in options.tests] |
|
2572 | tests = [_bytespath(a) for a in options.tests] | |
2572 | if options.test_list is not None: |
|
2573 | if options.test_list is not None: | |
2573 | for listfile in options.test_list: |
|
2574 | for listfile in options.test_list: | |
2574 | with open(listfile, 'rb') as f: |
|
2575 | with open(listfile, 'rb') as f: | |
2575 | tests.extend(t for t in f.read().splitlines() if t) |
|
2576 | tests.extend(t for t in f.read().splitlines() if t) | |
2576 | self.options = options |
|
2577 | self.options = options | |
2577 |
|
2578 | |||
2578 | self._checktools() |
|
2579 | self._checktools() | |
2579 | testdescs = self.findtests(tests) |
|
2580 | testdescs = self.findtests(tests) | |
2580 | if options.profile_runner: |
|
2581 | if options.profile_runner: | |
2581 | import statprof |
|
2582 | import statprof | |
2582 | statprof.start() |
|
2583 | statprof.start() | |
2583 | result = self._run(testdescs) |
|
2584 | result = self._run(testdescs) | |
2584 | if options.profile_runner: |
|
2585 | if options.profile_runner: | |
2585 | statprof.stop() |
|
2586 | statprof.stop() | |
2586 | statprof.display() |
|
2587 | statprof.display() | |
2587 | return result |
|
2588 | return result | |
2588 |
|
2589 | |||
2589 | finally: |
|
2590 | finally: | |
2590 | os.umask(oldmask) |
|
2591 | os.umask(oldmask) | |
2591 |
|
2592 | |||
2592 | def _run(self, testdescs): |
|
2593 | def _run(self, testdescs): | |
2593 | testdir = getcwdb() |
|
2594 | testdir = getcwdb() | |
2594 | self._testdir = osenvironb[b'TESTDIR'] = getcwdb() |
|
2595 | self._testdir = osenvironb[b'TESTDIR'] = getcwdb() | |
2595 | # assume all tests in same folder for now |
|
2596 | # assume all tests in same folder for now | |
2596 | if testdescs: |
|
2597 | if testdescs: | |
2597 | pathname = os.path.dirname(testdescs[0]['path']) |
|
2598 | pathname = os.path.dirname(testdescs[0]['path']) | |
2598 | if pathname: |
|
2599 | if pathname: | |
2599 | testdir = os.path.join(testdir, pathname) |
|
2600 | testdir = os.path.join(testdir, pathname) | |
2600 | self._testdir = osenvironb[b'TESTDIR'] = testdir |
|
2601 | self._testdir = osenvironb[b'TESTDIR'] = testdir | |
2601 | if self.options.outputdir: |
|
2602 | if self.options.outputdir: | |
2602 | self._outputdir = canonpath(_bytespath(self.options.outputdir)) |
|
2603 | self._outputdir = canonpath(_bytespath(self.options.outputdir)) | |
2603 | else: |
|
2604 | else: | |
2604 | self._outputdir = getcwdb() |
|
2605 | self._outputdir = getcwdb() | |
2605 | if testdescs and pathname: |
|
2606 | if testdescs and pathname: | |
2606 | self._outputdir = os.path.join(self._outputdir, pathname) |
|
2607 | self._outputdir = os.path.join(self._outputdir, pathname) | |
2607 | previoustimes = {} |
|
2608 | previoustimes = {} | |
2608 | if self.options.order_by_runtime: |
|
2609 | if self.options.order_by_runtime: | |
2609 | previoustimes = dict(loadtimes(self._outputdir)) |
|
2610 | previoustimes = dict(loadtimes(self._outputdir)) | |
2610 | sorttests(testdescs, previoustimes, shuffle=self.options.random) |
|
2611 | sorttests(testdescs, previoustimes, shuffle=self.options.random) | |
2611 |
|
2612 | |||
2612 | if 'PYTHONHASHSEED' not in os.environ: |
|
2613 | if 'PYTHONHASHSEED' not in os.environ: | |
2613 | # use a random python hash seed all the time |
|
2614 | # use a random python hash seed all the time | |
2614 | # we do the randomness ourself to know what seed is used |
|
2615 | # we do the randomness ourself to know what seed is used | |
2615 | os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32)) |
|
2616 | os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32)) | |
2616 |
|
2617 | |||
2617 | if self.options.tmpdir: |
|
2618 | if self.options.tmpdir: | |
2618 | self.options.keep_tmpdir = True |
|
2619 | self.options.keep_tmpdir = True | |
2619 | tmpdir = _bytespath(self.options.tmpdir) |
|
2620 | tmpdir = _bytespath(self.options.tmpdir) | |
2620 | if os.path.exists(tmpdir): |
|
2621 | if os.path.exists(tmpdir): | |
2621 | # Meaning of tmpdir has changed since 1.3: we used to create |
|
2622 | # Meaning of tmpdir has changed since 1.3: we used to create | |
2622 | # HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if |
|
2623 | # HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if | |
2623 | # tmpdir already exists. |
|
2624 | # tmpdir already exists. | |
2624 | print("error: temp dir %r already exists" % tmpdir) |
|
2625 | print("error: temp dir %r already exists" % tmpdir) | |
2625 | return 1 |
|
2626 | return 1 | |
2626 |
|
2627 | |||
2627 | os.makedirs(tmpdir) |
|
2628 | os.makedirs(tmpdir) | |
2628 | else: |
|
2629 | else: | |
2629 | d = None |
|
2630 | d = None | |
2630 | if os.name == 'nt': |
|
2631 | if os.name == 'nt': | |
2631 | # without this, we get the default temp dir location, but |
|
2632 | # without this, we get the default temp dir location, but | |
2632 | # in all lowercase, which causes troubles with paths (issue3490) |
|
2633 | # in all lowercase, which causes troubles with paths (issue3490) | |
2633 | d = osenvironb.get(b'TMP', None) |
|
2634 | d = osenvironb.get(b'TMP', None) | |
2634 | tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d) |
|
2635 | tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d) | |
2635 |
|
2636 | |||
2636 | self._hgtmp = osenvironb[b'HGTMP'] = ( |
|
2637 | self._hgtmp = osenvironb[b'HGTMP'] = ( | |
2637 | os.path.realpath(tmpdir)) |
|
2638 | os.path.realpath(tmpdir)) | |
2638 |
|
2639 | |||
2639 | if self.options.with_hg: |
|
2640 | if self.options.with_hg: | |
2640 | self._installdir = None |
|
2641 | self._installdir = None | |
2641 | whg = self.options.with_hg |
|
2642 | whg = self.options.with_hg | |
2642 | self._bindir = os.path.dirname(os.path.realpath(whg)) |
|
2643 | self._bindir = os.path.dirname(os.path.realpath(whg)) | |
2643 | assert isinstance(self._bindir, bytes) |
|
2644 | assert isinstance(self._bindir, bytes) | |
2644 | self._hgcommand = os.path.basename(whg) |
|
2645 | self._hgcommand = os.path.basename(whg) | |
2645 | self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin') |
|
2646 | self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin') | |
2646 | os.makedirs(self._tmpbindir) |
|
2647 | os.makedirs(self._tmpbindir) | |
2647 |
|
2648 | |||
2648 | normbin = os.path.normpath(os.path.abspath(whg)) |
|
2649 | normbin = os.path.normpath(os.path.abspath(whg)) | |
2649 | normbin = normbin.replace(os.sep.encode('ascii'), b'/') |
|
2650 | normbin = normbin.replace(os.sep.encode('ascii'), b'/') | |
2650 |
|
2651 | |||
2651 | # Other Python scripts in the test harness need to |
|
2652 | # Other Python scripts in the test harness need to | |
2652 | # `import mercurial`. If `hg` is a Python script, we assume |
|
2653 | # `import mercurial`. If `hg` is a Python script, we assume | |
2653 | # the Mercurial modules are relative to its path and tell the tests |
|
2654 | # the Mercurial modules are relative to its path and tell the tests | |
2654 | # to load Python modules from its directory. |
|
2655 | # to load Python modules from its directory. | |
2655 | with open(whg, 'rb') as fh: |
|
2656 | with open(whg, 'rb') as fh: | |
2656 | initial = fh.read(1024) |
|
2657 | initial = fh.read(1024) | |
2657 |
|
2658 | |||
2658 | if re.match(b'#!.*python', initial): |
|
2659 | if re.match(b'#!.*python', initial): | |
2659 | self._pythondir = self._bindir |
|
2660 | self._pythondir = self._bindir | |
2660 | # If it looks like our in-repo Rust binary, use the source root. |
|
2661 | # If it looks like our in-repo Rust binary, use the source root. | |
2661 | # This is a bit hacky. But rhg is still not supported outside the |
|
2662 | # This is a bit hacky. But rhg is still not supported outside the | |
2662 | # source directory. So until it is, do the simple thing. |
|
2663 | # source directory. So until it is, do the simple thing. | |
2663 | elif re.search(b'/rust/target/[^/]+/hg', normbin): |
|
2664 | elif re.search(b'/rust/target/[^/]+/hg', normbin): | |
2664 | self._pythondir = os.path.dirname(self._testdir) |
|
2665 | self._pythondir = os.path.dirname(self._testdir) | |
2665 | # Fall back to the legacy behavior. |
|
2666 | # Fall back to the legacy behavior. | |
2666 | else: |
|
2667 | else: | |
2667 | self._pythondir = self._bindir |
|
2668 | self._pythondir = self._bindir | |
2668 |
|
2669 | |||
2669 | else: |
|
2670 | else: | |
2670 | self._installdir = os.path.join(self._hgtmp, b"install") |
|
2671 | self._installdir = os.path.join(self._hgtmp, b"install") | |
2671 | self._bindir = os.path.join(self._installdir, b"bin") |
|
2672 | self._bindir = os.path.join(self._installdir, b"bin") | |
2672 | self._hgcommand = b'hg' |
|
2673 | self._hgcommand = b'hg' | |
2673 | self._tmpbindir = self._bindir |
|
2674 | self._tmpbindir = self._bindir | |
2674 | self._pythondir = os.path.join(self._installdir, b"lib", b"python") |
|
2675 | self._pythondir = os.path.join(self._installdir, b"lib", b"python") | |
2675 |
|
2676 | |||
2676 | # Force the use of hg.exe instead of relying on MSYS to recognize hg is |
|
2677 | # Force the use of hg.exe instead of relying on MSYS to recognize hg is | |
2677 | # a python script and feed it to python.exe. Legacy stdio is force |
|
2678 | # a python script and feed it to python.exe. Legacy stdio is force | |
2678 | # enabled by hg.exe, and this is a more realistic way to launch hg |
|
2679 | # enabled by hg.exe, and this is a more realistic way to launch hg | |
2679 | # anyway. |
|
2680 | # anyway. | |
2680 | if os.name == 'nt' and not self._hgcommand.endswith(b'.exe'): |
|
2681 | if os.name == 'nt' and not self._hgcommand.endswith(b'.exe'): | |
2681 | self._hgcommand += b'.exe' |
|
2682 | self._hgcommand += b'.exe' | |
2682 |
|
2683 | |||
2683 | # set CHGHG, then replace "hg" command by "chg" |
|
2684 | # set CHGHG, then replace "hg" command by "chg" | |
2684 | chgbindir = self._bindir |
|
2685 | chgbindir = self._bindir | |
2685 | if self.options.chg or self.options.with_chg: |
|
2686 | if self.options.chg or self.options.with_chg: | |
2686 | osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand) |
|
2687 | osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand) | |
2687 | else: |
|
2688 | else: | |
2688 | osenvironb.pop(b'CHGHG', None) # drop flag for hghave |
|
2689 | osenvironb.pop(b'CHGHG', None) # drop flag for hghave | |
2689 | if self.options.chg: |
|
2690 | if self.options.chg: | |
2690 | self._hgcommand = b'chg' |
|
2691 | self._hgcommand = b'chg' | |
2691 | elif self.options.with_chg: |
|
2692 | elif self.options.with_chg: | |
2692 | chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg)) |
|
2693 | chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg)) | |
2693 | self._hgcommand = os.path.basename(self.options.with_chg) |
|
2694 | self._hgcommand = os.path.basename(self.options.with_chg) | |
2694 |
|
2695 | |||
2695 | osenvironb[b"BINDIR"] = self._bindir |
|
2696 | osenvironb[b"BINDIR"] = self._bindir | |
2696 | osenvironb[b"PYTHON"] = PYTHON |
|
2697 | osenvironb[b"PYTHON"] = PYTHON | |
2697 |
|
2698 | |||
2698 | fileb = _bytespath(__file__) |
|
2699 | fileb = _bytespath(__file__) | |
2699 | runtestdir = os.path.abspath(os.path.dirname(fileb)) |
|
2700 | runtestdir = os.path.abspath(os.path.dirname(fileb)) | |
2700 | osenvironb[b'RUNTESTDIR'] = runtestdir |
|
2701 | osenvironb[b'RUNTESTDIR'] = runtestdir | |
2701 | if PYTHON3: |
|
2702 | if PYTHON3: | |
2702 | sepb = _bytespath(os.pathsep) |
|
2703 | sepb = _bytespath(os.pathsep) | |
2703 | else: |
|
2704 | else: | |
2704 | sepb = os.pathsep |
|
2705 | sepb = os.pathsep | |
2705 | path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb) |
|
2706 | path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb) | |
2706 | if os.path.islink(__file__): |
|
2707 | if os.path.islink(__file__): | |
2707 | # test helper will likely be at the end of the symlink |
|
2708 | # test helper will likely be at the end of the symlink | |
2708 | realfile = os.path.realpath(fileb) |
|
2709 | realfile = os.path.realpath(fileb) | |
2709 | realdir = os.path.abspath(os.path.dirname(realfile)) |
|
2710 | realdir = os.path.abspath(os.path.dirname(realfile)) | |
2710 | path.insert(2, realdir) |
|
2711 | path.insert(2, realdir) | |
2711 | if chgbindir != self._bindir: |
|
2712 | if chgbindir != self._bindir: | |
2712 | path.insert(1, chgbindir) |
|
2713 | path.insert(1, chgbindir) | |
2713 | if self._testdir != runtestdir: |
|
2714 | if self._testdir != runtestdir: | |
2714 | path = [self._testdir] + path |
|
2715 | path = [self._testdir] + path | |
2715 | if self._tmpbindir != self._bindir: |
|
2716 | if self._tmpbindir != self._bindir: | |
2716 | path = [self._tmpbindir] + path |
|
2717 | path = [self._tmpbindir] + path | |
2717 | osenvironb[b"PATH"] = sepb.join(path) |
|
2718 | osenvironb[b"PATH"] = sepb.join(path) | |
2718 |
|
2719 | |||
2719 | # Include TESTDIR in PYTHONPATH so that out-of-tree extensions |
|
2720 | # Include TESTDIR in PYTHONPATH so that out-of-tree extensions | |
2720 | # can run .../tests/run-tests.py test-foo where test-foo |
|
2721 | # can run .../tests/run-tests.py test-foo where test-foo | |
2721 | # adds an extension to HGRC. Also include run-test.py directory to |
|
2722 | # adds an extension to HGRC. Also include run-test.py directory to | |
2722 | # import modules like heredoctest. |
|
2723 | # import modules like heredoctest. | |
2723 | pypath = [self._pythondir, self._testdir, runtestdir] |
|
2724 | pypath = [self._pythondir, self._testdir, runtestdir] | |
2724 | # We have to augment PYTHONPATH, rather than simply replacing |
|
2725 | # We have to augment PYTHONPATH, rather than simply replacing | |
2725 | # it, in case external libraries are only available via current |
|
2726 | # it, in case external libraries are only available via current | |
2726 | # PYTHONPATH. (In particular, the Subversion bindings on OS X |
|
2727 | # PYTHONPATH. (In particular, the Subversion bindings on OS X | |
2727 | # are in /opt/subversion.) |
|
2728 | # are in /opt/subversion.) | |
2728 | oldpypath = osenvironb.get(IMPL_PATH) |
|
2729 | oldpypath = osenvironb.get(IMPL_PATH) | |
2729 | if oldpypath: |
|
2730 | if oldpypath: | |
2730 | pypath.append(oldpypath) |
|
2731 | pypath.append(oldpypath) | |
2731 | osenvironb[IMPL_PATH] = sepb.join(pypath) |
|
2732 | osenvironb[IMPL_PATH] = sepb.join(pypath) | |
2732 |
|
2733 | |||
2733 | if self.options.pure: |
|
2734 | if self.options.pure: | |
2734 | os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure" |
|
2735 | os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure" | |
2735 | os.environ["HGMODULEPOLICY"] = "py" |
|
2736 | os.environ["HGMODULEPOLICY"] = "py" | |
2736 |
|
2737 | |||
2737 | if self.options.allow_slow_tests: |
|
2738 | if self.options.allow_slow_tests: | |
2738 | os.environ["HGTEST_SLOW"] = "slow" |
|
2739 | os.environ["HGTEST_SLOW"] = "slow" | |
2739 | elif 'HGTEST_SLOW' in os.environ: |
|
2740 | elif 'HGTEST_SLOW' in os.environ: | |
2740 | del os.environ['HGTEST_SLOW'] |
|
2741 | del os.environ['HGTEST_SLOW'] | |
2741 |
|
2742 | |||
2742 | self._coveragefile = os.path.join(self._testdir, b'.coverage') |
|
2743 | self._coveragefile = os.path.join(self._testdir, b'.coverage') | |
2743 |
|
2744 | |||
2744 | if self.options.exceptions: |
|
2745 | if self.options.exceptions: | |
2745 | exceptionsdir = os.path.join(self._outputdir, b'exceptions') |
|
2746 | exceptionsdir = os.path.join(self._outputdir, b'exceptions') | |
2746 | try: |
|
2747 | try: | |
2747 | os.makedirs(exceptionsdir) |
|
2748 | os.makedirs(exceptionsdir) | |
2748 | except OSError as e: |
|
2749 | except OSError as e: | |
2749 | if e.errno != errno.EEXIST: |
|
2750 | if e.errno != errno.EEXIST: | |
2750 | raise |
|
2751 | raise | |
2751 |
|
2752 | |||
2752 | # Remove all existing exception reports. |
|
2753 | # Remove all existing exception reports. | |
2753 | for f in os.listdir(exceptionsdir): |
|
2754 | for f in os.listdir(exceptionsdir): | |
2754 | os.unlink(os.path.join(exceptionsdir, f)) |
|
2755 | os.unlink(os.path.join(exceptionsdir, f)) | |
2755 |
|
2756 | |||
2756 | osenvironb[b'HGEXCEPTIONSDIR'] = exceptionsdir |
|
2757 | osenvironb[b'HGEXCEPTIONSDIR'] = exceptionsdir | |
2757 | logexceptions = os.path.join(self._testdir, b'logexceptions.py') |
|
2758 | logexceptions = os.path.join(self._testdir, b'logexceptions.py') | |
2758 | self.options.extra_config_opt.append( |
|
2759 | self.options.extra_config_opt.append( | |
2759 | 'extensions.logexceptions=%s' % logexceptions.decode('utf-8')) |
|
2760 | 'extensions.logexceptions=%s' % logexceptions.decode('utf-8')) | |
2760 |
|
2761 | |||
2761 | vlog("# Using TESTDIR", self._testdir) |
|
2762 | vlog("# Using TESTDIR", self._testdir) | |
2762 | vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR']) |
|
2763 | vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR']) | |
2763 | vlog("# Using HGTMP", self._hgtmp) |
|
2764 | vlog("# Using HGTMP", self._hgtmp) | |
2764 | vlog("# Using PATH", os.environ["PATH"]) |
|
2765 | vlog("# Using PATH", os.environ["PATH"]) | |
2765 | vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH]) |
|
2766 | vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH]) | |
2766 | vlog("# Writing to directory", self._outputdir) |
|
2767 | vlog("# Writing to directory", self._outputdir) | |
2767 |
|
2768 | |||
2768 | try: |
|
2769 | try: | |
2769 | return self._runtests(testdescs) or 0 |
|
2770 | return self._runtests(testdescs) or 0 | |
2770 | finally: |
|
2771 | finally: | |
2771 | time.sleep(.1) |
|
2772 | time.sleep(.1) | |
2772 | self._cleanup() |
|
2773 | self._cleanup() | |
2773 |
|
2774 | |||
2774 | def findtests(self, args): |
|
2775 | def findtests(self, args): | |
2775 | """Finds possible test files from arguments. |
|
2776 | """Finds possible test files from arguments. | |
2776 |
|
2777 | |||
2777 | If you wish to inject custom tests into the test harness, this would |
|
2778 | If you wish to inject custom tests into the test harness, this would | |
2778 | be a good function to monkeypatch or override in a derived class. |
|
2779 | be a good function to monkeypatch or override in a derived class. | |
2779 | """ |
|
2780 | """ | |
2780 | if not args: |
|
2781 | if not args: | |
2781 | if self.options.changed: |
|
2782 | if self.options.changed: | |
2782 | proc = Popen4(b'hg st --rev "%s" -man0 .' % |
|
2783 | proc = Popen4(b'hg st --rev "%s" -man0 .' % | |
2783 | _bytespath(self.options.changed), None, 0) |
|
2784 | _bytespath(self.options.changed), None, 0) | |
2784 | stdout, stderr = proc.communicate() |
|
2785 | stdout, stderr = proc.communicate() | |
2785 | args = stdout.strip(b'\0').split(b'\0') |
|
2786 | args = stdout.strip(b'\0').split(b'\0') | |
2786 | else: |
|
2787 | else: | |
2787 | args = os.listdir(b'.') |
|
2788 | args = os.listdir(b'.') | |
2788 |
|
2789 | |||
2789 | expanded_args = [] |
|
2790 | expanded_args = [] | |
2790 | for arg in args: |
|
2791 | for arg in args: | |
2791 | if os.path.isdir(arg): |
|
2792 | if os.path.isdir(arg): | |
2792 | if not arg.endswith(b'/'): |
|
2793 | if not arg.endswith(b'/'): | |
2793 | arg += b'/' |
|
2794 | arg += b'/' | |
2794 | expanded_args.extend([arg + a for a in os.listdir(arg)]) |
|
2795 | expanded_args.extend([arg + a for a in os.listdir(arg)]) | |
2795 | else: |
|
2796 | else: | |
2796 | expanded_args.append(arg) |
|
2797 | expanded_args.append(arg) | |
2797 | args = expanded_args |
|
2798 | args = expanded_args | |
2798 |
|
2799 | |||
2799 | testcasepattern = re.compile( |
|
2800 | testcasepattern = re.compile( | |
2800 | br'([\w-]+\.t|py)(?:#([a-zA-Z0-9_\-\.#]+))') |
|
2801 | br'([\w-]+\.t|py)(?:#([a-zA-Z0-9_\-\.#]+))') | |
2801 | tests = [] |
|
2802 | tests = [] | |
2802 | for t in args: |
|
2803 | for t in args: | |
2803 | case = [] |
|
2804 | case = [] | |
2804 |
|
2805 | |||
2805 | if not (os.path.basename(t).startswith(b'test-') |
|
2806 | if not (os.path.basename(t).startswith(b'test-') | |
2806 | and (t.endswith(b'.py') or t.endswith(b'.t'))): |
|
2807 | and (t.endswith(b'.py') or t.endswith(b'.t'))): | |
2807 |
|
2808 | |||
2808 | m = testcasepattern.match(os.path.basename(t)) |
|
2809 | m = testcasepattern.match(os.path.basename(t)) | |
2809 | if m is not None: |
|
2810 | if m is not None: | |
2810 | t_basename, casestr = m.groups() |
|
2811 | t_basename, casestr = m.groups() | |
2811 | t = os.path.join(os.path.dirname(t), t_basename) |
|
2812 | t = os.path.join(os.path.dirname(t), t_basename) | |
2812 | if casestr: |
|
2813 | if casestr: | |
2813 | case = casestr.split(b'#') |
|
2814 | case = casestr.split(b'#') | |
2814 | else: |
|
2815 | else: | |
2815 | continue |
|
2816 | continue | |
2816 |
|
2817 | |||
2817 | if t.endswith(b'.t'): |
|
2818 | if t.endswith(b'.t'): | |
2818 | # .t file may contain multiple test cases |
|
2819 | # .t file may contain multiple test cases | |
2819 | casedimensions = parsettestcases(t) |
|
2820 | casedimensions = parsettestcases(t) | |
2820 | if casedimensions: |
|
2821 | if casedimensions: | |
2821 | cases = [] |
|
2822 | cases = [] | |
2822 | def addcases(case, casedimensions): |
|
2823 | def addcases(case, casedimensions): | |
2823 | if not casedimensions: |
|
2824 | if not casedimensions: | |
2824 | cases.append(case) |
|
2825 | cases.append(case) | |
2825 | else: |
|
2826 | else: | |
2826 | for c in casedimensions[0]: |
|
2827 | for c in casedimensions[0]: | |
2827 | addcases(case + [c], casedimensions[1:]) |
|
2828 | addcases(case + [c], casedimensions[1:]) | |
2828 | addcases([], casedimensions) |
|
2829 | addcases([], casedimensions) | |
2829 | if case and case in cases: |
|
2830 | if case and case in cases: | |
2830 | cases = [case] |
|
2831 | cases = [case] | |
2831 | elif case: |
|
2832 | elif case: | |
2832 | # Ignore invalid cases |
|
2833 | # Ignore invalid cases | |
2833 | cases = [] |
|
2834 | cases = [] | |
2834 | else: |
|
2835 | else: | |
2835 | pass |
|
2836 | pass | |
2836 | tests += [{'path': t, 'case': c} for c in sorted(cases)] |
|
2837 | tests += [{'path': t, 'case': c} for c in sorted(cases)] | |
2837 | else: |
|
2838 | else: | |
2838 | tests.append({'path': t}) |
|
2839 | tests.append({'path': t}) | |
2839 | else: |
|
2840 | else: | |
2840 | tests.append({'path': t}) |
|
2841 | tests.append({'path': t}) | |
2841 | return tests |
|
2842 | return tests | |
2842 |
|
2843 | |||
2843 | def _runtests(self, testdescs): |
|
2844 | def _runtests(self, testdescs): | |
2844 | def _reloadtest(test, i): |
|
2845 | def _reloadtest(test, i): | |
2845 | # convert a test back to its description dict |
|
2846 | # convert a test back to its description dict | |
2846 | desc = {'path': test.path} |
|
2847 | desc = {'path': test.path} | |
2847 | case = getattr(test, '_case', []) |
|
2848 | case = getattr(test, '_case', []) | |
2848 | if case: |
|
2849 | if case: | |
2849 | desc['case'] = case |
|
2850 | desc['case'] = case | |
2850 | return self._gettest(desc, i) |
|
2851 | return self._gettest(desc, i) | |
2851 |
|
2852 | |||
2852 | try: |
|
2853 | try: | |
2853 | if self.options.restart: |
|
2854 | if self.options.restart: | |
2854 | orig = list(testdescs) |
|
2855 | orig = list(testdescs) | |
2855 | while testdescs: |
|
2856 | while testdescs: | |
2856 | desc = testdescs[0] |
|
2857 | desc = testdescs[0] | |
2857 | # desc['path'] is a relative path |
|
2858 | # desc['path'] is a relative path | |
2858 | if 'case' in desc: |
|
2859 | if 'case' in desc: | |
2859 | casestr = b'#'.join(desc['case']) |
|
2860 | casestr = b'#'.join(desc['case']) | |
2860 | errpath = b'%s#%s.err' % (desc['path'], casestr) |
|
2861 | errpath = b'%s#%s.err' % (desc['path'], casestr) | |
2861 | else: |
|
2862 | else: | |
2862 | errpath = b'%s.err' % desc['path'] |
|
2863 | errpath = b'%s.err' % desc['path'] | |
2863 | errpath = os.path.join(self._outputdir, errpath) |
|
2864 | errpath = os.path.join(self._outputdir, errpath) | |
2864 | if os.path.exists(errpath): |
|
2865 | if os.path.exists(errpath): | |
2865 | break |
|
2866 | break | |
2866 | testdescs.pop(0) |
|
2867 | testdescs.pop(0) | |
2867 | if not testdescs: |
|
2868 | if not testdescs: | |
2868 | print("running all tests") |
|
2869 | print("running all tests") | |
2869 | testdescs = orig |
|
2870 | testdescs = orig | |
2870 |
|
2871 | |||
2871 | tests = [self._gettest(d, i) for i, d in enumerate(testdescs)] |
|
2872 | tests = [self._gettest(d, i) for i, d in enumerate(testdescs)] | |
2872 | num_tests = len(tests) * self.options.runs_per_test |
|
2873 | num_tests = len(tests) * self.options.runs_per_test | |
2873 |
|
2874 | |||
2874 | jobs = min(num_tests, self.options.jobs) |
|
2875 | jobs = min(num_tests, self.options.jobs) | |
2875 |
|
2876 | |||
2876 | failed = False |
|
2877 | failed = False | |
2877 | kws = self.options.keywords |
|
2878 | kws = self.options.keywords | |
2878 | if kws is not None and PYTHON3: |
|
2879 | if kws is not None and PYTHON3: | |
2879 | kws = kws.encode('utf-8') |
|
2880 | kws = kws.encode('utf-8') | |
2880 |
|
2881 | |||
2881 | suite = TestSuite(self._testdir, |
|
2882 | suite = TestSuite(self._testdir, | |
2882 | jobs=jobs, |
|
2883 | jobs=jobs, | |
2883 | whitelist=self.options.whitelisted, |
|
2884 | whitelist=self.options.whitelisted, | |
2884 | blacklist=self.options.blacklist, |
|
2885 | blacklist=self.options.blacklist, | |
2885 | retest=self.options.retest, |
|
2886 | retest=self.options.retest, | |
2886 | keywords=kws, |
|
2887 | keywords=kws, | |
2887 | loop=self.options.loop, |
|
2888 | loop=self.options.loop, | |
2888 | runs_per_test=self.options.runs_per_test, |
|
2889 | runs_per_test=self.options.runs_per_test, | |
2889 | showchannels=self.options.showchannels, |
|
2890 | showchannels=self.options.showchannels, | |
2890 | tests=tests, loadtest=_reloadtest) |
|
2891 | tests=tests, loadtest=_reloadtest) | |
2891 | verbosity = 1 |
|
2892 | verbosity = 1 | |
2892 | if self.options.list_tests: |
|
2893 | if self.options.list_tests: | |
2893 | verbosity = 0 |
|
2894 | verbosity = 0 | |
2894 | elif self.options.verbose: |
|
2895 | elif self.options.verbose: | |
2895 | verbosity = 2 |
|
2896 | verbosity = 2 | |
2896 | runner = TextTestRunner(self, verbosity=verbosity) |
|
2897 | runner = TextTestRunner(self, verbosity=verbosity) | |
2897 |
|
2898 | |||
2898 | if self.options.list_tests: |
|
2899 | if self.options.list_tests: | |
2899 | result = runner.listtests(suite) |
|
2900 | result = runner.listtests(suite) | |
2900 | else: |
|
2901 | else: | |
2901 | if self._installdir: |
|
2902 | if self._installdir: | |
2902 | self._installhg() |
|
2903 | self._installhg() | |
2903 | self._checkhglib("Testing") |
|
2904 | self._checkhglib("Testing") | |
2904 | else: |
|
2905 | else: | |
2905 | self._usecorrectpython() |
|
2906 | self._usecorrectpython() | |
2906 | if self.options.chg: |
|
2907 | if self.options.chg: | |
2907 | assert self._installdir |
|
2908 | assert self._installdir | |
2908 | self._installchg() |
|
2909 | self._installchg() | |
2909 |
|
2910 | |||
2910 | log('running %d tests using %d parallel processes' % ( |
|
2911 | log('running %d tests using %d parallel processes' % ( | |
2911 | num_tests, jobs)) |
|
2912 | num_tests, jobs)) | |
2912 |
|
2913 | |||
2913 | result = runner.run(suite) |
|
2914 | result = runner.run(suite) | |
2914 |
|
2915 | |||
2915 | if result.failures: |
|
2916 | if result.failures: | |
2916 | failed = True |
|
2917 | failed = True | |
2917 |
|
2918 | |||
2918 | result.onEnd() |
|
2919 | result.onEnd() | |
2919 |
|
2920 | |||
2920 | if self.options.anycoverage: |
|
2921 | if self.options.anycoverage: | |
2921 | self._outputcoverage() |
|
2922 | self._outputcoverage() | |
2922 | except KeyboardInterrupt: |
|
2923 | except KeyboardInterrupt: | |
2923 | failed = True |
|
2924 | failed = True | |
2924 | print("\ninterrupted!") |
|
2925 | print("\ninterrupted!") | |
2925 |
|
2926 | |||
2926 | if failed: |
|
2927 | if failed: | |
2927 | return 1 |
|
2928 | return 1 | |
2928 |
|
2929 | |||
2929 | def _getport(self, count): |
|
2930 | def _getport(self, count): | |
2930 | port = self._ports.get(count) # do we have a cached entry? |
|
2931 | port = self._ports.get(count) # do we have a cached entry? | |
2931 | if port is None: |
|
2932 | if port is None: | |
2932 | portneeded = 3 |
|
2933 | portneeded = 3 | |
2933 | # above 100 tries we just give up and let test reports failure |
|
2934 | # above 100 tries we just give up and let test reports failure | |
2934 | for tries in xrange(100): |
|
2935 | for tries in xrange(100): | |
2935 | allfree = True |
|
2936 | allfree = True | |
2936 | port = self.options.port + self._portoffset |
|
2937 | port = self.options.port + self._portoffset | |
2937 | for idx in xrange(portneeded): |
|
2938 | for idx in xrange(portneeded): | |
2938 | if not checkportisavailable(port + idx): |
|
2939 | if not checkportisavailable(port + idx): | |
2939 | allfree = False |
|
2940 | allfree = False | |
2940 | break |
|
2941 | break | |
2941 | self._portoffset += portneeded |
|
2942 | self._portoffset += portneeded | |
2942 | if allfree: |
|
2943 | if allfree: | |
2943 | break |
|
2944 | break | |
2944 | self._ports[count] = port |
|
2945 | self._ports[count] = port | |
2945 | return port |
|
2946 | return port | |
2946 |
|
2947 | |||
2947 | def _gettest(self, testdesc, count): |
|
2948 | def _gettest(self, testdesc, count): | |
2948 | """Obtain a Test by looking at its filename. |
|
2949 | """Obtain a Test by looking at its filename. | |
2949 |
|
2950 | |||
2950 | Returns a Test instance. The Test may not be runnable if it doesn't |
|
2951 | Returns a Test instance. The Test may not be runnable if it doesn't | |
2951 | map to a known type. |
|
2952 | map to a known type. | |
2952 | """ |
|
2953 | """ | |
2953 | path = testdesc['path'] |
|
2954 | path = testdesc['path'] | |
2954 | lctest = path.lower() |
|
2955 | lctest = path.lower() | |
2955 | testcls = Test |
|
2956 | testcls = Test | |
2956 |
|
2957 | |||
2957 | for ext, cls in self.TESTTYPES: |
|
2958 | for ext, cls in self.TESTTYPES: | |
2958 | if lctest.endswith(ext): |
|
2959 | if lctest.endswith(ext): | |
2959 | testcls = cls |
|
2960 | testcls = cls | |
2960 | break |
|
2961 | break | |
2961 |
|
2962 | |||
2962 | refpath = os.path.join(getcwdb(), path) |
|
2963 | refpath = os.path.join(getcwdb(), path) | |
2963 | tmpdir = os.path.join(self._hgtmp, b'child%d' % count) |
|
2964 | tmpdir = os.path.join(self._hgtmp, b'child%d' % count) | |
2964 |
|
2965 | |||
2965 | # extra keyword parameters. 'case' is used by .t tests |
|
2966 | # extra keyword parameters. 'case' is used by .t tests | |
2966 | kwds = dict((k, testdesc[k]) for k in ['case'] if k in testdesc) |
|
2967 | kwds = dict((k, testdesc[k]) for k in ['case'] if k in testdesc) | |
2967 |
|
2968 | |||
2968 | t = testcls(refpath, self._outputdir, tmpdir, |
|
2969 | t = testcls(refpath, self._outputdir, tmpdir, | |
2969 | keeptmpdir=self.options.keep_tmpdir, |
|
2970 | keeptmpdir=self.options.keep_tmpdir, | |
2970 | debug=self.options.debug, |
|
2971 | debug=self.options.debug, | |
2971 | first=self.options.first, |
|
2972 | first=self.options.first, | |
2972 | timeout=self.options.timeout, |
|
2973 | timeout=self.options.timeout, | |
2973 | startport=self._getport(count), |
|
2974 | startport=self._getport(count), | |
2974 | extraconfigopts=self.options.extra_config_opt, |
|
2975 | extraconfigopts=self.options.extra_config_opt, | |
2975 | py3warnings=self.options.py3_warnings, |
|
2976 | py3warnings=self.options.py3_warnings, | |
2976 | shell=self.options.shell, |
|
2977 | shell=self.options.shell, | |
2977 | hgcommand=self._hgcommand, |
|
2978 | hgcommand=self._hgcommand, | |
2978 | usechg=bool(self.options.with_chg or self.options.chg), |
|
2979 | usechg=bool(self.options.with_chg or self.options.chg), | |
2979 | useipv6=useipv6, **kwds) |
|
2980 | useipv6=useipv6, **kwds) | |
2980 | t.should_reload = True |
|
2981 | t.should_reload = True | |
2981 | return t |
|
2982 | return t | |
2982 |
|
2983 | |||
2983 | def _cleanup(self): |
|
2984 | def _cleanup(self): | |
2984 | """Clean up state from this test invocation.""" |
|
2985 | """Clean up state from this test invocation.""" | |
2985 | if self.options.keep_tmpdir: |
|
2986 | if self.options.keep_tmpdir: | |
2986 | return |
|
2987 | return | |
2987 |
|
2988 | |||
2988 | vlog("# Cleaning up HGTMP", self._hgtmp) |
|
2989 | vlog("# Cleaning up HGTMP", self._hgtmp) | |
2989 | shutil.rmtree(self._hgtmp, True) |
|
2990 | shutil.rmtree(self._hgtmp, True) | |
2990 | for f in self._createdfiles: |
|
2991 | for f in self._createdfiles: | |
2991 | try: |
|
2992 | try: | |
2992 | os.remove(f) |
|
2993 | os.remove(f) | |
2993 | except OSError: |
|
2994 | except OSError: | |
2994 | pass |
|
2995 | pass | |
2995 |
|
2996 | |||
2996 | def _usecorrectpython(self): |
|
2997 | def _usecorrectpython(self): | |
2997 | """Configure the environment to use the appropriate Python in tests.""" |
|
2998 | """Configure the environment to use the appropriate Python in tests.""" | |
2998 | # Tests must use the same interpreter as us or bad things will happen. |
|
2999 | # Tests must use the same interpreter as us or bad things will happen. | |
2999 | pyexename = sys.platform == 'win32' and b'python.exe' or b'python' |
|
3000 | pyexename = sys.platform == 'win32' and b'python.exe' or b'python' | |
3000 |
|
3001 | |||
3001 | # os.symlink() is a thing with py3 on Windows, but it requires |
|
3002 | # os.symlink() is a thing with py3 on Windows, but it requires | |
3002 | # Administrator rights. |
|
3003 | # Administrator rights. | |
3003 | if getattr(os, 'symlink', None) and os.name != 'nt': |
|
3004 | if getattr(os, 'symlink', None) and os.name != 'nt': | |
3004 | vlog("# Making python executable in test path a symlink to '%s'" % |
|
3005 | vlog("# Making python executable in test path a symlink to '%s'" % | |
3005 | sys.executable) |
|
3006 | sys.executable) | |
3006 | mypython = os.path.join(self._tmpbindir, pyexename) |
|
3007 | mypython = os.path.join(self._tmpbindir, pyexename) | |
3007 | try: |
|
3008 | try: | |
3008 | if os.readlink(mypython) == sys.executable: |
|
3009 | if os.readlink(mypython) == sys.executable: | |
3009 | return |
|
3010 | return | |
3010 | os.unlink(mypython) |
|
3011 | os.unlink(mypython) | |
3011 | except OSError as err: |
|
3012 | except OSError as err: | |
3012 | if err.errno != errno.ENOENT: |
|
3013 | if err.errno != errno.ENOENT: | |
3013 | raise |
|
3014 | raise | |
3014 | if self._findprogram(pyexename) != sys.executable: |
|
3015 | if self._findprogram(pyexename) != sys.executable: | |
3015 | try: |
|
3016 | try: | |
3016 | os.symlink(sys.executable, mypython) |
|
3017 | os.symlink(sys.executable, mypython) | |
3017 | self._createdfiles.append(mypython) |
|
3018 | self._createdfiles.append(mypython) | |
3018 | except OSError as err: |
|
3019 | except OSError as err: | |
3019 | # child processes may race, which is harmless |
|
3020 | # child processes may race, which is harmless | |
3020 | if err.errno != errno.EEXIST: |
|
3021 | if err.errno != errno.EEXIST: | |
3021 | raise |
|
3022 | raise | |
3022 | else: |
|
3023 | else: | |
3023 | exedir, exename = os.path.split(sys.executable) |
|
3024 | exedir, exename = os.path.split(sys.executable) | |
3024 | vlog("# Modifying search path to find %s as %s in '%s'" % |
|
3025 | vlog("# Modifying search path to find %s as %s in '%s'" % | |
3025 | (exename, pyexename, exedir)) |
|
3026 | (exename, pyexename, exedir)) | |
3026 | path = os.environ['PATH'].split(os.pathsep) |
|
3027 | path = os.environ['PATH'].split(os.pathsep) | |
3027 | while exedir in path: |
|
3028 | while exedir in path: | |
3028 | path.remove(exedir) |
|
3029 | path.remove(exedir) | |
3029 | os.environ['PATH'] = os.pathsep.join([exedir] + path) |
|
3030 | os.environ['PATH'] = os.pathsep.join([exedir] + path) | |
3030 | if not self._findprogram(pyexename): |
|
3031 | if not self._findprogram(pyexename): | |
3031 | print("WARNING: Cannot find %s in search path" % pyexename) |
|
3032 | print("WARNING: Cannot find %s in search path" % pyexename) | |
3032 |
|
3033 | |||
3033 | def _installhg(self): |
|
3034 | def _installhg(self): | |
3034 | """Install hg into the test environment. |
|
3035 | """Install hg into the test environment. | |
3035 |
|
3036 | |||
3036 | This will also configure hg with the appropriate testing settings. |
|
3037 | This will also configure hg with the appropriate testing settings. | |
3037 | """ |
|
3038 | """ | |
3038 | vlog("# Performing temporary installation of HG") |
|
3039 | vlog("# Performing temporary installation of HG") | |
3039 | installerrs = os.path.join(self._hgtmp, b"install.err") |
|
3040 | installerrs = os.path.join(self._hgtmp, b"install.err") | |
3040 | compiler = '' |
|
3041 | compiler = '' | |
3041 | if self.options.compiler: |
|
3042 | if self.options.compiler: | |
3042 | compiler = '--compiler ' + self.options.compiler |
|
3043 | compiler = '--compiler ' + self.options.compiler | |
3043 | if self.options.pure: |
|
3044 | if self.options.pure: | |
3044 | pure = b"--pure" |
|
3045 | pure = b"--pure" | |
3045 | else: |
|
3046 | else: | |
3046 | pure = b"" |
|
3047 | pure = b"" | |
3047 |
|
3048 | |||
3048 | # Run installer in hg root |
|
3049 | # Run installer in hg root | |
3049 | script = os.path.realpath(sys.argv[0]) |
|
3050 | script = os.path.realpath(sys.argv[0]) | |
3050 | exe = sys.executable |
|
3051 | exe = sys.executable | |
3051 | if PYTHON3: |
|
3052 | if PYTHON3: | |
3052 | compiler = _bytespath(compiler) |
|
3053 | compiler = _bytespath(compiler) | |
3053 | script = _bytespath(script) |
|
3054 | script = _bytespath(script) | |
3054 | exe = _bytespath(exe) |
|
3055 | exe = _bytespath(exe) | |
3055 | hgroot = os.path.dirname(os.path.dirname(script)) |
|
3056 | hgroot = os.path.dirname(os.path.dirname(script)) | |
3056 | self._hgroot = hgroot |
|
3057 | self._hgroot = hgroot | |
3057 | os.chdir(hgroot) |
|
3058 | os.chdir(hgroot) | |
3058 | nohome = b'--home=""' |
|
3059 | nohome = b'--home=""' | |
3059 | if os.name == 'nt': |
|
3060 | if os.name == 'nt': | |
3060 | # The --home="" trick works only on OS where os.sep == '/' |
|
3061 | # The --home="" trick works only on OS where os.sep == '/' | |
3061 | # because of a distutils convert_path() fast-path. Avoid it at |
|
3062 | # because of a distutils convert_path() fast-path. Avoid it at | |
3062 | # least on Windows for now, deal with .pydistutils.cfg bugs |
|
3063 | # least on Windows for now, deal with .pydistutils.cfg bugs | |
3063 | # when they happen. |
|
3064 | # when they happen. | |
3064 | nohome = b'' |
|
3065 | nohome = b'' | |
3065 | cmd = (b'"%(exe)s" setup.py %(pure)s clean --all' |
|
3066 | cmd = (b'"%(exe)s" setup.py %(pure)s clean --all' | |
3066 | b' build %(compiler)s --build-base="%(base)s"' |
|
3067 | b' build %(compiler)s --build-base="%(base)s"' | |
3067 | b' install --force --prefix="%(prefix)s"' |
|
3068 | b' install --force --prefix="%(prefix)s"' | |
3068 | b' --install-lib="%(libdir)s"' |
|
3069 | b' --install-lib="%(libdir)s"' | |
3069 | b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1' |
|
3070 | b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1' | |
3070 | % {b'exe': exe, b'pure': pure, |
|
3071 | % {b'exe': exe, b'pure': pure, | |
3071 | b'compiler': compiler, |
|
3072 | b'compiler': compiler, | |
3072 | b'base': os.path.join(self._hgtmp, b"build"), |
|
3073 | b'base': os.path.join(self._hgtmp, b"build"), | |
3073 | b'prefix': self._installdir, b'libdir': self._pythondir, |
|
3074 | b'prefix': self._installdir, b'libdir': self._pythondir, | |
3074 | b'bindir': self._bindir, |
|
3075 | b'bindir': self._bindir, | |
3075 | b'nohome': nohome, b'logfile': installerrs}) |
|
3076 | b'nohome': nohome, b'logfile': installerrs}) | |
3076 |
|
3077 | |||
3077 | # setuptools requires install directories to exist. |
|
3078 | # setuptools requires install directories to exist. | |
3078 | def makedirs(p): |
|
3079 | def makedirs(p): | |
3079 | try: |
|
3080 | try: | |
3080 | os.makedirs(p) |
|
3081 | os.makedirs(p) | |
3081 | except OSError as e: |
|
3082 | except OSError as e: | |
3082 | if e.errno != errno.EEXIST: |
|
3083 | if e.errno != errno.EEXIST: | |
3083 | raise |
|
3084 | raise | |
3084 | makedirs(self._pythondir) |
|
3085 | makedirs(self._pythondir) | |
3085 | makedirs(self._bindir) |
|
3086 | makedirs(self._bindir) | |
3086 |
|
3087 | |||
3087 | vlog("# Running", cmd) |
|
3088 | vlog("# Running", cmd) | |
3088 | if subprocess.call(_strpath(cmd), shell=True) == 0: |
|
3089 | if subprocess.call(_strpath(cmd), shell=True) == 0: | |
3089 | if not self.options.verbose: |
|
3090 | if not self.options.verbose: | |
3090 | try: |
|
3091 | try: | |
3091 | os.remove(installerrs) |
|
3092 | os.remove(installerrs) | |
3092 | except OSError as e: |
|
3093 | except OSError as e: | |
3093 | if e.errno != errno.ENOENT: |
|
3094 | if e.errno != errno.ENOENT: | |
3094 | raise |
|
3095 | raise | |
3095 | else: |
|
3096 | else: | |
3096 | with open(installerrs, 'rb') as f: |
|
3097 | with open(installerrs, 'rb') as f: | |
3097 | for line in f: |
|
3098 | for line in f: | |
3098 | if PYTHON3: |
|
3099 | if PYTHON3: | |
3099 | sys.stdout.buffer.write(line) |
|
3100 | sys.stdout.buffer.write(line) | |
3100 | else: |
|
3101 | else: | |
3101 | sys.stdout.write(line) |
|
3102 | sys.stdout.write(line) | |
3102 | sys.exit(1) |
|
3103 | sys.exit(1) | |
3103 | os.chdir(self._testdir) |
|
3104 | os.chdir(self._testdir) | |
3104 |
|
3105 | |||
3105 | self._usecorrectpython() |
|
3106 | self._usecorrectpython() | |
3106 |
|
3107 | |||
3107 | if self.options.py3_warnings and not self.options.anycoverage: |
|
3108 | if self.options.py3_warnings and not self.options.anycoverage: | |
3108 | vlog("# Updating hg command to enable Py3k Warnings switch") |
|
3109 | vlog("# Updating hg command to enable Py3k Warnings switch") | |
3109 | with open(os.path.join(self._bindir, 'hg'), 'rb') as f: |
|
3110 | with open(os.path.join(self._bindir, 'hg'), 'rb') as f: | |
3110 | lines = [line.rstrip() for line in f] |
|
3111 | lines = [line.rstrip() for line in f] | |
3111 | lines[0] += ' -3' |
|
3112 | lines[0] += ' -3' | |
3112 | with open(os.path.join(self._bindir, 'hg'), 'wb') as f: |
|
3113 | with open(os.path.join(self._bindir, 'hg'), 'wb') as f: | |
3113 | for line in lines: |
|
3114 | for line in lines: | |
3114 | f.write(line + '\n') |
|
3115 | f.write(line + '\n') | |
3115 |
|
3116 | |||
3116 | hgbat = os.path.join(self._bindir, b'hg.bat') |
|
3117 | hgbat = os.path.join(self._bindir, b'hg.bat') | |
3117 | if os.path.isfile(hgbat): |
|
3118 | if os.path.isfile(hgbat): | |
3118 | # hg.bat expects to be put in bin/scripts while run-tests.py |
|
3119 | # hg.bat expects to be put in bin/scripts while run-tests.py | |
3119 | # installation layout put it in bin/ directly. Fix it |
|
3120 | # installation layout put it in bin/ directly. Fix it | |
3120 | with open(hgbat, 'rb') as f: |
|
3121 | with open(hgbat, 'rb') as f: | |
3121 | data = f.read() |
|
3122 | data = f.read() | |
3122 | if br'"%~dp0..\python" "%~dp0hg" %*' in data: |
|
3123 | if br'"%~dp0..\python" "%~dp0hg" %*' in data: | |
3123 | data = data.replace(br'"%~dp0..\python" "%~dp0hg" %*', |
|
3124 | data = data.replace(br'"%~dp0..\python" "%~dp0hg" %*', | |
3124 | b'"%~dp0python" "%~dp0hg" %*') |
|
3125 | b'"%~dp0python" "%~dp0hg" %*') | |
3125 | with open(hgbat, 'wb') as f: |
|
3126 | with open(hgbat, 'wb') as f: | |
3126 | f.write(data) |
|
3127 | f.write(data) | |
3127 | else: |
|
3128 | else: | |
3128 | print('WARNING: cannot fix hg.bat reference to python.exe') |
|
3129 | print('WARNING: cannot fix hg.bat reference to python.exe') | |
3129 |
|
3130 | |||
3130 | if self.options.anycoverage: |
|
3131 | if self.options.anycoverage: | |
3131 | custom = os.path.join(self._testdir, 'sitecustomize.py') |
|
3132 | custom = os.path.join(self._testdir, 'sitecustomize.py') | |
3132 | target = os.path.join(self._pythondir, 'sitecustomize.py') |
|
3133 | target = os.path.join(self._pythondir, 'sitecustomize.py') | |
3133 | vlog('# Installing coverage trigger to %s' % target) |
|
3134 | vlog('# Installing coverage trigger to %s' % target) | |
3134 | shutil.copyfile(custom, target) |
|
3135 | shutil.copyfile(custom, target) | |
3135 | rc = os.path.join(self._testdir, '.coveragerc') |
|
3136 | rc = os.path.join(self._testdir, '.coveragerc') | |
3136 | vlog('# Installing coverage rc to %s' % rc) |
|
3137 | vlog('# Installing coverage rc to %s' % rc) | |
3137 | os.environ['COVERAGE_PROCESS_START'] = rc |
|
3138 | os.environ['COVERAGE_PROCESS_START'] = rc | |
3138 | covdir = os.path.join(self._installdir, '..', 'coverage') |
|
3139 | covdir = os.path.join(self._installdir, '..', 'coverage') | |
3139 | try: |
|
3140 | try: | |
3140 | os.mkdir(covdir) |
|
3141 | os.mkdir(covdir) | |
3141 | except OSError as e: |
|
3142 | except OSError as e: | |
3142 | if e.errno != errno.EEXIST: |
|
3143 | if e.errno != errno.EEXIST: | |
3143 | raise |
|
3144 | raise | |
3144 |
|
3145 | |||
3145 | os.environ['COVERAGE_DIR'] = covdir |
|
3146 | os.environ['COVERAGE_DIR'] = covdir | |
3146 |
|
3147 | |||
3147 | def _checkhglib(self, verb): |
|
3148 | def _checkhglib(self, verb): | |
3148 | """Ensure that the 'mercurial' package imported by python is |
|
3149 | """Ensure that the 'mercurial' package imported by python is | |
3149 | the one we expect it to be. If not, print a warning to stderr.""" |
|
3150 | the one we expect it to be. If not, print a warning to stderr.""" | |
3150 | if ((self._bindir == self._pythondir) and |
|
3151 | if ((self._bindir == self._pythondir) and | |
3151 | (self._bindir != self._tmpbindir)): |
|
3152 | (self._bindir != self._tmpbindir)): | |
3152 | # The pythondir has been inferred from --with-hg flag. |
|
3153 | # The pythondir has been inferred from --with-hg flag. | |
3153 | # We cannot expect anything sensible here. |
|
3154 | # We cannot expect anything sensible here. | |
3154 | return |
|
3155 | return | |
3155 | expecthg = os.path.join(self._pythondir, b'mercurial') |
|
3156 | expecthg = os.path.join(self._pythondir, b'mercurial') | |
3156 | actualhg = self._gethgpath() |
|
3157 | actualhg = self._gethgpath() | |
3157 | if os.path.abspath(actualhg) != os.path.abspath(expecthg): |
|
3158 | if os.path.abspath(actualhg) != os.path.abspath(expecthg): | |
3158 | sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n' |
|
3159 | sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n' | |
3159 | ' (expected %s)\n' |
|
3160 | ' (expected %s)\n' | |
3160 | % (verb, actualhg, expecthg)) |
|
3161 | % (verb, actualhg, expecthg)) | |
3161 | def _gethgpath(self): |
|
3162 | def _gethgpath(self): | |
3162 | """Return the path to the mercurial package that is actually found by |
|
3163 | """Return the path to the mercurial package that is actually found by | |
3163 | the current Python interpreter.""" |
|
3164 | the current Python interpreter.""" | |
3164 | if self._hgpath is not None: |
|
3165 | if self._hgpath is not None: | |
3165 | return self._hgpath |
|
3166 | return self._hgpath | |
3166 |
|
3167 | |||
3167 | cmd = b'"%s" -c "import mercurial; print (mercurial.__path__[0])"' |
|
3168 | cmd = b'"%s" -c "import mercurial; print (mercurial.__path__[0])"' | |
3168 | cmd = cmd % PYTHON |
|
3169 | cmd = cmd % PYTHON | |
3169 | if PYTHON3: |
|
3170 | if PYTHON3: | |
3170 | cmd = _strpath(cmd) |
|
3171 | cmd = _strpath(cmd) | |
3171 |
|
3172 | |||
3172 | p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True) |
|
3173 | p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True) | |
3173 | out, err = p.communicate() |
|
3174 | out, err = p.communicate() | |
3174 |
|
3175 | |||
3175 | self._hgpath = out.strip() |
|
3176 | self._hgpath = out.strip() | |
3176 |
|
3177 | |||
3177 | return self._hgpath |
|
3178 | return self._hgpath | |
3178 |
|
3179 | |||
3179 | def _installchg(self): |
|
3180 | def _installchg(self): | |
3180 | """Install chg into the test environment""" |
|
3181 | """Install chg into the test environment""" | |
3181 | vlog('# Performing temporary installation of CHG') |
|
3182 | vlog('# Performing temporary installation of CHG') | |
3182 | assert os.path.dirname(self._bindir) == self._installdir |
|
3183 | assert os.path.dirname(self._bindir) == self._installdir | |
3183 | assert self._hgroot, 'must be called after _installhg()' |
|
3184 | assert self._hgroot, 'must be called after _installhg()' | |
3184 | cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"' |
|
3185 | cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"' | |
3185 | % {b'make': 'make', # TODO: switch by option or environment? |
|
3186 | % {b'make': 'make', # TODO: switch by option or environment? | |
3186 | b'prefix': self._installdir}) |
|
3187 | b'prefix': self._installdir}) | |
3187 | cwd = os.path.join(self._hgroot, b'contrib', b'chg') |
|
3188 | cwd = os.path.join(self._hgroot, b'contrib', b'chg') | |
3188 | vlog("# Running", cmd) |
|
3189 | vlog("# Running", cmd) | |
3189 | proc = subprocess.Popen(cmd, shell=True, cwd=cwd, |
|
3190 | proc = subprocess.Popen(cmd, shell=True, cwd=cwd, | |
3190 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, |
|
3191 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, | |
3191 | stderr=subprocess.STDOUT) |
|
3192 | stderr=subprocess.STDOUT) | |
3192 | out, _err = proc.communicate() |
|
3193 | out, _err = proc.communicate() | |
3193 | if proc.returncode != 0: |
|
3194 | if proc.returncode != 0: | |
3194 | if PYTHON3: |
|
3195 | if PYTHON3: | |
3195 | sys.stdout.buffer.write(out) |
|
3196 | sys.stdout.buffer.write(out) | |
3196 | else: |
|
3197 | else: | |
3197 | sys.stdout.write(out) |
|
3198 | sys.stdout.write(out) | |
3198 | sys.exit(1) |
|
3199 | sys.exit(1) | |
3199 |
|
3200 | |||
3200 | def _outputcoverage(self): |
|
3201 | def _outputcoverage(self): | |
3201 | """Produce code coverage output.""" |
|
3202 | """Produce code coverage output.""" | |
3202 | import coverage |
|
3203 | import coverage | |
3203 | coverage = coverage.coverage |
|
3204 | coverage = coverage.coverage | |
3204 |
|
3205 | |||
3205 | vlog('# Producing coverage report') |
|
3206 | vlog('# Producing coverage report') | |
3206 | # chdir is the easiest way to get short, relative paths in the |
|
3207 | # chdir is the easiest way to get short, relative paths in the | |
3207 | # output. |
|
3208 | # output. | |
3208 | os.chdir(self._hgroot) |
|
3209 | os.chdir(self._hgroot) | |
3209 | covdir = os.path.join(self._installdir, '..', 'coverage') |
|
3210 | covdir = os.path.join(self._installdir, '..', 'coverage') | |
3210 | cov = coverage(data_file=os.path.join(covdir, 'cov')) |
|
3211 | cov = coverage(data_file=os.path.join(covdir, 'cov')) | |
3211 |
|
3212 | |||
3212 | # Map install directory paths back to source directory. |
|
3213 | # Map install directory paths back to source directory. | |
3213 | cov.config.paths['srcdir'] = ['.', self._pythondir] |
|
3214 | cov.config.paths['srcdir'] = ['.', self._pythondir] | |
3214 |
|
3215 | |||
3215 | cov.combine() |
|
3216 | cov.combine() | |
3216 |
|
3217 | |||
3217 | omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]] |
|
3218 | omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]] | |
3218 | cov.report(ignore_errors=True, omit=omit) |
|
3219 | cov.report(ignore_errors=True, omit=omit) | |
3219 |
|
3220 | |||
3220 | if self.options.htmlcov: |
|
3221 | if self.options.htmlcov: | |
3221 | htmldir = os.path.join(self._outputdir, 'htmlcov') |
|
3222 | htmldir = os.path.join(self._outputdir, 'htmlcov') | |
3222 | cov.html_report(directory=htmldir, omit=omit) |
|
3223 | cov.html_report(directory=htmldir, omit=omit) | |
3223 | if self.options.annotate: |
|
3224 | if self.options.annotate: | |
3224 | adir = os.path.join(self._outputdir, 'annotated') |
|
3225 | adir = os.path.join(self._outputdir, 'annotated') | |
3225 | if not os.path.isdir(adir): |
|
3226 | if not os.path.isdir(adir): | |
3226 | os.mkdir(adir) |
|
3227 | os.mkdir(adir) | |
3227 | cov.annotate(directory=adir, omit=omit) |
|
3228 | cov.annotate(directory=adir, omit=omit) | |
3228 |
|
3229 | |||
3229 | def _findprogram(self, program): |
|
3230 | def _findprogram(self, program): | |
3230 | """Search PATH for a executable program""" |
|
3231 | """Search PATH for a executable program""" | |
3231 | dpb = _bytespath(os.defpath) |
|
3232 | dpb = _bytespath(os.defpath) | |
3232 | sepb = _bytespath(os.pathsep) |
|
3233 | sepb = _bytespath(os.pathsep) | |
3233 | for p in osenvironb.get(b'PATH', dpb).split(sepb): |
|
3234 | for p in osenvironb.get(b'PATH', dpb).split(sepb): | |
3234 | name = os.path.join(p, program) |
|
3235 | name = os.path.join(p, program) | |
3235 | if os.name == 'nt' or os.access(name, os.X_OK): |
|
3236 | if os.name == 'nt' or os.access(name, os.X_OK): | |
3236 | return name |
|
3237 | return name | |
3237 | return None |
|
3238 | return None | |
3238 |
|
3239 | |||
3239 | def _checktools(self): |
|
3240 | def _checktools(self): | |
3240 | """Ensure tools required to run tests are present.""" |
|
3241 | """Ensure tools required to run tests are present.""" | |
3241 | for p in self.REQUIREDTOOLS: |
|
3242 | for p in self.REQUIREDTOOLS: | |
3242 | if os.name == 'nt' and not p.endswith(b'.exe'): |
|
3243 | if os.name == 'nt' and not p.endswith(b'.exe'): | |
3243 | p += b'.exe' |
|
3244 | p += b'.exe' | |
3244 | found = self._findprogram(p) |
|
3245 | found = self._findprogram(p) | |
3245 | if found: |
|
3246 | if found: | |
3246 | vlog("# Found prerequisite", p, "at", found) |
|
3247 | vlog("# Found prerequisite", p, "at", found) | |
3247 | else: |
|
3248 | else: | |
3248 | print("WARNING: Did not find prerequisite tool: %s " % |
|
3249 | print("WARNING: Did not find prerequisite tool: %s " % | |
3249 | p.decode("utf-8")) |
|
3250 | p.decode("utf-8")) | |
3250 |
|
3251 | |||
3251 | def aggregateexceptions(path): |
|
3252 | def aggregateexceptions(path): | |
3252 | exceptioncounts = collections.Counter() |
|
3253 | exceptioncounts = collections.Counter() | |
3253 | testsbyfailure = collections.defaultdict(set) |
|
3254 | testsbyfailure = collections.defaultdict(set) | |
3254 | failuresbytest = collections.defaultdict(set) |
|
3255 | failuresbytest = collections.defaultdict(set) | |
3255 |
|
3256 | |||
3256 | for f in os.listdir(path): |
|
3257 | for f in os.listdir(path): | |
3257 | with open(os.path.join(path, f), 'rb') as fh: |
|
3258 | with open(os.path.join(path, f), 'rb') as fh: | |
3258 | data = fh.read().split(b'\0') |
|
3259 | data = fh.read().split(b'\0') | |
3259 | if len(data) != 5: |
|
3260 | if len(data) != 5: | |
3260 | continue |
|
3261 | continue | |
3261 |
|
3262 | |||
3262 | exc, mainframe, hgframe, hgline, testname = data |
|
3263 | exc, mainframe, hgframe, hgline, testname = data | |
3263 | exc = exc.decode('utf-8') |
|
3264 | exc = exc.decode('utf-8') | |
3264 | mainframe = mainframe.decode('utf-8') |
|
3265 | mainframe = mainframe.decode('utf-8') | |
3265 | hgframe = hgframe.decode('utf-8') |
|
3266 | hgframe = hgframe.decode('utf-8') | |
3266 | hgline = hgline.decode('utf-8') |
|
3267 | hgline = hgline.decode('utf-8') | |
3267 | testname = testname.decode('utf-8') |
|
3268 | testname = testname.decode('utf-8') | |
3268 |
|
3269 | |||
3269 | key = (hgframe, hgline, exc) |
|
3270 | key = (hgframe, hgline, exc) | |
3270 | exceptioncounts[key] += 1 |
|
3271 | exceptioncounts[key] += 1 | |
3271 | testsbyfailure[key].add(testname) |
|
3272 | testsbyfailure[key].add(testname) | |
3272 | failuresbytest[testname].add(key) |
|
3273 | failuresbytest[testname].add(key) | |
3273 |
|
3274 | |||
3274 | # Find test having fewest failures for each failure. |
|
3275 | # Find test having fewest failures for each failure. | |
3275 | leastfailing = {} |
|
3276 | leastfailing = {} | |
3276 | for key, tests in testsbyfailure.items(): |
|
3277 | for key, tests in testsbyfailure.items(): | |
3277 | fewesttest = None |
|
3278 | fewesttest = None | |
3278 | fewestcount = 99999999 |
|
3279 | fewestcount = 99999999 | |
3279 | for test in sorted(tests): |
|
3280 | for test in sorted(tests): | |
3280 | if len(failuresbytest[test]) < fewestcount: |
|
3281 | if len(failuresbytest[test]) < fewestcount: | |
3281 | fewesttest = test |
|
3282 | fewesttest = test | |
3282 | fewestcount = len(failuresbytest[test]) |
|
3283 | fewestcount = len(failuresbytest[test]) | |
3283 |
|
3284 | |||
3284 | leastfailing[key] = (fewestcount, fewesttest) |
|
3285 | leastfailing[key] = (fewestcount, fewesttest) | |
3285 |
|
3286 | |||
3286 | # Create a combined counter so we can sort by total occurrences and |
|
3287 | # Create a combined counter so we can sort by total occurrences and | |
3287 | # impacted tests. |
|
3288 | # impacted tests. | |
3288 | combined = {} |
|
3289 | combined = {} | |
3289 | for key in exceptioncounts: |
|
3290 | for key in exceptioncounts: | |
3290 | combined[key] = (exceptioncounts[key], |
|
3291 | combined[key] = (exceptioncounts[key], | |
3291 | len(testsbyfailure[key]), |
|
3292 | len(testsbyfailure[key]), | |
3292 | leastfailing[key][0], |
|
3293 | leastfailing[key][0], | |
3293 | leastfailing[key][1]) |
|
3294 | leastfailing[key][1]) | |
3294 |
|
3295 | |||
3295 | return { |
|
3296 | return { | |
3296 | 'exceptioncounts': exceptioncounts, |
|
3297 | 'exceptioncounts': exceptioncounts, | |
3297 | 'total': sum(exceptioncounts.values()), |
|
3298 | 'total': sum(exceptioncounts.values()), | |
3298 | 'combined': combined, |
|
3299 | 'combined': combined, | |
3299 | 'leastfailing': leastfailing, |
|
3300 | 'leastfailing': leastfailing, | |
3300 | 'byfailure': testsbyfailure, |
|
3301 | 'byfailure': testsbyfailure, | |
3301 | 'bytest': failuresbytest, |
|
3302 | 'bytest': failuresbytest, | |
3302 | } |
|
3303 | } | |
3303 |
|
3304 | |||
3304 | if __name__ == '__main__': |
|
3305 | if __name__ == '__main__': | |
3305 | runner = TestRunner() |
|
3306 | runner = TestRunner() | |
3306 |
|
3307 | |||
3307 | try: |
|
3308 | try: | |
3308 | import msvcrt |
|
3309 | import msvcrt | |
3309 | msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY) |
|
3310 | msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY) | |
3310 | msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) |
|
3311 | msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) | |
3311 | msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) |
|
3312 | msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) | |
3312 | except ImportError: |
|
3313 | except ImportError: | |
3313 | pass |
|
3314 | pass | |
3314 |
|
3315 | |||
3315 | sys.exit(runner.run(sys.argv[1:])) |
|
3316 | sys.exit(runner.run(sys.argv[1:])) |
@@ -1,648 +1,649 b'' | |||||
1 | #testcases filelog compatibility changeset |
|
1 | #testcases filelog compatibility changeset | |
2 |
|
2 | |||
3 | $ cat >> $HGRCPATH << EOF |
|
3 | $ cat >> $HGRCPATH << EOF | |
4 | > [extensions] |
|
4 | > [extensions] | |
5 | > rebase= |
|
5 | > rebase= | |
6 | > [alias] |
|
6 | > [alias] | |
7 | > l = log -G -T '{rev} {desc}\n{files}\n' |
|
7 | > l = log -G -T '{rev} {desc}\n{files}\n' | |
8 | > EOF |
|
8 | > EOF | |
9 |
|
9 | |||
10 | #if compatibility |
|
10 | #if compatibility | |
11 | $ cat >> $HGRCPATH << EOF |
|
11 | $ cat >> $HGRCPATH << EOF | |
12 | > [experimental] |
|
12 | > [experimental] | |
13 | > copies.read-from = compatibility |
|
13 | > copies.read-from = compatibility | |
14 | > EOF |
|
14 | > EOF | |
15 | #endif |
|
15 | #endif | |
16 |
|
16 | |||
17 | #if changeset |
|
17 | #if changeset | |
18 | $ cat >> $HGRCPATH << EOF |
|
18 | $ cat >> $HGRCPATH << EOF | |
19 | > [experimental] |
|
19 | > [experimental] | |
20 | > copies.read-from = changeset-only |
|
20 | > copies.read-from = changeset-only | |
21 | > copies.write-to = changeset-only |
|
21 | > copies.write-to = changeset-only | |
22 | > EOF |
|
22 | > EOF | |
23 | #endif |
|
23 | #endif | |
24 |
|
24 | |||
25 | $ REPONUM=0 |
|
25 | $ REPONUM=0 | |
26 | $ newrepo() { |
|
26 | $ newrepo() { | |
27 | > cd $TESTTMP |
|
27 | > cd $TESTTMP | |
28 | > REPONUM=`expr $REPONUM + 1` |
|
28 | > REPONUM=`expr $REPONUM + 1` | |
29 | > hg init repo-$REPONUM |
|
29 | > hg init repo-$REPONUM | |
30 | > cd repo-$REPONUM |
|
30 | > cd repo-$REPONUM | |
31 | > } |
|
31 | > } | |
32 |
|
32 | |||
33 | Simple rename case |
|
33 | Simple rename case | |
34 | $ newrepo |
|
34 | $ newrepo | |
35 | $ echo x > x |
|
35 | $ echo x > x | |
36 | $ hg ci -Aqm 'add x' |
|
36 | $ hg ci -Aqm 'add x' | |
37 | $ hg mv x y |
|
37 | $ hg mv x y | |
38 | $ hg debugp1copies |
|
38 | $ hg debugp1copies | |
39 | x -> y |
|
39 | x -> y | |
40 | $ hg debugp2copies |
|
40 | $ hg debugp2copies | |
41 | $ hg ci -m 'rename x to y' |
|
41 | $ hg ci -m 'rename x to y' | |
42 | $ hg l |
|
42 | $ hg l | |
43 | @ 1 rename x to y |
|
43 | @ 1 rename x to y | |
44 | | x y |
|
44 | | x y | |
45 | o 0 add x |
|
45 | o 0 add x | |
46 | x |
|
46 | x | |
47 | $ hg debugp1copies -r 1 |
|
47 | $ hg debugp1copies -r 1 | |
48 | x -> y |
|
48 | x -> y | |
49 | $ hg debugpathcopies 0 1 |
|
49 | $ hg debugpathcopies 0 1 | |
50 | x -> y |
|
50 | x -> y | |
51 | $ hg debugpathcopies 1 0 |
|
51 | $ hg debugpathcopies 1 0 | |
52 | y -> x |
|
52 | y -> x | |
53 | Test filtering copies by path. We do filtering by destination. |
|
53 | Test filtering copies by path. We do filtering by destination. | |
54 | $ hg debugpathcopies 0 1 x |
|
54 | $ hg debugpathcopies 0 1 x | |
55 | $ hg debugpathcopies 1 0 x |
|
55 | $ hg debugpathcopies 1 0 x | |
56 | y -> x |
|
56 | y -> x | |
57 | $ hg debugpathcopies 0 1 y |
|
57 | $ hg debugpathcopies 0 1 y | |
58 | x -> y |
|
58 | x -> y | |
59 | $ hg debugpathcopies 1 0 y |
|
59 | $ hg debugpathcopies 1 0 y | |
60 |
|
60 | |||
61 | Copy a file onto another file |
|
61 | Copy a file onto another file | |
62 | $ newrepo |
|
62 | $ newrepo | |
63 | $ echo x > x |
|
63 | $ echo x > x | |
64 | $ echo y > y |
|
64 | $ echo y > y | |
65 | $ hg ci -Aqm 'add x and y' |
|
65 | $ hg ci -Aqm 'add x and y' | |
66 | $ hg cp -f x y |
|
66 | $ hg cp -f x y | |
67 | $ hg debugp1copies |
|
67 | $ hg debugp1copies | |
68 | x -> y |
|
68 | x -> y | |
69 | $ hg debugp2copies |
|
69 | $ hg debugp2copies | |
70 | $ hg ci -m 'copy x onto y' |
|
70 | $ hg ci -m 'copy x onto y' | |
71 | $ hg l |
|
71 | $ hg l | |
72 | @ 1 copy x onto y |
|
72 | @ 1 copy x onto y | |
73 | | y |
|
73 | | y | |
74 | o 0 add x and y |
|
74 | o 0 add x and y | |
75 | x y |
|
75 | x y | |
76 | $ hg debugp1copies -r 1 |
|
76 | $ hg debugp1copies -r 1 | |
77 | x -> y |
|
77 | x -> y | |
78 | Incorrectly doesn't show the rename |
|
78 | Incorrectly doesn't show the rename | |
79 | $ hg debugpathcopies 0 1 |
|
79 | $ hg debugpathcopies 0 1 | |
80 |
|
80 | |||
81 | Copy a file onto another file with same content. If metadata is stored in changeset, this does not |
|
81 | Copy a file onto another file with same content. If metadata is stored in changeset, this does not | |
82 | produce a new filelog entry. The changeset's "files" entry should still list the file. |
|
82 | produce a new filelog entry. The changeset's "files" entry should still list the file. | |
83 | $ newrepo |
|
83 | $ newrepo | |
84 | $ echo x > x |
|
84 | $ echo x > x | |
85 | $ echo x > x2 |
|
85 | $ echo x > x2 | |
86 | $ hg ci -Aqm 'add x and x2 with same content' |
|
86 | $ hg ci -Aqm 'add x and x2 with same content' | |
87 | $ hg cp -f x x2 |
|
87 | $ hg cp -f x x2 | |
88 | $ hg ci -m 'copy x onto x2' |
|
88 | $ hg ci -m 'copy x onto x2' | |
89 | $ hg l |
|
89 | $ hg l | |
90 | @ 1 copy x onto x2 |
|
90 | @ 1 copy x onto x2 | |
91 | | x2 |
|
91 | | x2 | |
92 | o 0 add x and x2 with same content |
|
92 | o 0 add x and x2 with same content | |
93 | x x2 |
|
93 | x x2 | |
94 | $ hg debugp1copies -r 1 |
|
94 | $ hg debugp1copies -r 1 | |
95 | x -> x2 |
|
95 | x -> x2 | |
96 | Incorrectly doesn't show the rename |
|
96 | Incorrectly doesn't show the rename | |
97 | $ hg debugpathcopies 0 1 |
|
97 | $ hg debugpathcopies 0 1 | |
98 |
|
98 | |||
99 | Copy a file, then delete destination, then copy again. This does not create a new filelog entry. |
|
99 | Copy a file, then delete destination, then copy again. This does not create a new filelog entry. | |
100 | $ newrepo |
|
100 | $ newrepo | |
101 | $ echo x > x |
|
101 | $ echo x > x | |
102 | $ hg ci -Aqm 'add x' |
|
102 | $ hg ci -Aqm 'add x' | |
103 | $ hg cp x y |
|
103 | $ hg cp x y | |
104 | $ hg ci -m 'copy x to y' |
|
104 | $ hg ci -m 'copy x to y' | |
105 | $ hg rm y |
|
105 | $ hg rm y | |
106 | $ hg ci -m 'remove y' |
|
106 | $ hg ci -m 'remove y' | |
107 | $ hg cp -f x y |
|
107 | $ hg cp -f x y | |
108 | $ hg ci -m 'copy x onto y (again)' |
|
108 | $ hg ci -m 'copy x onto y (again)' | |
109 | $ hg l |
|
109 | $ hg l | |
110 | @ 3 copy x onto y (again) |
|
110 | @ 3 copy x onto y (again) | |
111 | | y |
|
111 | | y | |
112 | o 2 remove y |
|
112 | o 2 remove y | |
113 | | y |
|
113 | | y | |
114 | o 1 copy x to y |
|
114 | o 1 copy x to y | |
115 | | y |
|
115 | | y | |
116 | o 0 add x |
|
116 | o 0 add x | |
117 | x |
|
117 | x | |
118 | $ hg debugp1copies -r 3 |
|
118 | $ hg debugp1copies -r 3 | |
119 | x -> y |
|
119 | x -> y | |
120 | $ hg debugpathcopies 0 3 |
|
120 | $ hg debugpathcopies 0 3 | |
121 | x -> y |
|
121 | x -> y | |
122 |
|
122 | |||
123 | Rename file in a loop: x->y->z->x |
|
123 | Rename file in a loop: x->y->z->x | |
124 | $ newrepo |
|
124 | $ newrepo | |
125 | $ echo x > x |
|
125 | $ echo x > x | |
126 | $ hg ci -Aqm 'add x' |
|
126 | $ hg ci -Aqm 'add x' | |
127 | $ hg mv x y |
|
127 | $ hg mv x y | |
128 | $ hg debugp1copies |
|
128 | $ hg debugp1copies | |
129 | x -> y |
|
129 | x -> y | |
130 | $ hg debugp2copies |
|
130 | $ hg debugp2copies | |
131 | $ hg ci -m 'rename x to y' |
|
131 | $ hg ci -m 'rename x to y' | |
132 | $ hg mv y z |
|
132 | $ hg mv y z | |
133 | $ hg ci -m 'rename y to z' |
|
133 | $ hg ci -m 'rename y to z' | |
134 | $ hg mv z x |
|
134 | $ hg mv z x | |
135 | $ hg ci -m 'rename z to x' |
|
135 | $ hg ci -m 'rename z to x' | |
136 | $ hg l |
|
136 | $ hg l | |
137 | @ 3 rename z to x |
|
137 | @ 3 rename z to x | |
138 | | x z |
|
138 | | x z | |
139 | o 2 rename y to z |
|
139 | o 2 rename y to z | |
140 | | y z |
|
140 | | y z | |
141 | o 1 rename x to y |
|
141 | o 1 rename x to y | |
142 | | x y |
|
142 | | x y | |
143 | o 0 add x |
|
143 | o 0 add x | |
144 | x |
|
144 | x | |
145 | $ hg debugpathcopies 0 3 |
|
145 | $ hg debugpathcopies 0 3 | |
146 |
|
146 | |||
147 | Copy x to y, then remove y, then add back y. With copy metadata in the changeset, this could easily |
|
147 | Copy x to y, then remove y, then add back y. With copy metadata in the changeset, this could easily | |
148 | end up reporting y as copied from x (if we don't unmark it as a copy when it's removed). |
|
148 | end up reporting y as copied from x (if we don't unmark it as a copy when it's removed). | |
149 | $ newrepo |
|
149 | $ newrepo | |
150 | $ echo x > x |
|
150 | $ echo x > x | |
151 | $ hg ci -Aqm 'add x' |
|
151 | $ hg ci -Aqm 'add x' | |
152 | $ hg mv x y |
|
152 | $ hg mv x y | |
153 | $ hg ci -m 'rename x to y' |
|
153 | $ hg ci -m 'rename x to y' | |
154 | $ hg rm y |
|
154 | $ hg rm y | |
155 | $ hg ci -qm 'remove y' |
|
155 | $ hg ci -qm 'remove y' | |
156 | $ echo x > y |
|
156 | $ echo x > y | |
157 | $ hg ci -Aqm 'add back y' |
|
157 | $ hg ci -Aqm 'add back y' | |
158 | $ hg l |
|
158 | $ hg l | |
159 | @ 3 add back y |
|
159 | @ 3 add back y | |
160 | | y |
|
160 | | y | |
161 | o 2 remove y |
|
161 | o 2 remove y | |
162 | | y |
|
162 | | y | |
163 | o 1 rename x to y |
|
163 | o 1 rename x to y | |
164 | | x y |
|
164 | | x y | |
165 | o 0 add x |
|
165 | o 0 add x | |
166 | x |
|
166 | x | |
167 | $ hg debugp1copies -r 3 |
|
167 | $ hg debugp1copies -r 3 | |
168 | $ hg debugpathcopies 0 3 |
|
168 | $ hg debugpathcopies 0 3 | |
169 |
|
169 | |||
170 | Copy x to z, then remove z, then copy x2 (same content as x) to z. With copy metadata in the |
|
170 | Copy x to z, then remove z, then copy x2 (same content as x) to z. With copy metadata in the | |
171 | changeset, the two copies here will have the same filelog entry, so ctx['z'].introrev() might point |
|
171 | changeset, the two copies here will have the same filelog entry, so ctx['z'].introrev() might point | |
172 | to the first commit that added the file. We should still report the copy as being from x2. |
|
172 | to the first commit that added the file. We should still report the copy as being from x2. | |
173 | $ newrepo |
|
173 | $ newrepo | |
174 | $ echo x > x |
|
174 | $ echo x > x | |
175 | $ echo x > x2 |
|
175 | $ echo x > x2 | |
176 | $ hg ci -Aqm 'add x and x2 with same content' |
|
176 | $ hg ci -Aqm 'add x and x2 with same content' | |
177 | $ hg cp x z |
|
177 | $ hg cp x z | |
178 | $ hg ci -qm 'copy x to z' |
|
178 | $ hg ci -qm 'copy x to z' | |
179 | $ hg rm z |
|
179 | $ hg rm z | |
180 | $ hg ci -m 'remove z' |
|
180 | $ hg ci -m 'remove z' | |
181 | $ hg cp x2 z |
|
181 | $ hg cp x2 z | |
182 | $ hg ci -m 'copy x2 to z' |
|
182 | $ hg ci -m 'copy x2 to z' | |
183 | $ hg l |
|
183 | $ hg l | |
184 | @ 3 copy x2 to z |
|
184 | @ 3 copy x2 to z | |
185 | | z |
|
185 | | z | |
186 | o 2 remove z |
|
186 | o 2 remove z | |
187 | | z |
|
187 | | z | |
188 | o 1 copy x to z |
|
188 | o 1 copy x to z | |
189 | | z |
|
189 | | z | |
190 | o 0 add x and x2 with same content |
|
190 | o 0 add x and x2 with same content | |
191 | x x2 |
|
191 | x x2 | |
192 | $ hg debugp1copies -r 3 |
|
192 | $ hg debugp1copies -r 3 | |
193 | x2 -> z |
|
193 | x2 -> z | |
194 | $ hg debugpathcopies 0 3 |
|
194 | $ hg debugpathcopies 0 3 | |
195 | x2 -> z |
|
195 | x2 -> z | |
196 |
|
196 | |||
197 | Create x and y, then rename them both to the same name, but on different sides of a fork |
|
197 | Create x and y, then rename them both to the same name, but on different sides of a fork | |
198 | $ newrepo |
|
198 | $ newrepo | |
199 | $ echo x > x |
|
199 | $ echo x > x | |
200 | $ echo y > y |
|
200 | $ echo y > y | |
201 | $ hg ci -Aqm 'add x and y' |
|
201 | $ hg ci -Aqm 'add x and y' | |
202 | $ hg mv x z |
|
202 | $ hg mv x z | |
203 | $ hg ci -qm 'rename x to z' |
|
203 | $ hg ci -qm 'rename x to z' | |
204 | $ hg co -q 0 |
|
204 | $ hg co -q 0 | |
205 | $ hg mv y z |
|
205 | $ hg mv y z | |
206 | $ hg ci -qm 'rename y to z' |
|
206 | $ hg ci -qm 'rename y to z' | |
207 | $ hg l |
|
207 | $ hg l | |
208 | @ 2 rename y to z |
|
208 | @ 2 rename y to z | |
209 | | y z |
|
209 | | y z | |
210 | | o 1 rename x to z |
|
210 | | o 1 rename x to z | |
211 | |/ x z |
|
211 | |/ x z | |
212 | o 0 add x and y |
|
212 | o 0 add x and y | |
213 | x y |
|
213 | x y | |
214 | $ hg debugpathcopies 1 2 |
|
214 | $ hg debugpathcopies 1 2 | |
215 | z -> x |
|
215 | z -> x | |
216 | y -> z |
|
216 | y -> z | |
217 |
|
217 | |||
218 | Fork renames x to y on one side and removes x on the other |
|
218 | Fork renames x to y on one side and removes x on the other | |
219 | $ newrepo |
|
219 | $ newrepo | |
220 | $ echo x > x |
|
220 | $ echo x > x | |
221 | $ hg ci -Aqm 'add x' |
|
221 | $ hg ci -Aqm 'add x' | |
222 | $ hg mv x y |
|
222 | $ hg mv x y | |
223 | $ hg ci -m 'rename x to y' |
|
223 | $ hg ci -m 'rename x to y' | |
224 | $ hg co -q 0 |
|
224 | $ hg co -q 0 | |
225 | $ hg rm x |
|
225 | $ hg rm x | |
226 | $ hg ci -m 'remove x' |
|
226 | $ hg ci -m 'remove x' | |
227 | created new head |
|
227 | created new head | |
228 | $ hg l |
|
228 | $ hg l | |
229 | @ 2 remove x |
|
229 | @ 2 remove x | |
230 | | x |
|
230 | | x | |
231 | | o 1 rename x to y |
|
231 | | o 1 rename x to y | |
232 | |/ x y |
|
232 | |/ x y | |
233 | o 0 add x |
|
233 | o 0 add x | |
234 | x |
|
234 | x | |
235 | $ hg debugpathcopies 1 2 |
|
235 | $ hg debugpathcopies 1 2 | |
236 |
|
236 | |||
237 | Copies via null revision (there shouldn't be any) |
|
237 | Copies via null revision (there shouldn't be any) | |
238 | $ newrepo |
|
238 | $ newrepo | |
239 | $ echo x > x |
|
239 | $ echo x > x | |
240 | $ hg ci -Aqm 'add x' |
|
240 | $ hg ci -Aqm 'add x' | |
241 | $ hg cp x y |
|
241 | $ hg cp x y | |
242 | $ hg ci -m 'copy x to y' |
|
242 | $ hg ci -m 'copy x to y' | |
243 | $ hg co -q null |
|
243 | $ hg co -q null | |
244 | $ echo x > x |
|
244 | $ echo x > x | |
245 | $ hg ci -Aqm 'add x (again)' |
|
245 | $ hg ci -Aqm 'add x (again)' | |
246 | $ hg l |
|
246 | $ hg l | |
247 | @ 2 add x (again) |
|
247 | @ 2 add x (again) | |
248 | x |
|
248 | x | |
249 | o 1 copy x to y |
|
249 | o 1 copy x to y | |
250 | | y |
|
250 | | y | |
251 | o 0 add x |
|
251 | o 0 add x | |
252 | x |
|
252 | x | |
253 | $ hg debugpathcopies 1 2 |
|
253 | $ hg debugpathcopies 1 2 | |
254 | $ hg debugpathcopies 2 1 |
|
254 | $ hg debugpathcopies 2 1 | |
255 |
|
255 | |||
256 | Merge rename from other branch |
|
256 | Merge rename from other branch | |
257 | $ newrepo |
|
257 | $ newrepo | |
258 | $ echo x > x |
|
258 | $ echo x > x | |
259 | $ hg ci -Aqm 'add x' |
|
259 | $ hg ci -Aqm 'add x' | |
260 | $ hg mv x y |
|
260 | $ hg mv x y | |
261 | $ hg ci -m 'rename x to y' |
|
261 | $ hg ci -m 'rename x to y' | |
262 | $ hg co -q 0 |
|
262 | $ hg co -q 0 | |
263 | $ echo z > z |
|
263 | $ echo z > z | |
264 | $ hg ci -Aqm 'add z' |
|
264 | $ hg ci -Aqm 'add z' | |
265 | $ hg merge -q 1 |
|
265 | $ hg merge -q 1 | |
266 | $ hg debugp1copies |
|
266 | $ hg debugp1copies | |
267 | $ hg debugp2copies |
|
267 | $ hg debugp2copies | |
268 | $ hg ci -m 'merge rename from p2' |
|
268 | $ hg ci -m 'merge rename from p2' | |
269 | $ hg l |
|
269 | $ hg l | |
270 | @ 3 merge rename from p2 |
|
270 | @ 3 merge rename from p2 | |
271 | |\ x |
|
271 | |\ x | |
272 | | o 2 add z |
|
272 | | o 2 add z | |
273 | | | z |
|
273 | | | z | |
274 | o | 1 rename x to y |
|
274 | o | 1 rename x to y | |
275 | |/ x y |
|
275 | |/ x y | |
276 | o 0 add x |
|
276 | o 0 add x | |
277 | x |
|
277 | x | |
278 | Perhaps we should indicate the rename here, but `hg status` is documented to be weird during |
|
278 | Perhaps we should indicate the rename here, but `hg status` is documented to be weird during | |
279 | merges, so... |
|
279 | merges, so... | |
280 | $ hg debugp1copies -r 3 |
|
280 | $ hg debugp1copies -r 3 | |
281 | $ hg debugp2copies -r 3 |
|
281 | $ hg debugp2copies -r 3 | |
282 | $ hg debugpathcopies 0 3 |
|
282 | $ hg debugpathcopies 0 3 | |
283 | x -> y |
|
283 | x -> y | |
284 | $ hg debugpathcopies 1 2 |
|
284 | $ hg debugpathcopies 1 2 | |
285 | y -> x |
|
285 | y -> x | |
286 | $ hg debugpathcopies 1 3 |
|
286 | $ hg debugpathcopies 1 3 | |
287 | $ hg debugpathcopies 2 3 |
|
287 | $ hg debugpathcopies 2 3 | |
288 | x -> y |
|
288 | x -> y | |
289 |
|
289 | |||
290 | Copy file from either side in a merge |
|
290 | Copy file from either side in a merge | |
291 | $ newrepo |
|
291 | $ newrepo | |
292 | $ echo x > x |
|
292 | $ echo x > x | |
293 | $ hg ci -Aqm 'add x' |
|
293 | $ hg ci -Aqm 'add x' | |
294 | $ hg co -q null |
|
294 | $ hg co -q null | |
295 | $ echo y > y |
|
295 | $ echo y > y | |
296 | $ hg ci -Aqm 'add y' |
|
296 | $ hg ci -Aqm 'add y' | |
297 | $ hg merge -q 0 |
|
297 | $ hg merge -q 0 | |
298 | $ hg cp y z |
|
298 | $ hg cp y z | |
299 | $ hg debugp1copies |
|
299 | $ hg debugp1copies | |
300 | y -> z |
|
300 | y -> z | |
301 | $ hg debugp2copies |
|
301 | $ hg debugp2copies | |
302 | $ hg ci -m 'copy file from p1 in merge' |
|
302 | $ hg ci -m 'copy file from p1 in merge' | |
303 | $ hg co -q 1 |
|
303 | $ hg co -q 1 | |
304 | $ hg merge -q 0 |
|
304 | $ hg merge -q 0 | |
305 | $ hg cp x z |
|
305 | $ hg cp x z | |
306 | $ hg debugp1copies |
|
306 | $ hg debugp1copies | |
307 | $ hg debugp2copies |
|
307 | $ hg debugp2copies | |
308 | x -> z |
|
308 | x -> z | |
309 | $ hg ci -qm 'copy file from p2 in merge' |
|
309 | $ hg ci -qm 'copy file from p2 in merge' | |
310 | $ hg l |
|
310 | $ hg l | |
311 | @ 3 copy file from p2 in merge |
|
311 | @ 3 copy file from p2 in merge | |
312 | |\ z |
|
312 | |\ z | |
313 | +---o 2 copy file from p1 in merge |
|
313 | +---o 2 copy file from p1 in merge | |
314 | | |/ z |
|
314 | | |/ z | |
315 | | o 1 add y |
|
315 | | o 1 add y | |
316 | | y |
|
316 | | y | |
317 | o 0 add x |
|
317 | o 0 add x | |
318 | x |
|
318 | x | |
319 | $ hg debugp1copies -r 2 |
|
319 | $ hg debugp1copies -r 2 | |
320 | y -> z |
|
320 | y -> z | |
321 | $ hg debugp2copies -r 2 |
|
321 | $ hg debugp2copies -r 2 | |
322 | $ hg debugpathcopies 1 2 |
|
322 | $ hg debugpathcopies 1 2 | |
323 | y -> z |
|
323 | y -> z | |
324 | $ hg debugpathcopies 0 2 |
|
324 | $ hg debugpathcopies 0 2 | |
325 | $ hg debugp1copies -r 3 |
|
325 | $ hg debugp1copies -r 3 | |
326 | $ hg debugp2copies -r 3 |
|
326 | $ hg debugp2copies -r 3 | |
327 | x -> z |
|
327 | x -> z | |
328 | $ hg debugpathcopies 1 3 |
|
328 | $ hg debugpathcopies 1 3 | |
329 | $ hg debugpathcopies 0 3 |
|
329 | $ hg debugpathcopies 0 3 | |
330 | x -> z |
|
330 | x -> z | |
331 |
|
331 | |||
332 | Copy file that exists on both sides of the merge, same content on both sides |
|
332 | Copy file that exists on both sides of the merge, same content on both sides | |
333 | $ newrepo |
|
333 | $ newrepo | |
334 | $ echo x > x |
|
334 | $ echo x > x | |
335 | $ hg ci -Aqm 'add x on branch 1' |
|
335 | $ hg ci -Aqm 'add x on branch 1' | |
336 | $ hg co -q null |
|
336 | $ hg co -q null | |
337 | $ echo x > x |
|
337 | $ echo x > x | |
338 | $ hg ci -Aqm 'add x on branch 2' |
|
338 | $ hg ci -Aqm 'add x on branch 2' | |
339 | $ hg merge -q 0 |
|
339 | $ hg merge -q 0 | |
340 | $ hg cp x z |
|
340 | $ hg cp x z | |
341 | $ hg debugp1copies |
|
341 | $ hg debugp1copies | |
342 | x -> z |
|
342 | x -> z | |
343 | $ hg debugp2copies |
|
343 | $ hg debugp2copies | |
344 | $ hg ci -qm 'merge' |
|
344 | $ hg ci -qm 'merge' | |
345 | $ hg l |
|
345 | $ hg l | |
346 | @ 2 merge |
|
346 | @ 2 merge | |
347 | |\ z |
|
347 | |\ z | |
348 | | o 1 add x on branch 2 |
|
348 | | o 1 add x on branch 2 | |
349 | | x |
|
349 | | x | |
350 | o 0 add x on branch 1 |
|
350 | o 0 add x on branch 1 | |
351 | x |
|
351 | x | |
352 | $ hg debugp1copies -r 2 |
|
352 | $ hg debugp1copies -r 2 | |
353 | x -> z |
|
353 | x -> z | |
354 | $ hg debugp2copies -r 2 |
|
354 | $ hg debugp2copies -r 2 | |
355 | It's a little weird that it shows up on both sides |
|
355 | It's a little weird that it shows up on both sides | |
356 | $ hg debugpathcopies 1 2 |
|
356 | $ hg debugpathcopies 1 2 | |
357 | x -> z |
|
357 | x -> z | |
358 | $ hg debugpathcopies 0 2 |
|
358 | $ hg debugpathcopies 0 2 | |
359 | x -> z (filelog !) |
|
359 | x -> z (filelog !) | |
360 |
|
360 | |||
361 | Copy file that exists on both sides of the merge, different content |
|
361 | Copy file that exists on both sides of the merge, different content | |
362 | $ newrepo |
|
362 | $ newrepo | |
363 | $ echo branch1 > x |
|
363 | $ echo branch1 > x | |
364 | $ hg ci -Aqm 'add x on branch 1' |
|
364 | $ hg ci -Aqm 'add x on branch 1' | |
365 | $ hg co -q null |
|
365 | $ hg co -q null | |
366 | $ echo branch2 > x |
|
366 | $ echo branch2 > x | |
367 | $ hg ci -Aqm 'add x on branch 2' |
|
367 | $ hg ci -Aqm 'add x on branch 2' | |
368 | $ hg merge -q 0 |
|
368 | $ hg merge -q 0 | |
369 | warning: conflicts while merging x! (edit, then use 'hg resolve --mark') |
|
369 | warning: conflicts while merging x! (edit, then use 'hg resolve --mark') | |
370 | [1] |
|
370 | [1] | |
371 | $ echo resolved > x |
|
371 | $ echo resolved > x | |
372 | $ hg resolve -m x |
|
372 | $ hg resolve -m x | |
373 | (no more unresolved files) |
|
373 | (no more unresolved files) | |
374 | $ hg cp x z |
|
374 | $ hg cp x z | |
375 | $ hg debugp1copies |
|
375 | $ hg debugp1copies | |
376 | x -> z |
|
376 | x -> z | |
377 | $ hg debugp2copies |
|
377 | $ hg debugp2copies | |
378 | $ hg ci -qm 'merge' |
|
378 | $ hg ci -qm 'merge' | |
379 | $ hg l |
|
379 | $ hg l | |
380 | @ 2 merge |
|
380 | @ 2 merge | |
381 | |\ x z |
|
381 | |\ x z | |
382 | | o 1 add x on branch 2 |
|
382 | | o 1 add x on branch 2 | |
383 | | x |
|
383 | | x | |
384 | o 0 add x on branch 1 |
|
384 | o 0 add x on branch 1 | |
385 | x |
|
385 | x | |
386 | $ hg debugp1copies -r 2 |
|
386 | $ hg debugp1copies -r 2 | |
387 | x -> z (changeset !) |
|
387 | x -> z (changeset !) | |
388 | $ hg debugp2copies -r 2 |
|
388 | $ hg debugp2copies -r 2 | |
389 | x -> z (no-changeset !) |
|
389 | x -> z (no-changeset !) | |
390 | $ hg debugpathcopies 1 2 |
|
390 | $ hg debugpathcopies 1 2 | |
391 | x -> z (changeset !) |
|
391 | x -> z (changeset !) | |
392 | $ hg debugpathcopies 0 2 |
|
392 | $ hg debugpathcopies 0 2 | |
393 | x -> z (no-changeset !) |
|
393 | x -> z (no-changeset !) | |
394 |
|
394 | |||
395 | Copy x->y on one side of merge and copy x->z on the other side. Pathcopies from one parent |
|
395 | Copy x->y on one side of merge and copy x->z on the other side. Pathcopies from one parent | |
396 | of the merge to the merge should include the copy from the other side. |
|
396 | of the merge to the merge should include the copy from the other side. | |
397 | $ newrepo |
|
397 | $ newrepo | |
398 | $ echo x > x |
|
398 | $ echo x > x | |
399 | $ hg ci -Aqm 'add x' |
|
399 | $ hg ci -Aqm 'add x' | |
400 | $ hg cp x y |
|
400 | $ hg cp x y | |
401 | $ hg ci -qm 'copy x to y' |
|
401 | $ hg ci -qm 'copy x to y' | |
402 | $ hg co -q 0 |
|
402 | $ hg co -q 0 | |
403 | $ hg cp x z |
|
403 | $ hg cp x z | |
404 | $ hg ci -qm 'copy x to z' |
|
404 | $ hg ci -qm 'copy x to z' | |
405 | $ hg merge -q 1 |
|
405 | $ hg merge -q 1 | |
406 | $ hg ci -m 'merge copy x->y and copy x->z' |
|
406 | $ hg ci -m 'merge copy x->y and copy x->z' | |
407 | $ hg l |
|
407 | $ hg l | |
408 | @ 3 merge copy x->y and copy x->z |
|
408 | @ 3 merge copy x->y and copy x->z | |
409 | |\ |
|
409 | |\ | |
410 | | o 2 copy x to z |
|
410 | | o 2 copy x to z | |
411 | | | z |
|
411 | | | z | |
412 | o | 1 copy x to y |
|
412 | o | 1 copy x to y | |
413 | |/ y |
|
413 | |/ y | |
414 | o 0 add x |
|
414 | o 0 add x | |
415 | x |
|
415 | x | |
416 | $ hg debugp1copies -r 3 |
|
416 | $ hg debugp1copies -r 3 | |
417 | $ hg debugp2copies -r 3 |
|
417 | $ hg debugp2copies -r 3 | |
418 | $ hg debugpathcopies 2 3 |
|
418 | $ hg debugpathcopies 2 3 | |
419 | x -> y |
|
419 | x -> y | |
420 | $ hg debugpathcopies 1 3 |
|
420 | $ hg debugpathcopies 1 3 | |
421 | x -> z |
|
421 | x -> z | |
422 |
|
422 | |||
423 | Copy x to y on one side of merge, create y and rename to z on the other side. Pathcopies from the |
|
423 | Copy x to y on one side of merge, create y and rename to z on the other side. Pathcopies from the | |
424 | first side should not include the y->z rename since y didn't exist in the merge base. |
|
424 | first side should not include the y->z rename since y didn't exist in the merge base. | |
425 | $ newrepo |
|
425 | $ newrepo | |
426 | $ echo x > x |
|
426 | $ echo x > x | |
427 | $ hg ci -Aqm 'add x' |
|
427 | $ hg ci -Aqm 'add x' | |
428 | $ hg cp x y |
|
428 | $ hg cp x y | |
429 | $ hg ci -qm 'copy x to y' |
|
429 | $ hg ci -qm 'copy x to y' | |
430 | $ hg co -q 0 |
|
430 | $ hg co -q 0 | |
431 | $ echo y > y |
|
431 | $ echo y > y | |
432 | $ hg ci -Aqm 'add y' |
|
432 | $ hg ci -Aqm 'add y' | |
433 | $ hg mv y z |
|
433 | $ hg mv y z | |
434 | $ hg ci -m 'rename y to z' |
|
434 | $ hg ci -m 'rename y to z' | |
435 | $ hg merge -q 1 |
|
435 | $ hg merge -q 1 | |
436 | $ hg ci -m 'merge' |
|
436 | $ hg ci -m 'merge' | |
437 | $ hg l |
|
437 | $ hg l | |
438 | @ 4 merge |
|
438 | @ 4 merge | |
439 | |\ |
|
439 | |\ | |
440 | | o 3 rename y to z |
|
440 | | o 3 rename y to z | |
441 | | | y z |
|
441 | | | y z | |
442 | | o 2 add y |
|
442 | | o 2 add y | |
443 | | | y |
|
443 | | | y | |
444 | o | 1 copy x to y |
|
444 | o | 1 copy x to y | |
445 | |/ y |
|
445 | |/ y | |
446 | o 0 add x |
|
446 | o 0 add x | |
447 | x |
|
447 | x | |
448 | $ hg debugp1copies -r 3 |
|
448 | $ hg debugp1copies -r 3 | |
449 | y -> z |
|
449 | y -> z | |
450 | $ hg debugp2copies -r 3 |
|
450 | $ hg debugp2copies -r 3 | |
451 | $ hg debugpathcopies 2 3 |
|
451 | $ hg debugpathcopies 2 3 | |
452 | y -> z |
|
452 | y -> z | |
453 | $ hg debugpathcopies 1 3 |
|
453 | $ hg debugpathcopies 1 3 | |
454 |
|
454 | |||
455 | Create x and y, then rename x to z on one side of merge, and rename y to z and modify z on the |
|
455 | Create x and y, then rename x to z on one side of merge, and rename y to z and modify z on the | |
456 | other side. |
|
456 | other side. | |
457 | $ newrepo |
|
457 | $ newrepo | |
458 | $ echo x > x |
|
458 | $ echo x > x | |
459 | $ echo y > y |
|
459 | $ echo y > y | |
460 | $ hg ci -Aqm 'add x and y' |
|
460 | $ hg ci -Aqm 'add x and y' | |
461 | $ hg mv x z |
|
461 | $ hg mv x z | |
462 | $ hg ci -qm 'rename x to z' |
|
462 | $ hg ci -qm 'rename x to z' | |
463 | $ hg co -q 0 |
|
463 | $ hg co -q 0 | |
464 | $ hg mv y z |
|
464 | $ hg mv y z | |
465 | $ hg ci -qm 'rename y to z' |
|
465 | $ hg ci -qm 'rename y to z' | |
466 | $ echo z >> z |
|
466 | $ echo z >> z | |
467 | $ hg ci -m 'modify z' |
|
467 | $ hg ci -m 'modify z' | |
468 | $ hg merge -q 1 |
|
468 | $ hg merge -q 1 | |
469 | warning: conflicts while merging z! (edit, then use 'hg resolve --mark') |
|
469 | warning: conflicts while merging z! (edit, then use 'hg resolve --mark') | |
470 | [1] |
|
470 | [1] | |
471 | $ echo z > z |
|
471 | $ echo z > z | |
472 | $ hg resolve -qm z |
|
472 | $ hg resolve -qm z | |
473 | $ hg ci -m 'merge 1 into 3' |
|
473 | $ hg ci -m 'merge 1 into 3' | |
474 | Try merging the other direction too |
|
474 | Try merging the other direction too | |
475 | $ hg co -q 1 |
|
475 | $ hg co -q 1 | |
476 | $ hg merge -q 3 |
|
476 | $ hg merge -q 3 | |
477 | warning: conflicts while merging z! (edit, then use 'hg resolve --mark') |
|
477 | warning: conflicts while merging z! (edit, then use 'hg resolve --mark') | |
478 | [1] |
|
478 | [1] | |
479 | $ echo z > z |
|
479 | $ echo z > z | |
480 | $ hg resolve -qm z |
|
480 | $ hg resolve -qm z | |
481 | $ hg ci -m 'merge 3 into 1' |
|
481 | $ hg ci -m 'merge 3 into 1' | |
482 | created new head |
|
482 | created new head | |
483 | $ hg l |
|
483 | $ hg l | |
484 | @ 5 merge 3 into 1 |
|
484 | @ 5 merge 3 into 1 | |
485 | |\ y z |
|
485 | |\ y z | |
486 | +---o 4 merge 1 into 3 |
|
486 | +---o 4 merge 1 into 3 | |
487 | | |/ x z |
|
487 | | |/ x z | |
488 | | o 3 modify z |
|
488 | | o 3 modify z | |
489 | | | z |
|
489 | | | z | |
490 | | o 2 rename y to z |
|
490 | | o 2 rename y to z | |
491 | | | y z |
|
491 | | | y z | |
492 | o | 1 rename x to z |
|
492 | o | 1 rename x to z | |
493 | |/ x z |
|
493 | |/ x z | |
494 | o 0 add x and y |
|
494 | o 0 add x and y | |
495 | x y |
|
495 | x y | |
496 | $ hg debugpathcopies 1 4 |
|
496 | $ hg debugpathcopies 1 4 | |
497 | $ hg debugpathcopies 2 4 |
|
497 | $ hg debugpathcopies 2 4 | |
498 | $ hg debugpathcopies 0 4 |
|
498 | $ hg debugpathcopies 0 4 | |
499 | x -> z (filelog !) |
|
499 | x -> z (filelog !) | |
500 | y -> z (compatibility !) |
|
500 | y -> z (compatibility !) | |
|
501 | y -> z (changeset !) | |||
501 | $ hg debugpathcopies 1 5 |
|
502 | $ hg debugpathcopies 1 5 | |
502 | $ hg debugpathcopies 2 5 |
|
503 | $ hg debugpathcopies 2 5 | |
503 | $ hg debugpathcopies 0 5 |
|
504 | $ hg debugpathcopies 0 5 | |
504 | x -> z |
|
505 | x -> z | |
505 |
|
506 | |||
506 |
|
507 | |||
507 | Test for a case in fullcopytracing algorithm where both the merging csets are |
|
508 | Test for a case in fullcopytracing algorithm where both the merging csets are | |
508 | "dirty"; where a dirty cset means that cset is descendant of merge base. This |
|
509 | "dirty"; where a dirty cset means that cset is descendant of merge base. This | |
509 | test reflect that for this particular case this algorithm correctly find the copies: |
|
510 | test reflect that for this particular case this algorithm correctly find the copies: | |
510 |
|
511 | |||
511 | $ cat >> $HGRCPATH << EOF |
|
512 | $ cat >> $HGRCPATH << EOF | |
512 | > [experimental] |
|
513 | > [experimental] | |
513 | > evolution.createmarkers=True |
|
514 | > evolution.createmarkers=True | |
514 | > evolution.allowunstable=True |
|
515 | > evolution.allowunstable=True | |
515 | > EOF |
|
516 | > EOF | |
516 |
|
517 | |||
517 | $ newrepo |
|
518 | $ newrepo | |
518 | $ echo a > a |
|
519 | $ echo a > a | |
519 | $ hg add a |
|
520 | $ hg add a | |
520 | $ hg ci -m "added a" |
|
521 | $ hg ci -m "added a" | |
521 | $ echo b > b |
|
522 | $ echo b > b | |
522 | $ hg add b |
|
523 | $ hg add b | |
523 | $ hg ci -m "added b" |
|
524 | $ hg ci -m "added b" | |
524 |
|
525 | |||
525 | $ hg mv b b1 |
|
526 | $ hg mv b b1 | |
526 | $ hg ci -m "rename b to b1" |
|
527 | $ hg ci -m "rename b to b1" | |
527 |
|
528 | |||
528 | $ hg up ".^" |
|
529 | $ hg up ".^" | |
529 | 1 files updated, 0 files merged, 1 files removed, 0 files unresolved |
|
530 | 1 files updated, 0 files merged, 1 files removed, 0 files unresolved | |
530 | $ echo d > d |
|
531 | $ echo d > d | |
531 | $ hg add d |
|
532 | $ hg add d | |
532 | $ hg ci -m "added d" |
|
533 | $ hg ci -m "added d" | |
533 | created new head |
|
534 | created new head | |
534 |
|
535 | |||
535 | $ echo baba >> b |
|
536 | $ echo baba >> b | |
536 | $ hg ci --amend -m "added d, modified b" |
|
537 | $ hg ci --amend -m "added d, modified b" | |
537 |
|
538 | |||
538 | $ hg l --hidden |
|
539 | $ hg l --hidden | |
539 | @ 4 added d, modified b |
|
540 | @ 4 added d, modified b | |
540 | | b d |
|
541 | | b d | |
541 | | x 3 added d |
|
542 | | x 3 added d | |
542 | |/ d |
|
543 | |/ d | |
543 | | o 2 rename b to b1 |
|
544 | | o 2 rename b to b1 | |
544 | |/ b b1 |
|
545 | |/ b b1 | |
545 | o 1 added b |
|
546 | o 1 added b | |
546 | | b |
|
547 | | b | |
547 | o 0 added a |
|
548 | o 0 added a | |
548 | a |
|
549 | a | |
549 |
|
550 | |||
550 | Grafting revision 4 on top of revision 2, showing that it respect the rename: |
|
551 | Grafting revision 4 on top of revision 2, showing that it respect the rename: | |
551 |
|
552 | |||
552 | TODO: Make this work with copy info in changesets (probably by writing a |
|
553 | TODO: Make this work with copy info in changesets (probably by writing a | |
553 | changeset-centric version of copies.mergecopies()) |
|
554 | changeset-centric version of copies.mergecopies()) | |
554 | #if no-changeset |
|
555 | #if no-changeset | |
555 | $ hg up 2 -q |
|
556 | $ hg up 2 -q | |
556 | $ hg graft -r 4 --base 3 --hidden |
|
557 | $ hg graft -r 4 --base 3 --hidden | |
557 | grafting 4:af28412ec03c "added d, modified b" (tip) |
|
558 | grafting 4:af28412ec03c "added d, modified b" (tip) | |
558 | merging b1 and b to b1 |
|
559 | merging b1 and b to b1 | |
559 |
|
560 | |||
560 | $ hg l -l1 -p |
|
561 | $ hg l -l1 -p | |
561 | @ 5 added d, modified b |
|
562 | @ 5 added d, modified b | |
562 | | b1 |
|
563 | | b1 | |
563 | ~ diff -r 5a4825cc2926 -r 94a2f1a0e8e2 b1 |
|
564 | ~ diff -r 5a4825cc2926 -r 94a2f1a0e8e2 b1 | |
564 | --- a/b1 Thu Jan 01 00:00:00 1970 +0000 |
|
565 | --- a/b1 Thu Jan 01 00:00:00 1970 +0000 | |
565 | +++ b/b1 Thu Jan 01 00:00:00 1970 +0000 |
|
566 | +++ b/b1 Thu Jan 01 00:00:00 1970 +0000 | |
566 | @@ -1,1 +1,2 @@ |
|
567 | @@ -1,1 +1,2 @@ | |
567 | b |
|
568 | b | |
568 | +baba |
|
569 | +baba | |
569 |
|
570 | |||
570 | #endif |
|
571 | #endif | |
571 |
|
572 | |||
572 | Test to make sure that fullcopytracing algorithm don't fail when both the merging csets are dirty |
|
573 | Test to make sure that fullcopytracing algorithm don't fail when both the merging csets are dirty | |
573 | (a dirty cset is one who is not the descendant of merge base) |
|
574 | (a dirty cset is one who is not the descendant of merge base) | |
574 | ------------------------------------------------------------------------------------------------- |
|
575 | ------------------------------------------------------------------------------------------------- | |
575 |
|
576 | |||
576 | $ newrepo |
|
577 | $ newrepo | |
577 | $ echo a > a |
|
578 | $ echo a > a | |
578 | $ hg add a |
|
579 | $ hg add a | |
579 | $ hg ci -m "added a" |
|
580 | $ hg ci -m "added a" | |
580 | $ echo b > b |
|
581 | $ echo b > b | |
581 | $ hg add b |
|
582 | $ hg add b | |
582 | $ hg ci -m "added b" |
|
583 | $ hg ci -m "added b" | |
583 |
|
584 | |||
584 | $ echo foobar > willconflict |
|
585 | $ echo foobar > willconflict | |
585 | $ hg add willconflict |
|
586 | $ hg add willconflict | |
586 | $ hg ci -m "added willconflict" |
|
587 | $ hg ci -m "added willconflict" | |
587 | $ echo c > c |
|
588 | $ echo c > c | |
588 | $ hg add c |
|
589 | $ hg add c | |
589 | $ hg ci -m "added c" |
|
590 | $ hg ci -m "added c" | |
590 |
|
591 | |||
591 | $ hg l |
|
592 | $ hg l | |
592 | @ 3 added c |
|
593 | @ 3 added c | |
593 | | c |
|
594 | | c | |
594 | o 2 added willconflict |
|
595 | o 2 added willconflict | |
595 | | willconflict |
|
596 | | willconflict | |
596 | o 1 added b |
|
597 | o 1 added b | |
597 | | b |
|
598 | | b | |
598 | o 0 added a |
|
599 | o 0 added a | |
599 | a |
|
600 | a | |
600 |
|
601 | |||
601 | $ hg up ".^^" |
|
602 | $ hg up ".^^" | |
602 | 0 files updated, 0 files merged, 2 files removed, 0 files unresolved |
|
603 | 0 files updated, 0 files merged, 2 files removed, 0 files unresolved | |
603 | $ echo d > d |
|
604 | $ echo d > d | |
604 | $ hg add d |
|
605 | $ hg add d | |
605 | $ hg ci -m "added d" |
|
606 | $ hg ci -m "added d" | |
606 | created new head |
|
607 | created new head | |
607 |
|
608 | |||
608 | $ echo barfoo > willconflict |
|
609 | $ echo barfoo > willconflict | |
609 | $ hg add willconflict |
|
610 | $ hg add willconflict | |
610 | $ hg ci --amend -m "added willconflict and d" |
|
611 | $ hg ci --amend -m "added willconflict and d" | |
611 |
|
612 | |||
612 | $ hg l |
|
613 | $ hg l | |
613 | @ 5 added willconflict and d |
|
614 | @ 5 added willconflict and d | |
614 | | d willconflict |
|
615 | | d willconflict | |
615 | | o 3 added c |
|
616 | | o 3 added c | |
616 | | | c |
|
617 | | | c | |
617 | | o 2 added willconflict |
|
618 | | o 2 added willconflict | |
618 | |/ willconflict |
|
619 | |/ willconflict | |
619 | o 1 added b |
|
620 | o 1 added b | |
620 | | b |
|
621 | | b | |
621 | o 0 added a |
|
622 | o 0 added a | |
622 | a |
|
623 | a | |
623 |
|
624 | |||
624 | $ hg rebase -r . -d 2 -t :other |
|
625 | $ hg rebase -r . -d 2 -t :other | |
625 | rebasing 5:5018b1509e94 "added willconflict and d" (tip) |
|
626 | rebasing 5:5018b1509e94 "added willconflict and d" (tip) | |
626 |
|
627 | |||
627 | $ hg up 3 -q |
|
628 | $ hg up 3 -q | |
628 | $ hg l --hidden |
|
629 | $ hg l --hidden | |
629 | o 6 added willconflict and d |
|
630 | o 6 added willconflict and d | |
630 | | d willconflict |
|
631 | | d willconflict | |
631 | | x 5 added willconflict and d |
|
632 | | x 5 added willconflict and d | |
632 | | | d willconflict |
|
633 | | | d willconflict | |
633 | | | x 4 added d |
|
634 | | | x 4 added d | |
634 | | |/ d |
|
635 | | |/ d | |
635 | +---@ 3 added c |
|
636 | +---@ 3 added c | |
636 | | | c |
|
637 | | | c | |
637 | o | 2 added willconflict |
|
638 | o | 2 added willconflict | |
638 | |/ willconflict |
|
639 | |/ willconflict | |
639 | o 1 added b |
|
640 | o 1 added b | |
640 | | b |
|
641 | | b | |
641 | o 0 added a |
|
642 | o 0 added a | |
642 | a |
|
643 | a | |
643 |
|
644 | |||
644 | Now if we trigger a merge between cset revision 3 and 6 using base revision 4, in this case |
|
645 | Now if we trigger a merge between cset revision 3 and 6 using base revision 4, in this case | |
645 | both the merging csets will be dirty as no one is descendent of base revision: |
|
646 | both the merging csets will be dirty as no one is descendent of base revision: | |
646 |
|
647 | |||
647 | $ hg graft -r 6 --base 4 --hidden -t :other |
|
648 | $ hg graft -r 6 --base 4 --hidden -t :other | |
648 | grafting 6:99802e4f1e46 "added willconflict and d" (tip) |
|
649 | grafting 6:99802e4f1e46 "added willconflict and d" (tip) |
@@ -1,1889 +1,1889 b'' | |||||
1 | Test basic extension support |
|
1 | Test basic extension support | |
2 | $ cat > unflush.py <<EOF |
|
2 | $ cat > unflush.py <<EOF | |
3 | > import sys |
|
3 | > import sys | |
4 | > from mercurial import pycompat |
|
4 | > from mercurial import pycompat | |
5 | > if pycompat.ispy3: |
|
5 | > if pycompat.ispy3: | |
6 | > # no changes required |
|
6 | > # no changes required | |
7 | > sys.exit(0) |
|
7 | > sys.exit(0) | |
8 | > with open(sys.argv[1], 'rb') as f: |
|
8 | > with open(sys.argv[1], 'rb') as f: | |
9 | > data = f.read() |
|
9 | > data = f.read() | |
10 | > with open(sys.argv[1], 'wb') as f: |
|
10 | > with open(sys.argv[1], 'wb') as f: | |
11 | > f.write(data.replace(b', flush=True', b'')) |
|
11 | > f.write(data.replace(b', flush=True', b'')) | |
12 | > EOF |
|
12 | > EOF | |
13 |
|
13 | |||
14 | $ cat > foobar.py <<EOF |
|
14 | $ cat > foobar.py <<EOF | |
15 | > import os |
|
15 | > import os | |
16 | > from mercurial import commands, exthelper, registrar |
|
16 | > from mercurial import commands, exthelper, registrar | |
17 | > |
|
17 | > | |
18 | > eh = exthelper.exthelper() |
|
18 | > eh = exthelper.exthelper() | |
19 | > eh.configitem(b'tests', b'foo', default=b"Foo") |
|
19 | > eh.configitem(b'tests', b'foo', default=b"Foo") | |
20 | > |
|
20 | > | |
21 | > uisetup = eh.finaluisetup |
|
21 | > uisetup = eh.finaluisetup | |
22 | > uipopulate = eh.finaluipopulate |
|
22 | > uipopulate = eh.finaluipopulate | |
23 | > reposetup = eh.finalreposetup |
|
23 | > reposetup = eh.finalreposetup | |
24 | > cmdtable = eh.cmdtable |
|
24 | > cmdtable = eh.cmdtable | |
25 | > configtable = eh.configtable |
|
25 | > configtable = eh.configtable | |
26 | > |
|
26 | > | |
27 | > @eh.uisetup |
|
27 | > @eh.uisetup | |
28 | > def _uisetup(ui): |
|
28 | > def _uisetup(ui): | |
29 | > ui.debug(b"uisetup called [debug]\\n") |
|
29 | > ui.debug(b"uisetup called [debug]\\n") | |
30 | > ui.write(b"uisetup called\\n") |
|
30 | > ui.write(b"uisetup called\\n") | |
31 | > ui.status(b"uisetup called [status]\\n") |
|
31 | > ui.status(b"uisetup called [status]\\n") | |
32 | > ui.flush() |
|
32 | > ui.flush() | |
33 | > @eh.uipopulate |
|
33 | > @eh.uipopulate | |
34 | > def _uipopulate(ui): |
|
34 | > def _uipopulate(ui): | |
35 | > ui._populatecnt = getattr(ui, "_populatecnt", 0) + 1 |
|
35 | > ui._populatecnt = getattr(ui, "_populatecnt", 0) + 1 | |
36 | > ui.write(b"uipopulate called (%d times)\n" % ui._populatecnt) |
|
36 | > ui.write(b"uipopulate called (%d times)\n" % ui._populatecnt) | |
37 | > @eh.reposetup |
|
37 | > @eh.reposetup | |
38 | > def _reposetup(ui, repo): |
|
38 | > def _reposetup(ui, repo): | |
39 | > ui.write(b"reposetup called for %s\\n" % os.path.basename(repo.root)) |
|
39 | > ui.write(b"reposetup called for %s\\n" % os.path.basename(repo.root)) | |
40 | > ui.write(b"ui %s= repo.ui\\n" % (ui == repo.ui and b"=" or b"!")) |
|
40 | > ui.write(b"ui %s= repo.ui\\n" % (ui == repo.ui and b"=" or b"!")) | |
41 | > ui.flush() |
|
41 | > ui.flush() | |
42 | > @eh.command(b'foo', [], b'hg foo') |
|
42 | > @eh.command(b'foo', [], b'hg foo') | |
43 | > def foo(ui, *args, **kwargs): |
|
43 | > def foo(ui, *args, **kwargs): | |
44 | > foo = ui.config(b'tests', b'foo') |
|
44 | > foo = ui.config(b'tests', b'foo') | |
45 | > ui.write(foo) |
|
45 | > ui.write(foo) | |
46 | > ui.write(b"\\n") |
|
46 | > ui.write(b"\\n") | |
47 | > @eh.command(b'bar', [], b'hg bar', norepo=True) |
|
47 | > @eh.command(b'bar', [], b'hg bar', norepo=True) | |
48 | > def bar(ui, *args, **kwargs): |
|
48 | > def bar(ui, *args, **kwargs): | |
49 | > ui.write(b"Bar\\n") |
|
49 | > ui.write(b"Bar\\n") | |
50 | > EOF |
|
50 | > EOF | |
51 | $ abspath=`pwd`/foobar.py |
|
51 | $ abspath=`pwd`/foobar.py | |
52 |
|
52 | |||
53 | $ mkdir barfoo |
|
53 | $ mkdir barfoo | |
54 | $ cp foobar.py barfoo/__init__.py |
|
54 | $ cp foobar.py barfoo/__init__.py | |
55 | $ barfoopath=`pwd`/barfoo |
|
55 | $ barfoopath=`pwd`/barfoo | |
56 |
|
56 | |||
57 | $ hg init a |
|
57 | $ hg init a | |
58 | $ cd a |
|
58 | $ cd a | |
59 | $ echo foo > file |
|
59 | $ echo foo > file | |
60 | $ hg add file |
|
60 | $ hg add file | |
61 | $ hg commit -m 'add file' |
|
61 | $ hg commit -m 'add file' | |
62 |
|
62 | |||
63 | $ echo '[extensions]' >> $HGRCPATH |
|
63 | $ echo '[extensions]' >> $HGRCPATH | |
64 | $ echo "foobar = $abspath" >> $HGRCPATH |
|
64 | $ echo "foobar = $abspath" >> $HGRCPATH | |
65 | $ hg foo |
|
65 | $ hg foo | |
66 | uisetup called |
|
66 | uisetup called | |
67 | uisetup called [status] |
|
67 | uisetup called [status] | |
68 | uipopulate called (1 times) |
|
68 | uipopulate called (1 times) | |
69 | uipopulate called (1 times) |
|
69 | uipopulate called (1 times) | |
70 | uipopulate called (1 times) |
|
70 | uipopulate called (1 times) | |
71 | reposetup called for a |
|
71 | reposetup called for a | |
72 | ui == repo.ui |
|
72 | ui == repo.ui | |
73 | uipopulate called (1 times) (chg !) |
|
73 | uipopulate called (1 times) (chg !) | |
74 | uipopulate called (1 times) (chg !) |
|
74 | uipopulate called (1 times) (chg !) | |
75 | uipopulate called (1 times) (chg !) |
|
75 | uipopulate called (1 times) (chg !) | |
76 | uipopulate called (1 times) (chg !) |
|
76 | uipopulate called (1 times) (chg !) | |
77 | uipopulate called (1 times) (chg !) |
|
77 | uipopulate called (1 times) (chg !) | |
78 | reposetup called for a (chg !) |
|
78 | reposetup called for a (chg !) | |
79 | ui == repo.ui (chg !) |
|
79 | ui == repo.ui (chg !) | |
80 | Foo |
|
80 | Foo | |
81 | $ hg foo --quiet |
|
81 | $ hg foo --quiet | |
82 | uisetup called (no-chg !) |
|
82 | uisetup called (no-chg !) | |
83 | uipopulate called (1 times) |
|
83 | uipopulate called (1 times) | |
84 | uipopulate called (1 times) |
|
84 | uipopulate called (1 times) | |
85 | uipopulate called (1 times) (chg !) |
|
85 | uipopulate called (1 times) (chg !) | |
86 | uipopulate called (1 times) (chg !) |
|
86 | uipopulate called (1 times) (chg !) | |
87 |
uipopulate called (1 times) |
|
87 | uipopulate called (1 times) | |
88 |
reposetup called for a |
|
88 | reposetup called for a | |
89 | ui == repo.ui |
|
89 | ui == repo.ui | |
90 | Foo |
|
90 | Foo | |
91 | $ hg foo --debug |
|
91 | $ hg foo --debug | |
92 | uisetup called [debug] (no-chg !) |
|
92 | uisetup called [debug] (no-chg !) | |
93 | uisetup called (no-chg !) |
|
93 | uisetup called (no-chg !) | |
94 | uisetup called [status] (no-chg !) |
|
94 | uisetup called [status] (no-chg !) | |
95 | uipopulate called (1 times) |
|
95 | uipopulate called (1 times) | |
96 | uipopulate called (1 times) |
|
96 | uipopulate called (1 times) | |
97 | uipopulate called (1 times) (chg !) |
|
97 | uipopulate called (1 times) (chg !) | |
98 | uipopulate called (1 times) (chg !) |
|
98 | uipopulate called (1 times) (chg !) | |
99 |
uipopulate called (1 times) |
|
99 | uipopulate called (1 times) | |
100 |
reposetup called for a |
|
100 | reposetup called for a | |
101 | ui == repo.ui |
|
101 | ui == repo.ui | |
102 | Foo |
|
102 | Foo | |
103 |
|
103 | |||
104 | $ cd .. |
|
104 | $ cd .. | |
105 | $ hg clone a b |
|
105 | $ hg clone a b | |
106 | uisetup called (no-chg !) |
|
106 | uisetup called (no-chg !) | |
107 | uisetup called [status] (no-chg !) |
|
107 | uisetup called [status] (no-chg !) | |
108 | uipopulate called (1 times) |
|
108 | uipopulate called (1 times) | |
109 | uipopulate called (1 times) (chg !) |
|
109 | uipopulate called (1 times) (chg !) | |
110 |
uipopulate called (1 times) |
|
110 | uipopulate called (1 times) | |
111 | reposetup called for a |
|
111 | reposetup called for a | |
112 | ui == repo.ui |
|
112 | ui == repo.ui | |
113 | uipopulate called (1 times) |
|
113 | uipopulate called (1 times) | |
114 | reposetup called for b |
|
114 | reposetup called for b | |
115 | ui == repo.ui |
|
115 | ui == repo.ui | |
116 | updating to branch default |
|
116 | updating to branch default | |
117 | 1 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
117 | 1 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
118 |
|
118 | |||
119 | $ hg bar |
|
119 | $ hg bar | |
120 | uisetup called (no-chg !) |
|
120 | uisetup called (no-chg !) | |
121 | uisetup called [status] (no-chg !) |
|
121 | uisetup called [status] (no-chg !) | |
122 | uipopulate called (1 times) |
|
122 | uipopulate called (1 times) | |
123 | uipopulate called (1 times) (chg !) |
|
123 | uipopulate called (1 times) (chg !) | |
124 | Bar |
|
124 | Bar | |
125 | $ echo 'foobar = !' >> $HGRCPATH |
|
125 | $ echo 'foobar = !' >> $HGRCPATH | |
126 |
|
126 | |||
127 | module/__init__.py-style |
|
127 | module/__init__.py-style | |
128 |
|
128 | |||
129 | $ echo "barfoo = $barfoopath" >> $HGRCPATH |
|
129 | $ echo "barfoo = $barfoopath" >> $HGRCPATH | |
130 | $ cd a |
|
130 | $ cd a | |
131 | $ hg foo |
|
131 | $ hg foo | |
132 | uisetup called |
|
132 | uisetup called | |
133 | uisetup called [status] |
|
133 | uisetup called [status] | |
134 | uipopulate called (1 times) |
|
134 | uipopulate called (1 times) | |
135 | uipopulate called (1 times) |
|
135 | uipopulate called (1 times) | |
136 | uipopulate called (1 times) |
|
136 | uipopulate called (1 times) | |
137 | reposetup called for a |
|
137 | reposetup called for a | |
138 | ui == repo.ui |
|
138 | ui == repo.ui | |
139 | uipopulate called (1 times) (chg !) |
|
139 | uipopulate called (1 times) (chg !) | |
140 | uipopulate called (1 times) (chg !) |
|
140 | uipopulate called (1 times) (chg !) | |
141 | uipopulate called (1 times) (chg !) |
|
141 | uipopulate called (1 times) (chg !) | |
142 | uipopulate called (1 times) (chg !) |
|
142 | uipopulate called (1 times) (chg !) | |
143 | uipopulate called (1 times) (chg !) |
|
143 | uipopulate called (1 times) (chg !) | |
144 | reposetup called for a (chg !) |
|
144 | reposetup called for a (chg !) | |
145 | ui == repo.ui (chg !) |
|
145 | ui == repo.ui (chg !) | |
146 | Foo |
|
146 | Foo | |
147 | $ echo 'barfoo = !' >> $HGRCPATH |
|
147 | $ echo 'barfoo = !' >> $HGRCPATH | |
148 |
|
148 | |||
149 | Check that extensions are loaded in phases: |
|
149 | Check that extensions are loaded in phases: | |
150 |
|
150 | |||
151 | $ cat > foo.py <<EOF |
|
151 | $ cat > foo.py <<EOF | |
152 | > from __future__ import print_function |
|
152 | > from __future__ import print_function | |
153 | > import os |
|
153 | > import os | |
154 | > from mercurial import exthelper |
|
154 | > from mercurial import exthelper | |
155 | > name = os.path.basename(__file__).rsplit('.', 1)[0] |
|
155 | > name = os.path.basename(__file__).rsplit('.', 1)[0] | |
156 | > print("1) %s imported" % name, flush=True) |
|
156 | > print("1) %s imported" % name, flush=True) | |
157 | > eh = exthelper.exthelper() |
|
157 | > eh = exthelper.exthelper() | |
158 | > @eh.uisetup |
|
158 | > @eh.uisetup | |
159 | > def _uisetup(ui): |
|
159 | > def _uisetup(ui): | |
160 | > print("2) %s uisetup" % name, flush=True) |
|
160 | > print("2) %s uisetup" % name, flush=True) | |
161 | > @eh.extsetup |
|
161 | > @eh.extsetup | |
162 | > def _extsetup(ui): |
|
162 | > def _extsetup(ui): | |
163 | > print("3) %s extsetup" % name, flush=True) |
|
163 | > print("3) %s extsetup" % name, flush=True) | |
164 | > @eh.uipopulate |
|
164 | > @eh.uipopulate | |
165 | > def _uipopulate(ui): |
|
165 | > def _uipopulate(ui): | |
166 | > print("4) %s uipopulate" % name, flush=True) |
|
166 | > print("4) %s uipopulate" % name, flush=True) | |
167 | > @eh.reposetup |
|
167 | > @eh.reposetup | |
168 | > def _reposetup(ui, repo): |
|
168 | > def _reposetup(ui, repo): | |
169 | > print("5) %s reposetup" % name, flush=True) |
|
169 | > print("5) %s reposetup" % name, flush=True) | |
170 | > |
|
170 | > | |
171 | > extsetup = eh.finalextsetup |
|
171 | > extsetup = eh.finalextsetup | |
172 | > reposetup = eh.finalreposetup |
|
172 | > reposetup = eh.finalreposetup | |
173 | > uipopulate = eh.finaluipopulate |
|
173 | > uipopulate = eh.finaluipopulate | |
174 | > uisetup = eh.finaluisetup |
|
174 | > uisetup = eh.finaluisetup | |
175 | > revsetpredicate = eh.revsetpredicate |
|
175 | > revsetpredicate = eh.revsetpredicate | |
176 | > |
|
176 | > | |
177 | > bytesname = name.encode('utf-8') |
|
177 | > bytesname = name.encode('utf-8') | |
178 | > # custom predicate to check registration of functions at loading |
|
178 | > # custom predicate to check registration of functions at loading | |
179 | > from mercurial import ( |
|
179 | > from mercurial import ( | |
180 | > smartset, |
|
180 | > smartset, | |
181 | > ) |
|
181 | > ) | |
182 | > @eh.revsetpredicate(bytesname, safe=True) # safe=True for query via hgweb |
|
182 | > @eh.revsetpredicate(bytesname, safe=True) # safe=True for query via hgweb | |
183 | > def custompredicate(repo, subset, x): |
|
183 | > def custompredicate(repo, subset, x): | |
184 | > return smartset.baseset([r for r in subset if r in {0}]) |
|
184 | > return smartset.baseset([r for r in subset if r in {0}]) | |
185 | > EOF |
|
185 | > EOF | |
186 | $ "$PYTHON" $TESTTMP/unflush.py foo.py |
|
186 | $ "$PYTHON" $TESTTMP/unflush.py foo.py | |
187 |
|
187 | |||
188 | $ cp foo.py bar.py |
|
188 | $ cp foo.py bar.py | |
189 | $ echo 'foo = foo.py' >> $HGRCPATH |
|
189 | $ echo 'foo = foo.py' >> $HGRCPATH | |
190 | $ echo 'bar = bar.py' >> $HGRCPATH |
|
190 | $ echo 'bar = bar.py' >> $HGRCPATH | |
191 |
|
191 | |||
192 | Check normal command's load order of extensions and registration of functions |
|
192 | Check normal command's load order of extensions and registration of functions | |
193 |
|
193 | |||
194 | $ hg log -r "foo() and bar()" -q |
|
194 | $ hg log -r "foo() and bar()" -q | |
195 | 1) foo imported |
|
195 | 1) foo imported | |
196 | 1) bar imported |
|
196 | 1) bar imported | |
197 | 2) foo uisetup |
|
197 | 2) foo uisetup | |
198 | 2) bar uisetup |
|
198 | 2) bar uisetup | |
199 | 3) foo extsetup |
|
199 | 3) foo extsetup | |
200 | 3) bar extsetup |
|
200 | 3) bar extsetup | |
201 | 4) foo uipopulate |
|
201 | 4) foo uipopulate | |
202 | 4) bar uipopulate |
|
202 | 4) bar uipopulate | |
203 | 4) foo uipopulate |
|
203 | 4) foo uipopulate | |
204 | 4) bar uipopulate |
|
204 | 4) bar uipopulate | |
205 | 4) foo uipopulate |
|
205 | 4) foo uipopulate | |
206 | 4) bar uipopulate |
|
206 | 4) bar uipopulate | |
207 | 5) foo reposetup |
|
207 | 5) foo reposetup | |
208 | 5) bar reposetup |
|
208 | 5) bar reposetup | |
209 | 0:c24b9ac61126 |
|
209 | 0:c24b9ac61126 | |
210 |
|
210 | |||
211 | Check hgweb's load order of extensions and registration of functions |
|
211 | Check hgweb's load order of extensions and registration of functions | |
212 |
|
212 | |||
213 | $ cat > hgweb.cgi <<EOF |
|
213 | $ cat > hgweb.cgi <<EOF | |
214 | > #!$PYTHON |
|
214 | > #!$PYTHON | |
215 | > from mercurial import demandimport; demandimport.enable() |
|
215 | > from mercurial import demandimport; demandimport.enable() | |
216 | > from mercurial.hgweb import hgweb |
|
216 | > from mercurial.hgweb import hgweb | |
217 | > from mercurial.hgweb import wsgicgi |
|
217 | > from mercurial.hgweb import wsgicgi | |
218 | > application = hgweb(b'.', b'test repo') |
|
218 | > application = hgweb(b'.', b'test repo') | |
219 | > wsgicgi.launch(application) |
|
219 | > wsgicgi.launch(application) | |
220 | > EOF |
|
220 | > EOF | |
221 | $ . "$TESTDIR/cgienv" |
|
221 | $ . "$TESTDIR/cgienv" | |
222 |
|
222 | |||
223 | $ PATH_INFO='/' SCRIPT_NAME='' "$PYTHON" hgweb.cgi \ |
|
223 | $ PATH_INFO='/' SCRIPT_NAME='' "$PYTHON" hgweb.cgi \ | |
224 | > | grep '^[0-9]) ' # ignores HTML output |
|
224 | > | grep '^[0-9]) ' # ignores HTML output | |
225 | 1) foo imported |
|
225 | 1) foo imported | |
226 | 1) bar imported |
|
226 | 1) bar imported | |
227 | 2) foo uisetup |
|
227 | 2) foo uisetup | |
228 | 2) bar uisetup |
|
228 | 2) bar uisetup | |
229 | 3) foo extsetup |
|
229 | 3) foo extsetup | |
230 | 3) bar extsetup |
|
230 | 3) bar extsetup | |
231 | 4) foo uipopulate |
|
231 | 4) foo uipopulate | |
232 | 4) bar uipopulate |
|
232 | 4) bar uipopulate | |
233 | 4) foo uipopulate |
|
233 | 4) foo uipopulate | |
234 | 4) bar uipopulate |
|
234 | 4) bar uipopulate | |
235 | 5) foo reposetup |
|
235 | 5) foo reposetup | |
236 | 5) bar reposetup |
|
236 | 5) bar reposetup | |
237 |
|
237 | |||
238 | (check that revset predicate foo() and bar() are available) |
|
238 | (check that revset predicate foo() and bar() are available) | |
239 |
|
239 | |||
240 | #if msys |
|
240 | #if msys | |
241 | $ PATH_INFO='//shortlog' |
|
241 | $ PATH_INFO='//shortlog' | |
242 | #else |
|
242 | #else | |
243 | $ PATH_INFO='/shortlog' |
|
243 | $ PATH_INFO='/shortlog' | |
244 | #endif |
|
244 | #endif | |
245 | $ export PATH_INFO |
|
245 | $ export PATH_INFO | |
246 | $ SCRIPT_NAME='' QUERY_STRING='rev=foo() and bar()' "$PYTHON" hgweb.cgi \ |
|
246 | $ SCRIPT_NAME='' QUERY_STRING='rev=foo() and bar()' "$PYTHON" hgweb.cgi \ | |
247 | > | grep '<a href="/rev/[0-9a-z]*">' |
|
247 | > | grep '<a href="/rev/[0-9a-z]*">' | |
248 | <a href="/rev/c24b9ac61126">add file</a> |
|
248 | <a href="/rev/c24b9ac61126">add file</a> | |
249 |
|
249 | |||
250 | $ echo 'foo = !' >> $HGRCPATH |
|
250 | $ echo 'foo = !' >> $HGRCPATH | |
251 | $ echo 'bar = !' >> $HGRCPATH |
|
251 | $ echo 'bar = !' >> $HGRCPATH | |
252 |
|
252 | |||
253 | Check "from __future__ import absolute_import" support for external libraries |
|
253 | Check "from __future__ import absolute_import" support for external libraries | |
254 |
|
254 | |||
255 | (import-checker.py reports issues for some of heredoc python code |
|
255 | (import-checker.py reports issues for some of heredoc python code | |
256 | fragments below, because import-checker.py does not know test specific |
|
256 | fragments below, because import-checker.py does not know test specific | |
257 | package hierarchy. NO_CHECK_* should be used as a limit mark of |
|
257 | package hierarchy. NO_CHECK_* should be used as a limit mark of | |
258 | heredoc, in order to make import-checker.py ignore them. For |
|
258 | heredoc, in order to make import-checker.py ignore them. For | |
259 | simplicity, all python code fragments below are generated with such |
|
259 | simplicity, all python code fragments below are generated with such | |
260 | limit mark, regardless of importing module or not.) |
|
260 | limit mark, regardless of importing module or not.) | |
261 |
|
261 | |||
262 | #if windows |
|
262 | #if windows | |
263 | $ PATHSEP=";" |
|
263 | $ PATHSEP=";" | |
264 | #else |
|
264 | #else | |
265 | $ PATHSEP=":" |
|
265 | $ PATHSEP=":" | |
266 | #endif |
|
266 | #endif | |
267 | $ export PATHSEP |
|
267 | $ export PATHSEP | |
268 |
|
268 | |||
269 | $ mkdir $TESTTMP/libroot |
|
269 | $ mkdir $TESTTMP/libroot | |
270 | $ echo "s = 'libroot/ambig.py'" > $TESTTMP/libroot/ambig.py |
|
270 | $ echo "s = 'libroot/ambig.py'" > $TESTTMP/libroot/ambig.py | |
271 | $ mkdir $TESTTMP/libroot/mod |
|
271 | $ mkdir $TESTTMP/libroot/mod | |
272 | $ touch $TESTTMP/libroot/mod/__init__.py |
|
272 | $ touch $TESTTMP/libroot/mod/__init__.py | |
273 | $ echo "s = 'libroot/mod/ambig.py'" > $TESTTMP/libroot/mod/ambig.py |
|
273 | $ echo "s = 'libroot/mod/ambig.py'" > $TESTTMP/libroot/mod/ambig.py | |
274 |
|
274 | |||
275 | $ cat > $TESTTMP/libroot/mod/ambigabs.py <<NO_CHECK_EOF |
|
275 | $ cat > $TESTTMP/libroot/mod/ambigabs.py <<NO_CHECK_EOF | |
276 | > from __future__ import absolute_import, print_function |
|
276 | > from __future__ import absolute_import, print_function | |
277 | > import ambig # should load "libroot/ambig.py" |
|
277 | > import ambig # should load "libroot/ambig.py" | |
278 | > s = ambig.s |
|
278 | > s = ambig.s | |
279 | > NO_CHECK_EOF |
|
279 | > NO_CHECK_EOF | |
280 | $ cat > loadabs.py <<NO_CHECK_EOF |
|
280 | $ cat > loadabs.py <<NO_CHECK_EOF | |
281 | > import mod.ambigabs as ambigabs |
|
281 | > import mod.ambigabs as ambigabs | |
282 | > def extsetup(ui): |
|
282 | > def extsetup(ui): | |
283 | > print('ambigabs.s=%s' % ambigabs.s, flush=True) |
|
283 | > print('ambigabs.s=%s' % ambigabs.s, flush=True) | |
284 | > NO_CHECK_EOF |
|
284 | > NO_CHECK_EOF | |
285 | $ "$PYTHON" $TESTTMP/unflush.py loadabs.py |
|
285 | $ "$PYTHON" $TESTTMP/unflush.py loadabs.py | |
286 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadabs=loadabs.py root) |
|
286 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadabs=loadabs.py root) | |
287 | ambigabs.s=libroot/ambig.py |
|
287 | ambigabs.s=libroot/ambig.py | |
288 | $TESTTMP/a |
|
288 | $TESTTMP/a | |
289 |
|
289 | |||
290 | #if no-py3 |
|
290 | #if no-py3 | |
291 | $ cat > $TESTTMP/libroot/mod/ambigrel.py <<NO_CHECK_EOF |
|
291 | $ cat > $TESTTMP/libroot/mod/ambigrel.py <<NO_CHECK_EOF | |
292 | > from __future__ import print_function |
|
292 | > from __future__ import print_function | |
293 | > import ambig # should load "libroot/mod/ambig.py" |
|
293 | > import ambig # should load "libroot/mod/ambig.py" | |
294 | > s = ambig.s |
|
294 | > s = ambig.s | |
295 | > NO_CHECK_EOF |
|
295 | > NO_CHECK_EOF | |
296 | $ cat > loadrel.py <<NO_CHECK_EOF |
|
296 | $ cat > loadrel.py <<NO_CHECK_EOF | |
297 | > import mod.ambigrel as ambigrel |
|
297 | > import mod.ambigrel as ambigrel | |
298 | > def extsetup(ui): |
|
298 | > def extsetup(ui): | |
299 | > print('ambigrel.s=%s' % ambigrel.s, flush=True) |
|
299 | > print('ambigrel.s=%s' % ambigrel.s, flush=True) | |
300 | > NO_CHECK_EOF |
|
300 | > NO_CHECK_EOF | |
301 | $ "$PYTHON" $TESTTMP/unflush.py loadrel.py |
|
301 | $ "$PYTHON" $TESTTMP/unflush.py loadrel.py | |
302 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadrel=loadrel.py root) |
|
302 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadrel=loadrel.py root) | |
303 | ambigrel.s=libroot/mod/ambig.py |
|
303 | ambigrel.s=libroot/mod/ambig.py | |
304 | $TESTTMP/a |
|
304 | $TESTTMP/a | |
305 | #endif |
|
305 | #endif | |
306 |
|
306 | |||
307 | Check absolute/relative import of extension specific modules |
|
307 | Check absolute/relative import of extension specific modules | |
308 |
|
308 | |||
309 | $ mkdir $TESTTMP/extroot |
|
309 | $ mkdir $TESTTMP/extroot | |
310 | $ cat > $TESTTMP/extroot/bar.py <<NO_CHECK_EOF |
|
310 | $ cat > $TESTTMP/extroot/bar.py <<NO_CHECK_EOF | |
311 | > s = b'this is extroot.bar' |
|
311 | > s = b'this is extroot.bar' | |
312 | > NO_CHECK_EOF |
|
312 | > NO_CHECK_EOF | |
313 | $ mkdir $TESTTMP/extroot/sub1 |
|
313 | $ mkdir $TESTTMP/extroot/sub1 | |
314 | $ cat > $TESTTMP/extroot/sub1/__init__.py <<NO_CHECK_EOF |
|
314 | $ cat > $TESTTMP/extroot/sub1/__init__.py <<NO_CHECK_EOF | |
315 | > s = b'this is extroot.sub1.__init__' |
|
315 | > s = b'this is extroot.sub1.__init__' | |
316 | > NO_CHECK_EOF |
|
316 | > NO_CHECK_EOF | |
317 | $ cat > $TESTTMP/extroot/sub1/baz.py <<NO_CHECK_EOF |
|
317 | $ cat > $TESTTMP/extroot/sub1/baz.py <<NO_CHECK_EOF | |
318 | > s = b'this is extroot.sub1.baz' |
|
318 | > s = b'this is extroot.sub1.baz' | |
319 | > NO_CHECK_EOF |
|
319 | > NO_CHECK_EOF | |
320 | $ cat > $TESTTMP/extroot/__init__.py <<NO_CHECK_EOF |
|
320 | $ cat > $TESTTMP/extroot/__init__.py <<NO_CHECK_EOF | |
321 | > from __future__ import absolute_import |
|
321 | > from __future__ import absolute_import | |
322 | > s = b'this is extroot.__init__' |
|
322 | > s = b'this is extroot.__init__' | |
323 | > from . import foo |
|
323 | > from . import foo | |
324 | > def extsetup(ui): |
|
324 | > def extsetup(ui): | |
325 | > ui.write(b'(extroot) ', foo.func(), b'\n') |
|
325 | > ui.write(b'(extroot) ', foo.func(), b'\n') | |
326 | > ui.flush() |
|
326 | > ui.flush() | |
327 | > NO_CHECK_EOF |
|
327 | > NO_CHECK_EOF | |
328 |
|
328 | |||
329 | $ cat > $TESTTMP/extroot/foo.py <<NO_CHECK_EOF |
|
329 | $ cat > $TESTTMP/extroot/foo.py <<NO_CHECK_EOF | |
330 | > # test absolute import |
|
330 | > # test absolute import | |
331 | > buf = [] |
|
331 | > buf = [] | |
332 | > def func(): |
|
332 | > def func(): | |
333 | > # "not locals" case |
|
333 | > # "not locals" case | |
334 | > import extroot.bar |
|
334 | > import extroot.bar | |
335 | > buf.append(b'import extroot.bar in func(): %s' % extroot.bar.s) |
|
335 | > buf.append(b'import extroot.bar in func(): %s' % extroot.bar.s) | |
336 | > return b'\n(extroot) '.join(buf) |
|
336 | > return b'\n(extroot) '.join(buf) | |
337 | > # b"fromlist == ('*',)" case |
|
337 | > # b"fromlist == ('*',)" case | |
338 | > from extroot.bar import * |
|
338 | > from extroot.bar import * | |
339 | > buf.append(b'from extroot.bar import *: %s' % s) |
|
339 | > buf.append(b'from extroot.bar import *: %s' % s) | |
340 | > # "not fromlist" and "if '.' in name" case |
|
340 | > # "not fromlist" and "if '.' in name" case | |
341 | > import extroot.sub1.baz |
|
341 | > import extroot.sub1.baz | |
342 | > buf.append(b'import extroot.sub1.baz: %s' % extroot.sub1.baz.s) |
|
342 | > buf.append(b'import extroot.sub1.baz: %s' % extroot.sub1.baz.s) | |
343 | > # "not fromlist" and NOT "if '.' in name" case |
|
343 | > # "not fromlist" and NOT "if '.' in name" case | |
344 | > import extroot |
|
344 | > import extroot | |
345 | > buf.append(b'import extroot: %s' % extroot.s) |
|
345 | > buf.append(b'import extroot: %s' % extroot.s) | |
346 | > # NOT "not fromlist" and NOT "level != -1" case |
|
346 | > # NOT "not fromlist" and NOT "level != -1" case | |
347 | > from extroot.bar import s |
|
347 | > from extroot.bar import s | |
348 | > buf.append(b'from extroot.bar import s: %s' % s) |
|
348 | > buf.append(b'from extroot.bar import s: %s' % s) | |
349 | > NO_CHECK_EOF |
|
349 | > NO_CHECK_EOF | |
350 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.extroot=$TESTTMP/extroot root) |
|
350 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.extroot=$TESTTMP/extroot root) | |
351 | (extroot) from extroot.bar import *: this is extroot.bar |
|
351 | (extroot) from extroot.bar import *: this is extroot.bar | |
352 | (extroot) import extroot.sub1.baz: this is extroot.sub1.baz |
|
352 | (extroot) import extroot.sub1.baz: this is extroot.sub1.baz | |
353 | (extroot) import extroot: this is extroot.__init__ |
|
353 | (extroot) import extroot: this is extroot.__init__ | |
354 | (extroot) from extroot.bar import s: this is extroot.bar |
|
354 | (extroot) from extroot.bar import s: this is extroot.bar | |
355 | (extroot) import extroot.bar in func(): this is extroot.bar |
|
355 | (extroot) import extroot.bar in func(): this is extroot.bar | |
356 | $TESTTMP/a |
|
356 | $TESTTMP/a | |
357 |
|
357 | |||
358 | #if no-py3 |
|
358 | #if no-py3 | |
359 | $ rm "$TESTTMP"/extroot/foo.* |
|
359 | $ rm "$TESTTMP"/extroot/foo.* | |
360 | $ rm -Rf "$TESTTMP/extroot/__pycache__" |
|
360 | $ rm -Rf "$TESTTMP/extroot/__pycache__" | |
361 | $ cat > $TESTTMP/extroot/foo.py <<NO_CHECK_EOF |
|
361 | $ cat > $TESTTMP/extroot/foo.py <<NO_CHECK_EOF | |
362 | > # test relative import |
|
362 | > # test relative import | |
363 | > buf = [] |
|
363 | > buf = [] | |
364 | > def func(): |
|
364 | > def func(): | |
365 | > # "not locals" case |
|
365 | > # "not locals" case | |
366 | > import bar |
|
366 | > import bar | |
367 | > buf.append('import bar in func(): %s' % bar.s) |
|
367 | > buf.append('import bar in func(): %s' % bar.s) | |
368 | > return '\n(extroot) '.join(buf) |
|
368 | > return '\n(extroot) '.join(buf) | |
369 | > # "fromlist == ('*',)" case |
|
369 | > # "fromlist == ('*',)" case | |
370 | > from bar import * |
|
370 | > from bar import * | |
371 | > buf.append('from bar import *: %s' % s) |
|
371 | > buf.append('from bar import *: %s' % s) | |
372 | > # "not fromlist" and "if '.' in name" case |
|
372 | > # "not fromlist" and "if '.' in name" case | |
373 | > import sub1.baz |
|
373 | > import sub1.baz | |
374 | > buf.append('import sub1.baz: %s' % sub1.baz.s) |
|
374 | > buf.append('import sub1.baz: %s' % sub1.baz.s) | |
375 | > # "not fromlist" and NOT "if '.' in name" case |
|
375 | > # "not fromlist" and NOT "if '.' in name" case | |
376 | > import sub1 |
|
376 | > import sub1 | |
377 | > buf.append('import sub1: %s' % sub1.s) |
|
377 | > buf.append('import sub1: %s' % sub1.s) | |
378 | > # NOT "not fromlist" and NOT "level != -1" case |
|
378 | > # NOT "not fromlist" and NOT "level != -1" case | |
379 | > from bar import s |
|
379 | > from bar import s | |
380 | > buf.append('from bar import s: %s' % s) |
|
380 | > buf.append('from bar import s: %s' % s) | |
381 | > NO_CHECK_EOF |
|
381 | > NO_CHECK_EOF | |
382 | $ hg --config extensions.extroot=$TESTTMP/extroot root |
|
382 | $ hg --config extensions.extroot=$TESTTMP/extroot root | |
383 | (extroot) from bar import *: this is extroot.bar |
|
383 | (extroot) from bar import *: this is extroot.bar | |
384 | (extroot) import sub1.baz: this is extroot.sub1.baz |
|
384 | (extroot) import sub1.baz: this is extroot.sub1.baz | |
385 | (extroot) import sub1: this is extroot.sub1.__init__ |
|
385 | (extroot) import sub1: this is extroot.sub1.__init__ | |
386 | (extroot) from bar import s: this is extroot.bar |
|
386 | (extroot) from bar import s: this is extroot.bar | |
387 | (extroot) import bar in func(): this is extroot.bar |
|
387 | (extroot) import bar in func(): this is extroot.bar | |
388 | $TESTTMP/a |
|
388 | $TESTTMP/a | |
389 | #endif |
|
389 | #endif | |
390 |
|
390 | |||
391 | #if demandimport |
|
391 | #if demandimport | |
392 |
|
392 | |||
393 | Examine whether module loading is delayed until actual referring, even |
|
393 | Examine whether module loading is delayed until actual referring, even | |
394 | though module is imported with "absolute_import" feature. |
|
394 | though module is imported with "absolute_import" feature. | |
395 |
|
395 | |||
396 | Files below in each packages are used for described purpose: |
|
396 | Files below in each packages are used for described purpose: | |
397 |
|
397 | |||
398 | - "called": examine whether "from MODULE import ATTR" works correctly |
|
398 | - "called": examine whether "from MODULE import ATTR" works correctly | |
399 | - "unused": examine whether loading is delayed correctly |
|
399 | - "unused": examine whether loading is delayed correctly | |
400 | - "used": examine whether "from PACKAGE import MODULE" works correctly |
|
400 | - "used": examine whether "from PACKAGE import MODULE" works correctly | |
401 |
|
401 | |||
402 | Package hierarchy is needed to examine whether demand importing works |
|
402 | Package hierarchy is needed to examine whether demand importing works | |
403 | as expected for "from SUB.PACK.AGE import MODULE". |
|
403 | as expected for "from SUB.PACK.AGE import MODULE". | |
404 |
|
404 | |||
405 | Setup "external library" to be imported with "absolute_import" |
|
405 | Setup "external library" to be imported with "absolute_import" | |
406 | feature. |
|
406 | feature. | |
407 |
|
407 | |||
408 | $ mkdir -p $TESTTMP/extlibroot/lsub1/lsub2 |
|
408 | $ mkdir -p $TESTTMP/extlibroot/lsub1/lsub2 | |
409 | $ touch $TESTTMP/extlibroot/__init__.py |
|
409 | $ touch $TESTTMP/extlibroot/__init__.py | |
410 | $ touch $TESTTMP/extlibroot/lsub1/__init__.py |
|
410 | $ touch $TESTTMP/extlibroot/lsub1/__init__.py | |
411 | $ touch $TESTTMP/extlibroot/lsub1/lsub2/__init__.py |
|
411 | $ touch $TESTTMP/extlibroot/lsub1/lsub2/__init__.py | |
412 |
|
412 | |||
413 | $ cat > $TESTTMP/extlibroot/lsub1/lsub2/called.py <<NO_CHECK_EOF |
|
413 | $ cat > $TESTTMP/extlibroot/lsub1/lsub2/called.py <<NO_CHECK_EOF | |
414 | > def func(): |
|
414 | > def func(): | |
415 | > return b"this is extlibroot.lsub1.lsub2.called.func()" |
|
415 | > return b"this is extlibroot.lsub1.lsub2.called.func()" | |
416 | > NO_CHECK_EOF |
|
416 | > NO_CHECK_EOF | |
417 | $ cat > $TESTTMP/extlibroot/lsub1/lsub2/unused.py <<NO_CHECK_EOF |
|
417 | $ cat > $TESTTMP/extlibroot/lsub1/lsub2/unused.py <<NO_CHECK_EOF | |
418 | > raise Exception("extlibroot.lsub1.lsub2.unused is loaded unintentionally") |
|
418 | > raise Exception("extlibroot.lsub1.lsub2.unused is loaded unintentionally") | |
419 | > NO_CHECK_EOF |
|
419 | > NO_CHECK_EOF | |
420 | $ cat > $TESTTMP/extlibroot/lsub1/lsub2/used.py <<NO_CHECK_EOF |
|
420 | $ cat > $TESTTMP/extlibroot/lsub1/lsub2/used.py <<NO_CHECK_EOF | |
421 | > detail = b"this is extlibroot.lsub1.lsub2.used" |
|
421 | > detail = b"this is extlibroot.lsub1.lsub2.used" | |
422 | > NO_CHECK_EOF |
|
422 | > NO_CHECK_EOF | |
423 |
|
423 | |||
424 | Setup sub-package of "external library", which causes instantiation of |
|
424 | Setup sub-package of "external library", which causes instantiation of | |
425 | demandmod in "recurse down the module chain" code path. Relative |
|
425 | demandmod in "recurse down the module chain" code path. Relative | |
426 | importing with "absolute_import" feature isn't tested, because "level |
|
426 | importing with "absolute_import" feature isn't tested, because "level | |
427 | >=1 " doesn't cause instantiation of demandmod. |
|
427 | >=1 " doesn't cause instantiation of demandmod. | |
428 |
|
428 | |||
429 | $ mkdir -p $TESTTMP/extlibroot/recursedown/abs |
|
429 | $ mkdir -p $TESTTMP/extlibroot/recursedown/abs | |
430 | $ cat > $TESTTMP/extlibroot/recursedown/abs/used.py <<NO_CHECK_EOF |
|
430 | $ cat > $TESTTMP/extlibroot/recursedown/abs/used.py <<NO_CHECK_EOF | |
431 | > detail = b"this is extlibroot.recursedown.abs.used" |
|
431 | > detail = b"this is extlibroot.recursedown.abs.used" | |
432 | > NO_CHECK_EOF |
|
432 | > NO_CHECK_EOF | |
433 | $ cat > $TESTTMP/extlibroot/recursedown/abs/__init__.py <<NO_CHECK_EOF |
|
433 | $ cat > $TESTTMP/extlibroot/recursedown/abs/__init__.py <<NO_CHECK_EOF | |
434 | > from __future__ import absolute_import |
|
434 | > from __future__ import absolute_import | |
435 | > from extlibroot.recursedown.abs.used import detail |
|
435 | > from extlibroot.recursedown.abs.used import detail | |
436 | > NO_CHECK_EOF |
|
436 | > NO_CHECK_EOF | |
437 |
|
437 | |||
438 | $ mkdir -p $TESTTMP/extlibroot/recursedown/legacy |
|
438 | $ mkdir -p $TESTTMP/extlibroot/recursedown/legacy | |
439 | $ cat > $TESTTMP/extlibroot/recursedown/legacy/used.py <<NO_CHECK_EOF |
|
439 | $ cat > $TESTTMP/extlibroot/recursedown/legacy/used.py <<NO_CHECK_EOF | |
440 | > detail = b"this is extlibroot.recursedown.legacy.used" |
|
440 | > detail = b"this is extlibroot.recursedown.legacy.used" | |
441 | > NO_CHECK_EOF |
|
441 | > NO_CHECK_EOF | |
442 | $ cat > $TESTTMP/extlibroot/recursedown/legacy/__init__.py <<NO_CHECK_EOF |
|
442 | $ cat > $TESTTMP/extlibroot/recursedown/legacy/__init__.py <<NO_CHECK_EOF | |
443 | > # legacy style (level == -1) import |
|
443 | > # legacy style (level == -1) import | |
444 | > from extlibroot.recursedown.legacy.used import detail |
|
444 | > from extlibroot.recursedown.legacy.used import detail | |
445 | > NO_CHECK_EOF |
|
445 | > NO_CHECK_EOF | |
446 |
|
446 | |||
447 | $ cat > $TESTTMP/extlibroot/recursedown/__init__.py <<NO_CHECK_EOF |
|
447 | $ cat > $TESTTMP/extlibroot/recursedown/__init__.py <<NO_CHECK_EOF | |
448 | > from __future__ import absolute_import |
|
448 | > from __future__ import absolute_import | |
449 | > from extlibroot.recursedown.abs import detail as absdetail |
|
449 | > from extlibroot.recursedown.abs import detail as absdetail | |
450 | > from .legacy import detail as legacydetail |
|
450 | > from .legacy import detail as legacydetail | |
451 | > NO_CHECK_EOF |
|
451 | > NO_CHECK_EOF | |
452 |
|
452 | |||
453 | Setup package that re-exports an attribute of its submodule as the same |
|
453 | Setup package that re-exports an attribute of its submodule as the same | |
454 | name. This leaves 'shadowing.used' pointing to 'used.detail', but still |
|
454 | name. This leaves 'shadowing.used' pointing to 'used.detail', but still | |
455 | the submodule 'used' should be somehow accessible. (issue5617) |
|
455 | the submodule 'used' should be somehow accessible. (issue5617) | |
456 |
|
456 | |||
457 | $ mkdir -p $TESTTMP/extlibroot/shadowing |
|
457 | $ mkdir -p $TESTTMP/extlibroot/shadowing | |
458 | $ cat > $TESTTMP/extlibroot/shadowing/used.py <<NO_CHECK_EOF |
|
458 | $ cat > $TESTTMP/extlibroot/shadowing/used.py <<NO_CHECK_EOF | |
459 | > detail = b"this is extlibroot.shadowing.used" |
|
459 | > detail = b"this is extlibroot.shadowing.used" | |
460 | > NO_CHECK_EOF |
|
460 | > NO_CHECK_EOF | |
461 | $ cat > $TESTTMP/extlibroot/shadowing/proxied.py <<NO_CHECK_EOF |
|
461 | $ cat > $TESTTMP/extlibroot/shadowing/proxied.py <<NO_CHECK_EOF | |
462 | > from __future__ import absolute_import |
|
462 | > from __future__ import absolute_import | |
463 | > from extlibroot.shadowing.used import detail |
|
463 | > from extlibroot.shadowing.used import detail | |
464 | > NO_CHECK_EOF |
|
464 | > NO_CHECK_EOF | |
465 | $ cat > $TESTTMP/extlibroot/shadowing/__init__.py <<NO_CHECK_EOF |
|
465 | $ cat > $TESTTMP/extlibroot/shadowing/__init__.py <<NO_CHECK_EOF | |
466 | > from __future__ import absolute_import |
|
466 | > from __future__ import absolute_import | |
467 | > from .used import detail as used |
|
467 | > from .used import detail as used | |
468 | > NO_CHECK_EOF |
|
468 | > NO_CHECK_EOF | |
469 |
|
469 | |||
470 | Setup extension local modules to be imported with "absolute_import" |
|
470 | Setup extension local modules to be imported with "absolute_import" | |
471 | feature. |
|
471 | feature. | |
472 |
|
472 | |||
473 | $ mkdir -p $TESTTMP/absextroot/xsub1/xsub2 |
|
473 | $ mkdir -p $TESTTMP/absextroot/xsub1/xsub2 | |
474 | $ touch $TESTTMP/absextroot/xsub1/__init__.py |
|
474 | $ touch $TESTTMP/absextroot/xsub1/__init__.py | |
475 | $ touch $TESTTMP/absextroot/xsub1/xsub2/__init__.py |
|
475 | $ touch $TESTTMP/absextroot/xsub1/xsub2/__init__.py | |
476 |
|
476 | |||
477 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/called.py <<NO_CHECK_EOF |
|
477 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/called.py <<NO_CHECK_EOF | |
478 | > def func(): |
|
478 | > def func(): | |
479 | > return b"this is absextroot.xsub1.xsub2.called.func()" |
|
479 | > return b"this is absextroot.xsub1.xsub2.called.func()" | |
480 | > NO_CHECK_EOF |
|
480 | > NO_CHECK_EOF | |
481 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/unused.py <<NO_CHECK_EOF |
|
481 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/unused.py <<NO_CHECK_EOF | |
482 | > raise Exception("absextroot.xsub1.xsub2.unused is loaded unintentionally") |
|
482 | > raise Exception("absextroot.xsub1.xsub2.unused is loaded unintentionally") | |
483 | > NO_CHECK_EOF |
|
483 | > NO_CHECK_EOF | |
484 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/used.py <<NO_CHECK_EOF |
|
484 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/used.py <<NO_CHECK_EOF | |
485 | > detail = b"this is absextroot.xsub1.xsub2.used" |
|
485 | > detail = b"this is absextroot.xsub1.xsub2.used" | |
486 | > NO_CHECK_EOF |
|
486 | > NO_CHECK_EOF | |
487 |
|
487 | |||
488 | Setup extension local modules to examine whether demand importing |
|
488 | Setup extension local modules to examine whether demand importing | |
489 | works as expected in "level > 1" case. |
|
489 | works as expected in "level > 1" case. | |
490 |
|
490 | |||
491 | $ cat > $TESTTMP/absextroot/relimportee.py <<NO_CHECK_EOF |
|
491 | $ cat > $TESTTMP/absextroot/relimportee.py <<NO_CHECK_EOF | |
492 | > detail = b"this is absextroot.relimportee" |
|
492 | > detail = b"this is absextroot.relimportee" | |
493 | > NO_CHECK_EOF |
|
493 | > NO_CHECK_EOF | |
494 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/relimporter.py <<NO_CHECK_EOF |
|
494 | $ cat > $TESTTMP/absextroot/xsub1/xsub2/relimporter.py <<NO_CHECK_EOF | |
495 | > from __future__ import absolute_import |
|
495 | > from __future__ import absolute_import | |
496 | > from mercurial import pycompat |
|
496 | > from mercurial import pycompat | |
497 | > from ... import relimportee |
|
497 | > from ... import relimportee | |
498 | > detail = b"this relimporter imports %r" % ( |
|
498 | > detail = b"this relimporter imports %r" % ( | |
499 | > pycompat.bytestr(relimportee.detail)) |
|
499 | > pycompat.bytestr(relimportee.detail)) | |
500 | > NO_CHECK_EOF |
|
500 | > NO_CHECK_EOF | |
501 |
|
501 | |||
502 | Setup modules, which actually import extension local modules at |
|
502 | Setup modules, which actually import extension local modules at | |
503 | runtime. |
|
503 | runtime. | |
504 |
|
504 | |||
505 | $ cat > $TESTTMP/absextroot/absolute.py << NO_CHECK_EOF |
|
505 | $ cat > $TESTTMP/absextroot/absolute.py << NO_CHECK_EOF | |
506 | > from __future__ import absolute_import |
|
506 | > from __future__ import absolute_import | |
507 | > |
|
507 | > | |
508 | > # import extension local modules absolutely (level = 0) |
|
508 | > # import extension local modules absolutely (level = 0) | |
509 | > from absextroot.xsub1.xsub2 import used, unused |
|
509 | > from absextroot.xsub1.xsub2 import used, unused | |
510 | > from absextroot.xsub1.xsub2.called import func |
|
510 | > from absextroot.xsub1.xsub2.called import func | |
511 | > |
|
511 | > | |
512 | > def getresult(): |
|
512 | > def getresult(): | |
513 | > result = [] |
|
513 | > result = [] | |
514 | > result.append(used.detail) |
|
514 | > result.append(used.detail) | |
515 | > result.append(func()) |
|
515 | > result.append(func()) | |
516 | > return result |
|
516 | > return result | |
517 | > NO_CHECK_EOF |
|
517 | > NO_CHECK_EOF | |
518 |
|
518 | |||
519 | $ cat > $TESTTMP/absextroot/relative.py << NO_CHECK_EOF |
|
519 | $ cat > $TESTTMP/absextroot/relative.py << NO_CHECK_EOF | |
520 | > from __future__ import absolute_import |
|
520 | > from __future__ import absolute_import | |
521 | > |
|
521 | > | |
522 | > # import extension local modules relatively (level == 1) |
|
522 | > # import extension local modules relatively (level == 1) | |
523 | > from .xsub1.xsub2 import used, unused |
|
523 | > from .xsub1.xsub2 import used, unused | |
524 | > from .xsub1.xsub2.called import func |
|
524 | > from .xsub1.xsub2.called import func | |
525 | > |
|
525 | > | |
526 | > # import a module, which implies "importing with level > 1" |
|
526 | > # import a module, which implies "importing with level > 1" | |
527 | > from .xsub1.xsub2 import relimporter |
|
527 | > from .xsub1.xsub2 import relimporter | |
528 | > |
|
528 | > | |
529 | > def getresult(): |
|
529 | > def getresult(): | |
530 | > result = [] |
|
530 | > result = [] | |
531 | > result.append(used.detail) |
|
531 | > result.append(used.detail) | |
532 | > result.append(func()) |
|
532 | > result.append(func()) | |
533 | > result.append(relimporter.detail) |
|
533 | > result.append(relimporter.detail) | |
534 | > return result |
|
534 | > return result | |
535 | > NO_CHECK_EOF |
|
535 | > NO_CHECK_EOF | |
536 |
|
536 | |||
537 | Setup main procedure of extension. |
|
537 | Setup main procedure of extension. | |
538 |
|
538 | |||
539 | $ cat > $TESTTMP/absextroot/__init__.py <<NO_CHECK_EOF |
|
539 | $ cat > $TESTTMP/absextroot/__init__.py <<NO_CHECK_EOF | |
540 | > from __future__ import absolute_import |
|
540 | > from __future__ import absolute_import | |
541 | > from mercurial import registrar |
|
541 | > from mercurial import registrar | |
542 | > cmdtable = {} |
|
542 | > cmdtable = {} | |
543 | > command = registrar.command(cmdtable) |
|
543 | > command = registrar.command(cmdtable) | |
544 | > |
|
544 | > | |
545 | > # "absolute" and "relative" shouldn't be imported before actual |
|
545 | > # "absolute" and "relative" shouldn't be imported before actual | |
546 | > # command execution, because (1) they import same modules, and (2) |
|
546 | > # command execution, because (1) they import same modules, and (2) | |
547 | > # preceding import (= instantiate "demandmod" object instead of |
|
547 | > # preceding import (= instantiate "demandmod" object instead of | |
548 | > # real "module" object) might hide problem of succeeding import. |
|
548 | > # real "module" object) might hide problem of succeeding import. | |
549 | > |
|
549 | > | |
550 | > @command(b'showabsolute', [], norepo=True) |
|
550 | > @command(b'showabsolute', [], norepo=True) | |
551 | > def showabsolute(ui, *args, **opts): |
|
551 | > def showabsolute(ui, *args, **opts): | |
552 | > from absextroot import absolute |
|
552 | > from absextroot import absolute | |
553 | > ui.write(b'ABS: %s\n' % b'\nABS: '.join(absolute.getresult())) |
|
553 | > ui.write(b'ABS: %s\n' % b'\nABS: '.join(absolute.getresult())) | |
554 | > |
|
554 | > | |
555 | > @command(b'showrelative', [], norepo=True) |
|
555 | > @command(b'showrelative', [], norepo=True) | |
556 | > def showrelative(ui, *args, **opts): |
|
556 | > def showrelative(ui, *args, **opts): | |
557 | > from . import relative |
|
557 | > from . import relative | |
558 | > ui.write(b'REL: %s\n' % b'\nREL: '.join(relative.getresult())) |
|
558 | > ui.write(b'REL: %s\n' % b'\nREL: '.join(relative.getresult())) | |
559 | > |
|
559 | > | |
560 | > # import modules from external library |
|
560 | > # import modules from external library | |
561 | > from extlibroot.lsub1.lsub2 import used as lused, unused as lunused |
|
561 | > from extlibroot.lsub1.lsub2 import used as lused, unused as lunused | |
562 | > from extlibroot.lsub1.lsub2.called import func as lfunc |
|
562 | > from extlibroot.lsub1.lsub2.called import func as lfunc | |
563 | > from extlibroot.recursedown import absdetail, legacydetail |
|
563 | > from extlibroot.recursedown import absdetail, legacydetail | |
564 | > from extlibroot.shadowing import proxied |
|
564 | > from extlibroot.shadowing import proxied | |
565 | > |
|
565 | > | |
566 | > def uisetup(ui): |
|
566 | > def uisetup(ui): | |
567 | > result = [] |
|
567 | > result = [] | |
568 | > result.append(lused.detail) |
|
568 | > result.append(lused.detail) | |
569 | > result.append(lfunc()) |
|
569 | > result.append(lfunc()) | |
570 | > result.append(absdetail) |
|
570 | > result.append(absdetail) | |
571 | > result.append(legacydetail) |
|
571 | > result.append(legacydetail) | |
572 | > result.append(proxied.detail) |
|
572 | > result.append(proxied.detail) | |
573 | > ui.write(b'LIB: %s\n' % b'\nLIB: '.join(result)) |
|
573 | > ui.write(b'LIB: %s\n' % b'\nLIB: '.join(result)) | |
574 | > NO_CHECK_EOF |
|
574 | > NO_CHECK_EOF | |
575 |
|
575 | |||
576 | Examine module importing. |
|
576 | Examine module importing. | |
577 |
|
577 | |||
578 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.absextroot=$TESTTMP/absextroot showabsolute) |
|
578 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.absextroot=$TESTTMP/absextroot showabsolute) | |
579 | LIB: this is extlibroot.lsub1.lsub2.used |
|
579 | LIB: this is extlibroot.lsub1.lsub2.used | |
580 | LIB: this is extlibroot.lsub1.lsub2.called.func() |
|
580 | LIB: this is extlibroot.lsub1.lsub2.called.func() | |
581 | LIB: this is extlibroot.recursedown.abs.used |
|
581 | LIB: this is extlibroot.recursedown.abs.used | |
582 | LIB: this is extlibroot.recursedown.legacy.used |
|
582 | LIB: this is extlibroot.recursedown.legacy.used | |
583 | LIB: this is extlibroot.shadowing.used |
|
583 | LIB: this is extlibroot.shadowing.used | |
584 | ABS: this is absextroot.xsub1.xsub2.used |
|
584 | ABS: this is absextroot.xsub1.xsub2.used | |
585 | ABS: this is absextroot.xsub1.xsub2.called.func() |
|
585 | ABS: this is absextroot.xsub1.xsub2.called.func() | |
586 |
|
586 | |||
587 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.absextroot=$TESTTMP/absextroot showrelative) |
|
587 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.absextroot=$TESTTMP/absextroot showrelative) | |
588 | LIB: this is extlibroot.lsub1.lsub2.used |
|
588 | LIB: this is extlibroot.lsub1.lsub2.used | |
589 | LIB: this is extlibroot.lsub1.lsub2.called.func() |
|
589 | LIB: this is extlibroot.lsub1.lsub2.called.func() | |
590 | LIB: this is extlibroot.recursedown.abs.used |
|
590 | LIB: this is extlibroot.recursedown.abs.used | |
591 | LIB: this is extlibroot.recursedown.legacy.used |
|
591 | LIB: this is extlibroot.recursedown.legacy.used | |
592 | LIB: this is extlibroot.shadowing.used |
|
592 | LIB: this is extlibroot.shadowing.used | |
593 | REL: this is absextroot.xsub1.xsub2.used |
|
593 | REL: this is absextroot.xsub1.xsub2.used | |
594 | REL: this is absextroot.xsub1.xsub2.called.func() |
|
594 | REL: this is absextroot.xsub1.xsub2.called.func() | |
595 | REL: this relimporter imports 'this is absextroot.relimportee' |
|
595 | REL: this relimporter imports 'this is absextroot.relimportee' | |
596 |
|
596 | |||
597 | Examine whether sub-module is imported relatively as expected. |
|
597 | Examine whether sub-module is imported relatively as expected. | |
598 |
|
598 | |||
599 | See also issue5208 for detail about example case on Python 3.x. |
|
599 | See also issue5208 for detail about example case on Python 3.x. | |
600 |
|
600 | |||
601 | $ f -q $TESTTMP/extlibroot/lsub1/lsub2/notexist.py |
|
601 | $ f -q $TESTTMP/extlibroot/lsub1/lsub2/notexist.py | |
602 | $TESTTMP/extlibroot/lsub1/lsub2/notexist.py: file not found |
|
602 | $TESTTMP/extlibroot/lsub1/lsub2/notexist.py: file not found | |
603 |
|
603 | |||
604 | $ cat > $TESTTMP/notexist.py <<NO_CHECK_EOF |
|
604 | $ cat > $TESTTMP/notexist.py <<NO_CHECK_EOF | |
605 | > text = 'notexist.py at root is loaded unintentionally\n' |
|
605 | > text = 'notexist.py at root is loaded unintentionally\n' | |
606 | > NO_CHECK_EOF |
|
606 | > NO_CHECK_EOF | |
607 |
|
607 | |||
608 | $ cat > $TESTTMP/checkrelativity.py <<NO_CHECK_EOF |
|
608 | $ cat > $TESTTMP/checkrelativity.py <<NO_CHECK_EOF | |
609 | > from mercurial import registrar |
|
609 | > from mercurial import registrar | |
610 | > cmdtable = {} |
|
610 | > cmdtable = {} | |
611 | > command = registrar.command(cmdtable) |
|
611 | > command = registrar.command(cmdtable) | |
612 | > |
|
612 | > | |
613 | > # demand import avoids failure of importing notexist here, but only on |
|
613 | > # demand import avoids failure of importing notexist here, but only on | |
614 | > # Python 2. |
|
614 | > # Python 2. | |
615 | > import extlibroot.lsub1.lsub2.notexist |
|
615 | > import extlibroot.lsub1.lsub2.notexist | |
616 | > |
|
616 | > | |
617 | > @command(b'checkrelativity', [], norepo=True) |
|
617 | > @command(b'checkrelativity', [], norepo=True) | |
618 | > def checkrelativity(ui, *args, **opts): |
|
618 | > def checkrelativity(ui, *args, **opts): | |
619 | > try: |
|
619 | > try: | |
620 | > ui.write(extlibroot.lsub1.lsub2.notexist.text) |
|
620 | > ui.write(extlibroot.lsub1.lsub2.notexist.text) | |
621 | > return 1 # unintentional success |
|
621 | > return 1 # unintentional success | |
622 | > except ImportError: |
|
622 | > except ImportError: | |
623 | > pass # intentional failure |
|
623 | > pass # intentional failure | |
624 | > NO_CHECK_EOF |
|
624 | > NO_CHECK_EOF | |
625 |
|
625 | |||
626 | Python 3's lazy importer verifies modules exist before returning the lazy |
|
626 | Python 3's lazy importer verifies modules exist before returning the lazy | |
627 | module stub. Our custom lazy importer for Python 2 always returns a stub. |
|
627 | module stub. Our custom lazy importer for Python 2 always returns a stub. | |
628 |
|
628 | |||
629 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.checkrelativity=$TESTTMP/checkrelativity.py checkrelativity) || true |
|
629 | $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.checkrelativity=$TESTTMP/checkrelativity.py checkrelativity) || true | |
630 | *** failed to import extension checkrelativity from $TESTTMP/checkrelativity.py: No module named 'extlibroot.lsub1.lsub2.notexist' (py3 !) |
|
630 | *** failed to import extension checkrelativity from $TESTTMP/checkrelativity.py: No module named 'extlibroot.lsub1.lsub2.notexist' (py3 !) | |
631 | hg: unknown command 'checkrelativity' (py3 !) |
|
631 | hg: unknown command 'checkrelativity' (py3 !) | |
632 | (use 'hg help' for a list of commands) (py3 !) |
|
632 | (use 'hg help' for a list of commands) (py3 !) | |
633 |
|
633 | |||
634 | #endif |
|
634 | #endif | |
635 |
|
635 | |||
636 | (Here, module importing tests are finished. Therefore, use other than |
|
636 | (Here, module importing tests are finished. Therefore, use other than | |
637 | NO_CHECK_* limit mark for heredoc python files, in order to apply |
|
637 | NO_CHECK_* limit mark for heredoc python files, in order to apply | |
638 | import-checker.py or so on their contents) |
|
638 | import-checker.py or so on their contents) | |
639 |
|
639 | |||
640 | Make sure a broken uisetup doesn't globally break hg: |
|
640 | Make sure a broken uisetup doesn't globally break hg: | |
641 | $ cat > $TESTTMP/baduisetup.py <<EOF |
|
641 | $ cat > $TESTTMP/baduisetup.py <<EOF | |
642 | > def uisetup(ui): |
|
642 | > def uisetup(ui): | |
643 | > 1 / 0 |
|
643 | > 1 / 0 | |
644 | > EOF |
|
644 | > EOF | |
645 |
|
645 | |||
646 | Even though the extension fails during uisetup, hg is still basically usable: |
|
646 | Even though the extension fails during uisetup, hg is still basically usable: | |
647 | $ hg --config extensions.baduisetup=$TESTTMP/baduisetup.py version |
|
647 | $ hg --config extensions.baduisetup=$TESTTMP/baduisetup.py version | |
648 | Traceback (most recent call last): |
|
648 | Traceback (most recent call last): | |
649 | File "*/mercurial/extensions.py", line *, in _runuisetup (glob) |
|
649 | File "*/mercurial/extensions.py", line *, in _runuisetup (glob) | |
650 | uisetup(ui) |
|
650 | uisetup(ui) | |
651 | File "$TESTTMP/baduisetup.py", line 2, in uisetup |
|
651 | File "$TESTTMP/baduisetup.py", line 2, in uisetup | |
652 | 1 / 0 |
|
652 | 1 / 0 | |
653 | ZeroDivisionError: * by zero (glob) |
|
653 | ZeroDivisionError: * by zero (glob) | |
654 | *** failed to set up extension baduisetup: * by zero (glob) |
|
654 | *** failed to set up extension baduisetup: * by zero (glob) | |
655 | Mercurial Distributed SCM (version *) (glob) |
|
655 | Mercurial Distributed SCM (version *) (glob) | |
656 | (see https://mercurial-scm.org for more information) |
|
656 | (see https://mercurial-scm.org for more information) | |
657 |
|
657 | |||
658 | Copyright (C) 2005-* Matt Mackall and others (glob) |
|
658 | Copyright (C) 2005-* Matt Mackall and others (glob) | |
659 | This is free software; see the source for copying conditions. There is NO |
|
659 | This is free software; see the source for copying conditions. There is NO | |
660 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
660 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
661 |
|
661 | |||
662 | $ cd .. |
|
662 | $ cd .. | |
663 |
|
663 | |||
664 | hide outer repo |
|
664 | hide outer repo | |
665 | $ hg init |
|
665 | $ hg init | |
666 |
|
666 | |||
667 | $ cat > empty.py <<EOF |
|
667 | $ cat > empty.py <<EOF | |
668 | > '''empty cmdtable |
|
668 | > '''empty cmdtable | |
669 | > ''' |
|
669 | > ''' | |
670 | > cmdtable = {} |
|
670 | > cmdtable = {} | |
671 | > EOF |
|
671 | > EOF | |
672 | $ emptypath=`pwd`/empty.py |
|
672 | $ emptypath=`pwd`/empty.py | |
673 | $ echo "empty = $emptypath" >> $HGRCPATH |
|
673 | $ echo "empty = $emptypath" >> $HGRCPATH | |
674 | $ hg help empty |
|
674 | $ hg help empty | |
675 | empty extension - empty cmdtable |
|
675 | empty extension - empty cmdtable | |
676 |
|
676 | |||
677 | no commands defined |
|
677 | no commands defined | |
678 |
|
678 | |||
679 |
|
679 | |||
680 | $ echo 'empty = !' >> $HGRCPATH |
|
680 | $ echo 'empty = !' >> $HGRCPATH | |
681 |
|
681 | |||
682 | $ cat > debugextension.py <<EOF |
|
682 | $ cat > debugextension.py <<EOF | |
683 | > '''only debugcommands |
|
683 | > '''only debugcommands | |
684 | > ''' |
|
684 | > ''' | |
685 | > from mercurial import registrar |
|
685 | > from mercurial import registrar | |
686 | > cmdtable = {} |
|
686 | > cmdtable = {} | |
687 | > command = registrar.command(cmdtable) |
|
687 | > command = registrar.command(cmdtable) | |
688 | > @command(b'debugfoobar', [], b'hg debugfoobar') |
|
688 | > @command(b'debugfoobar', [], b'hg debugfoobar') | |
689 | > def debugfoobar(ui, repo, *args, **opts): |
|
689 | > def debugfoobar(ui, repo, *args, **opts): | |
690 | > "yet another debug command" |
|
690 | > "yet another debug command" | |
691 | > @command(b'foo', [], b'hg foo') |
|
691 | > @command(b'foo', [], b'hg foo') | |
692 | > def foo(ui, repo, *args, **opts): |
|
692 | > def foo(ui, repo, *args, **opts): | |
693 | > """yet another foo command |
|
693 | > """yet another foo command | |
694 | > This command has been DEPRECATED since forever. |
|
694 | > This command has been DEPRECATED since forever. | |
695 | > """ |
|
695 | > """ | |
696 | > EOF |
|
696 | > EOF | |
697 | $ debugpath=`pwd`/debugextension.py |
|
697 | $ debugpath=`pwd`/debugextension.py | |
698 | $ echo "debugextension = $debugpath" >> $HGRCPATH |
|
698 | $ echo "debugextension = $debugpath" >> $HGRCPATH | |
699 |
|
699 | |||
700 | $ hg help debugextension |
|
700 | $ hg help debugextension | |
701 | hg debugextensions |
|
701 | hg debugextensions | |
702 |
|
702 | |||
703 | show information about active extensions |
|
703 | show information about active extensions | |
704 |
|
704 | |||
705 | options: |
|
705 | options: | |
706 |
|
706 | |||
707 | -T --template TEMPLATE display with template |
|
707 | -T --template TEMPLATE display with template | |
708 |
|
708 | |||
709 | (some details hidden, use --verbose to show complete help) |
|
709 | (some details hidden, use --verbose to show complete help) | |
710 |
|
710 | |||
711 |
|
711 | |||
712 | $ hg --verbose help debugextension |
|
712 | $ hg --verbose help debugextension | |
713 | hg debugextensions |
|
713 | hg debugextensions | |
714 |
|
714 | |||
715 | show information about active extensions |
|
715 | show information about active extensions | |
716 |
|
716 | |||
717 | options: |
|
717 | options: | |
718 |
|
718 | |||
719 | -T --template TEMPLATE display with template |
|
719 | -T --template TEMPLATE display with template | |
720 |
|
720 | |||
721 | global options ([+] can be repeated): |
|
721 | global options ([+] can be repeated): | |
722 |
|
722 | |||
723 | -R --repository REPO repository root directory or name of overlay bundle |
|
723 | -R --repository REPO repository root directory or name of overlay bundle | |
724 | file |
|
724 | file | |
725 | --cwd DIR change working directory |
|
725 | --cwd DIR change working directory | |
726 | -y --noninteractive do not prompt, automatically pick the first choice for |
|
726 | -y --noninteractive do not prompt, automatically pick the first choice for | |
727 | all prompts |
|
727 | all prompts | |
728 | -q --quiet suppress output |
|
728 | -q --quiet suppress output | |
729 | -v --verbose enable additional output |
|
729 | -v --verbose enable additional output | |
730 | --color TYPE when to colorize (boolean, always, auto, never, or |
|
730 | --color TYPE when to colorize (boolean, always, auto, never, or | |
731 | debug) |
|
731 | debug) | |
732 | --config CONFIG [+] set/override config option (use 'section.name=value') |
|
732 | --config CONFIG [+] set/override config option (use 'section.name=value') | |
733 | --debug enable debugging output |
|
733 | --debug enable debugging output | |
734 | --debugger start debugger |
|
734 | --debugger start debugger | |
735 | --encoding ENCODE set the charset encoding (default: ascii) |
|
735 | --encoding ENCODE set the charset encoding (default: ascii) | |
736 | --encodingmode MODE set the charset encoding mode (default: strict) |
|
736 | --encodingmode MODE set the charset encoding mode (default: strict) | |
737 | --traceback always print a traceback on exception |
|
737 | --traceback always print a traceback on exception | |
738 | --time time how long the command takes |
|
738 | --time time how long the command takes | |
739 | --profile print command execution profile |
|
739 | --profile print command execution profile | |
740 | --version output version information and exit |
|
740 | --version output version information and exit | |
741 | -h --help display help and exit |
|
741 | -h --help display help and exit | |
742 | --hidden consider hidden changesets |
|
742 | --hidden consider hidden changesets | |
743 | --pager TYPE when to paginate (boolean, always, auto, or never) |
|
743 | --pager TYPE when to paginate (boolean, always, auto, or never) | |
744 | (default: auto) |
|
744 | (default: auto) | |
745 |
|
745 | |||
746 |
|
746 | |||
747 |
|
747 | |||
748 |
|
748 | |||
749 |
|
749 | |||
750 |
|
750 | |||
751 | $ hg --debug help debugextension |
|
751 | $ hg --debug help debugextension | |
752 | hg debugextensions |
|
752 | hg debugextensions | |
753 |
|
753 | |||
754 | show information about active extensions |
|
754 | show information about active extensions | |
755 |
|
755 | |||
756 | options: |
|
756 | options: | |
757 |
|
757 | |||
758 | -T --template TEMPLATE display with template |
|
758 | -T --template TEMPLATE display with template | |
759 |
|
759 | |||
760 | global options ([+] can be repeated): |
|
760 | global options ([+] can be repeated): | |
761 |
|
761 | |||
762 | -R --repository REPO repository root directory or name of overlay bundle |
|
762 | -R --repository REPO repository root directory or name of overlay bundle | |
763 | file |
|
763 | file | |
764 | --cwd DIR change working directory |
|
764 | --cwd DIR change working directory | |
765 | -y --noninteractive do not prompt, automatically pick the first choice for |
|
765 | -y --noninteractive do not prompt, automatically pick the first choice for | |
766 | all prompts |
|
766 | all prompts | |
767 | -q --quiet suppress output |
|
767 | -q --quiet suppress output | |
768 | -v --verbose enable additional output |
|
768 | -v --verbose enable additional output | |
769 | --color TYPE when to colorize (boolean, always, auto, never, or |
|
769 | --color TYPE when to colorize (boolean, always, auto, never, or | |
770 | debug) |
|
770 | debug) | |
771 | --config CONFIG [+] set/override config option (use 'section.name=value') |
|
771 | --config CONFIG [+] set/override config option (use 'section.name=value') | |
772 | --debug enable debugging output |
|
772 | --debug enable debugging output | |
773 | --debugger start debugger |
|
773 | --debugger start debugger | |
774 | --encoding ENCODE set the charset encoding (default: ascii) |
|
774 | --encoding ENCODE set the charset encoding (default: ascii) | |
775 | --encodingmode MODE set the charset encoding mode (default: strict) |
|
775 | --encodingmode MODE set the charset encoding mode (default: strict) | |
776 | --traceback always print a traceback on exception |
|
776 | --traceback always print a traceback on exception | |
777 | --time time how long the command takes |
|
777 | --time time how long the command takes | |
778 | --profile print command execution profile |
|
778 | --profile print command execution profile | |
779 | --version output version information and exit |
|
779 | --version output version information and exit | |
780 | -h --help display help and exit |
|
780 | -h --help display help and exit | |
781 | --hidden consider hidden changesets |
|
781 | --hidden consider hidden changesets | |
782 | --pager TYPE when to paginate (boolean, always, auto, or never) |
|
782 | --pager TYPE when to paginate (boolean, always, auto, or never) | |
783 | (default: auto) |
|
783 | (default: auto) | |
784 |
|
784 | |||
785 |
|
785 | |||
786 |
|
786 | |||
787 |
|
787 | |||
788 |
|
788 | |||
789 | $ echo 'debugextension = !' >> $HGRCPATH |
|
789 | $ echo 'debugextension = !' >> $HGRCPATH | |
790 |
|
790 | |||
791 | Asking for help about a deprecated extension should do something useful: |
|
791 | Asking for help about a deprecated extension should do something useful: | |
792 |
|
792 | |||
793 | $ hg help glog |
|
793 | $ hg help glog | |
794 | 'glog' is provided by the following extension: |
|
794 | 'glog' is provided by the following extension: | |
795 |
|
795 | |||
796 | graphlog command to view revision graphs from a shell (DEPRECATED) |
|
796 | graphlog command to view revision graphs from a shell (DEPRECATED) | |
797 |
|
797 | |||
798 | (use 'hg help extensions' for information on enabling extensions) |
|
798 | (use 'hg help extensions' for information on enabling extensions) | |
799 |
|
799 | |||
800 | Extension module help vs command help: |
|
800 | Extension module help vs command help: | |
801 |
|
801 | |||
802 | $ echo 'extdiff =' >> $HGRCPATH |
|
802 | $ echo 'extdiff =' >> $HGRCPATH | |
803 | $ hg help extdiff |
|
803 | $ hg help extdiff | |
804 | hg extdiff [OPT]... [FILE]... |
|
804 | hg extdiff [OPT]... [FILE]... | |
805 |
|
805 | |||
806 | use external program to diff repository (or selected files) |
|
806 | use external program to diff repository (or selected files) | |
807 |
|
807 | |||
808 | Show differences between revisions for the specified files, using an |
|
808 | Show differences between revisions for the specified files, using an | |
809 | external program. The default program used is diff, with default options |
|
809 | external program. The default program used is diff, with default options | |
810 | "-Npru". |
|
810 | "-Npru". | |
811 |
|
811 | |||
812 | To select a different program, use the -p/--program option. The program |
|
812 | To select a different program, use the -p/--program option. The program | |
813 | will be passed the names of two directories to compare, unless the --per- |
|
813 | will be passed the names of two directories to compare, unless the --per- | |
814 | file option is specified (see below). To pass additional options to the |
|
814 | file option is specified (see below). To pass additional options to the | |
815 | program, use -o/--option. These will be passed before the names of the |
|
815 | program, use -o/--option. These will be passed before the names of the | |
816 | directories or files to compare. |
|
816 | directories or files to compare. | |
817 |
|
817 | |||
818 | When two revision arguments are given, then changes are shown between |
|
818 | When two revision arguments are given, then changes are shown between | |
819 | those revisions. If only one revision is specified then that revision is |
|
819 | those revisions. If only one revision is specified then that revision is | |
820 | compared to the working directory, and, when no revisions are specified, |
|
820 | compared to the working directory, and, when no revisions are specified, | |
821 | the working directory files are compared to its parent. |
|
821 | the working directory files are compared to its parent. | |
822 |
|
822 | |||
823 | The --per-file option runs the external program repeatedly on each file to |
|
823 | The --per-file option runs the external program repeatedly on each file to | |
824 | diff, instead of once on two directories. By default, this happens one by |
|
824 | diff, instead of once on two directories. By default, this happens one by | |
825 | one, where the next file diff is open in the external program only once |
|
825 | one, where the next file diff is open in the external program only once | |
826 | the previous external program (for the previous file diff) has exited. If |
|
826 | the previous external program (for the previous file diff) has exited. If | |
827 | the external program has a graphical interface, it can open all the file |
|
827 | the external program has a graphical interface, it can open all the file | |
828 | diffs at once instead of one by one. See 'hg help -e extdiff' for |
|
828 | diffs at once instead of one by one. See 'hg help -e extdiff' for | |
829 | information about how to tell Mercurial that a given program has a |
|
829 | information about how to tell Mercurial that a given program has a | |
830 | graphical interface. |
|
830 | graphical interface. | |
831 |
|
831 | |||
832 | The --confirm option will prompt the user before each invocation of the |
|
832 | The --confirm option will prompt the user before each invocation of the | |
833 | external program. It is ignored if --per-file isn't specified. |
|
833 | external program. It is ignored if --per-file isn't specified. | |
834 |
|
834 | |||
835 | (use 'hg help -e extdiff' to show help for the extdiff extension) |
|
835 | (use 'hg help -e extdiff' to show help for the extdiff extension) | |
836 |
|
836 | |||
837 | options ([+] can be repeated): |
|
837 | options ([+] can be repeated): | |
838 |
|
838 | |||
839 | -p --program CMD comparison program to run |
|
839 | -p --program CMD comparison program to run | |
840 | -o --option OPT [+] pass option to comparison program |
|
840 | -o --option OPT [+] pass option to comparison program | |
841 | -r --rev REV [+] revision |
|
841 | -r --rev REV [+] revision | |
842 | -c --change REV change made by revision |
|
842 | -c --change REV change made by revision | |
843 | --per-file compare each file instead of revision snapshots |
|
843 | --per-file compare each file instead of revision snapshots | |
844 | --confirm prompt user before each external program invocation |
|
844 | --confirm prompt user before each external program invocation | |
845 | --patch compare patches for two revisions |
|
845 | --patch compare patches for two revisions | |
846 | -I --include PATTERN [+] include names matching the given patterns |
|
846 | -I --include PATTERN [+] include names matching the given patterns | |
847 | -X --exclude PATTERN [+] exclude names matching the given patterns |
|
847 | -X --exclude PATTERN [+] exclude names matching the given patterns | |
848 | -S --subrepos recurse into subrepositories |
|
848 | -S --subrepos recurse into subrepositories | |
849 |
|
849 | |||
850 | (some details hidden, use --verbose to show complete help) |
|
850 | (some details hidden, use --verbose to show complete help) | |
851 |
|
851 | |||
852 |
|
852 | |||
853 |
|
853 | |||
854 |
|
854 | |||
855 |
|
855 | |||
856 |
|
856 | |||
857 |
|
857 | |||
858 |
|
858 | |||
859 |
|
859 | |||
860 |
|
860 | |||
861 | $ hg help --extension extdiff |
|
861 | $ hg help --extension extdiff | |
862 | extdiff extension - command to allow external programs to compare revisions |
|
862 | extdiff extension - command to allow external programs to compare revisions | |
863 |
|
863 | |||
864 | The extdiff Mercurial extension allows you to use external programs to compare |
|
864 | The extdiff Mercurial extension allows you to use external programs to compare | |
865 | revisions, or revision with working directory. The external diff programs are |
|
865 | revisions, or revision with working directory. The external diff programs are | |
866 | called with a configurable set of options and two non-option arguments: paths |
|
866 | called with a configurable set of options and two non-option arguments: paths | |
867 | to directories containing snapshots of files to compare. |
|
867 | to directories containing snapshots of files to compare. | |
868 |
|
868 | |||
869 | If there is more than one file being compared and the "child" revision is the |
|
869 | If there is more than one file being compared and the "child" revision is the | |
870 | working directory, any modifications made in the external diff program will be |
|
870 | working directory, any modifications made in the external diff program will be | |
871 | copied back to the working directory from the temporary directory. |
|
871 | copied back to the working directory from the temporary directory. | |
872 |
|
872 | |||
873 | The extdiff extension also allows you to configure new diff commands, so you |
|
873 | The extdiff extension also allows you to configure new diff commands, so you | |
874 | do not need to type 'hg extdiff -p kdiff3' always. |
|
874 | do not need to type 'hg extdiff -p kdiff3' always. | |
875 |
|
875 | |||
876 | [extdiff] |
|
876 | [extdiff] | |
877 | # add new command that runs GNU diff(1) in 'context diff' mode |
|
877 | # add new command that runs GNU diff(1) in 'context diff' mode | |
878 | cdiff = gdiff -Nprc5 |
|
878 | cdiff = gdiff -Nprc5 | |
879 | ## or the old way: |
|
879 | ## or the old way: | |
880 | #cmd.cdiff = gdiff |
|
880 | #cmd.cdiff = gdiff | |
881 | #opts.cdiff = -Nprc5 |
|
881 | #opts.cdiff = -Nprc5 | |
882 |
|
882 | |||
883 | # add new command called meld, runs meld (no need to name twice). If |
|
883 | # add new command called meld, runs meld (no need to name twice). If | |
884 | # the meld executable is not available, the meld tool in [merge-tools] |
|
884 | # the meld executable is not available, the meld tool in [merge-tools] | |
885 | # will be used, if available |
|
885 | # will be used, if available | |
886 | meld = |
|
886 | meld = | |
887 |
|
887 | |||
888 | # add new command called vimdiff, runs gvimdiff with DirDiff plugin |
|
888 | # add new command called vimdiff, runs gvimdiff with DirDiff plugin | |
889 | # (see http://www.vim.org/scripts/script.php?script_id=102) Non |
|
889 | # (see http://www.vim.org/scripts/script.php?script_id=102) Non | |
890 | # English user, be sure to put "let g:DirDiffDynamicDiffText = 1" in |
|
890 | # English user, be sure to put "let g:DirDiffDynamicDiffText = 1" in | |
891 | # your .vimrc |
|
891 | # your .vimrc | |
892 | vimdiff = gvim -f "+next" \ |
|
892 | vimdiff = gvim -f "+next" \ | |
893 | "+execute 'DirDiff' fnameescape(argv(0)) fnameescape(argv(1))" |
|
893 | "+execute 'DirDiff' fnameescape(argv(0)) fnameescape(argv(1))" | |
894 |
|
894 | |||
895 | Tool arguments can include variables that are expanded at runtime: |
|
895 | Tool arguments can include variables that are expanded at runtime: | |
896 |
|
896 | |||
897 | $parent1, $plabel1 - filename, descriptive label of first parent |
|
897 | $parent1, $plabel1 - filename, descriptive label of first parent | |
898 | $child, $clabel - filename, descriptive label of child revision |
|
898 | $child, $clabel - filename, descriptive label of child revision | |
899 | $parent2, $plabel2 - filename, descriptive label of second parent |
|
899 | $parent2, $plabel2 - filename, descriptive label of second parent | |
900 | $root - repository root |
|
900 | $root - repository root | |
901 | $parent is an alias for $parent1. |
|
901 | $parent is an alias for $parent1. | |
902 |
|
902 | |||
903 | The extdiff extension will look in your [diff-tools] and [merge-tools] |
|
903 | The extdiff extension will look in your [diff-tools] and [merge-tools] | |
904 | sections for diff tool arguments, when none are specified in [extdiff]. |
|
904 | sections for diff tool arguments, when none are specified in [extdiff]. | |
905 |
|
905 | |||
906 | [extdiff] |
|
906 | [extdiff] | |
907 | kdiff3 = |
|
907 | kdiff3 = | |
908 |
|
908 | |||
909 | [diff-tools] |
|
909 | [diff-tools] | |
910 | kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child |
|
910 | kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child | |
911 |
|
911 | |||
912 | If a program has a graphical interface, it might be interesting to tell |
|
912 | If a program has a graphical interface, it might be interesting to tell | |
913 | Mercurial about it. It will prevent the program from being mistakenly used in |
|
913 | Mercurial about it. It will prevent the program from being mistakenly used in | |
914 | a terminal-only environment (such as an SSH terminal session), and will make |
|
914 | a terminal-only environment (such as an SSH terminal session), and will make | |
915 | 'hg extdiff --per-file' open multiple file diffs at once instead of one by one |
|
915 | 'hg extdiff --per-file' open multiple file diffs at once instead of one by one | |
916 | (if you still want to open file diffs one by one, you can use the --confirm |
|
916 | (if you still want to open file diffs one by one, you can use the --confirm | |
917 | option). |
|
917 | option). | |
918 |
|
918 | |||
919 | Declaring that a tool has a graphical interface can be done with the "gui" |
|
919 | Declaring that a tool has a graphical interface can be done with the "gui" | |
920 | flag next to where "diffargs" are specified: |
|
920 | flag next to where "diffargs" are specified: | |
921 |
|
921 | |||
922 | [diff-tools] |
|
922 | [diff-tools] | |
923 | kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child |
|
923 | kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child | |
924 | kdiff3.gui = true |
|
924 | kdiff3.gui = true | |
925 |
|
925 | |||
926 | You can use -I/-X and list of file or directory names like normal 'hg diff' |
|
926 | You can use -I/-X and list of file or directory names like normal 'hg diff' | |
927 | command. The extdiff extension makes snapshots of only needed files, so |
|
927 | command. The extdiff extension makes snapshots of only needed files, so | |
928 | running the external diff program will actually be pretty fast (at least |
|
928 | running the external diff program will actually be pretty fast (at least | |
929 | faster than having to compare the entire tree). |
|
929 | faster than having to compare the entire tree). | |
930 |
|
930 | |||
931 | list of commands: |
|
931 | list of commands: | |
932 |
|
932 | |||
933 | extdiff use external program to diff repository (or selected files) |
|
933 | extdiff use external program to diff repository (or selected files) | |
934 |
|
934 | |||
935 | (use 'hg help -v -e extdiff' to show built-in aliases and global options) |
|
935 | (use 'hg help -v -e extdiff' to show built-in aliases and global options) | |
936 |
|
936 | |||
937 |
|
937 | |||
938 |
|
938 | |||
939 |
|
939 | |||
940 |
|
940 | |||
941 |
|
941 | |||
942 |
|
942 | |||
943 |
|
943 | |||
944 |
|
944 | |||
945 |
|
945 | |||
946 |
|
946 | |||
947 |
|
947 | |||
948 |
|
948 | |||
949 |
|
949 | |||
950 |
|
950 | |||
951 |
|
951 | |||
952 | $ echo 'extdiff = !' >> $HGRCPATH |
|
952 | $ echo 'extdiff = !' >> $HGRCPATH | |
953 |
|
953 | |||
954 | Test help topic with same name as extension |
|
954 | Test help topic with same name as extension | |
955 |
|
955 | |||
956 | $ cat > multirevs.py <<EOF |
|
956 | $ cat > multirevs.py <<EOF | |
957 | > from mercurial import commands, registrar |
|
957 | > from mercurial import commands, registrar | |
958 | > cmdtable = {} |
|
958 | > cmdtable = {} | |
959 | > command = registrar.command(cmdtable) |
|
959 | > command = registrar.command(cmdtable) | |
960 | > """multirevs extension |
|
960 | > """multirevs extension | |
961 | > Big multi-line module docstring.""" |
|
961 | > Big multi-line module docstring.""" | |
962 | > @command(b'multirevs', [], b'ARG', norepo=True) |
|
962 | > @command(b'multirevs', [], b'ARG', norepo=True) | |
963 | > def multirevs(ui, repo, arg, *args, **opts): |
|
963 | > def multirevs(ui, repo, arg, *args, **opts): | |
964 | > """multirevs command""" |
|
964 | > """multirevs command""" | |
965 | > EOF |
|
965 | > EOF | |
966 | $ echo "multirevs = multirevs.py" >> $HGRCPATH |
|
966 | $ echo "multirevs = multirevs.py" >> $HGRCPATH | |
967 |
|
967 | |||
968 | $ hg help multirevs | tail |
|
968 | $ hg help multirevs | tail | |
969 | used): |
|
969 | used): | |
970 |
|
970 | |||
971 | hg update :@ |
|
971 | hg update :@ | |
972 |
|
972 | |||
973 | - Show diff between tags 1.3 and 1.5 (this works because the first and the |
|
973 | - Show diff between tags 1.3 and 1.5 (this works because the first and the | |
974 | last revisions of the revset are used): |
|
974 | last revisions of the revset are used): | |
975 |
|
975 | |||
976 | hg diff -r 1.3::1.5 |
|
976 | hg diff -r 1.3::1.5 | |
977 |
|
977 | |||
978 | use 'hg help -c multirevs' to see help for the multirevs command |
|
978 | use 'hg help -c multirevs' to see help for the multirevs command | |
979 |
|
979 | |||
980 |
|
980 | |||
981 |
|
981 | |||
982 |
|
982 | |||
983 |
|
983 | |||
984 |
|
984 | |||
985 | $ hg help -c multirevs |
|
985 | $ hg help -c multirevs | |
986 | hg multirevs ARG |
|
986 | hg multirevs ARG | |
987 |
|
987 | |||
988 | multirevs command |
|
988 | multirevs command | |
989 |
|
989 | |||
990 | (some details hidden, use --verbose to show complete help) |
|
990 | (some details hidden, use --verbose to show complete help) | |
991 |
|
991 | |||
992 |
|
992 | |||
993 |
|
993 | |||
994 | $ hg multirevs |
|
994 | $ hg multirevs | |
995 | hg multirevs: invalid arguments |
|
995 | hg multirevs: invalid arguments | |
996 | hg multirevs ARG |
|
996 | hg multirevs ARG | |
997 |
|
997 | |||
998 | multirevs command |
|
998 | multirevs command | |
999 |
|
999 | |||
1000 | (use 'hg multirevs -h' to show more help) |
|
1000 | (use 'hg multirevs -h' to show more help) | |
1001 | [255] |
|
1001 | [255] | |
1002 |
|
1002 | |||
1003 |
|
1003 | |||
1004 |
|
1004 | |||
1005 | $ echo "multirevs = !" >> $HGRCPATH |
|
1005 | $ echo "multirevs = !" >> $HGRCPATH | |
1006 |
|
1006 | |||
1007 | Issue811: Problem loading extensions twice (by site and by user) |
|
1007 | Issue811: Problem loading extensions twice (by site and by user) | |
1008 |
|
1008 | |||
1009 | $ cat <<EOF >> $HGRCPATH |
|
1009 | $ cat <<EOF >> $HGRCPATH | |
1010 | > mq = |
|
1010 | > mq = | |
1011 | > strip = |
|
1011 | > strip = | |
1012 | > hgext.mq = |
|
1012 | > hgext.mq = | |
1013 | > hgext/mq = |
|
1013 | > hgext/mq = | |
1014 | > EOF |
|
1014 | > EOF | |
1015 |
|
1015 | |||
1016 | Show extensions: |
|
1016 | Show extensions: | |
1017 | (note that mq force load strip, also checking it's not loaded twice) |
|
1017 | (note that mq force load strip, also checking it's not loaded twice) | |
1018 |
|
1018 | |||
1019 | #if no-extraextensions |
|
1019 | #if no-extraextensions | |
1020 | $ hg debugextensions |
|
1020 | $ hg debugextensions | |
1021 | mq |
|
1021 | mq | |
1022 | strip |
|
1022 | strip | |
1023 | #endif |
|
1023 | #endif | |
1024 |
|
1024 | |||
1025 | For extensions, which name matches one of its commands, help |
|
1025 | For extensions, which name matches one of its commands, help | |
1026 | message should ask '-v -e' to get list of built-in aliases |
|
1026 | message should ask '-v -e' to get list of built-in aliases | |
1027 | along with extension help itself |
|
1027 | along with extension help itself | |
1028 |
|
1028 | |||
1029 | $ mkdir $TESTTMP/d |
|
1029 | $ mkdir $TESTTMP/d | |
1030 | $ cat > $TESTTMP/d/dodo.py <<EOF |
|
1030 | $ cat > $TESTTMP/d/dodo.py <<EOF | |
1031 | > """ |
|
1031 | > """ | |
1032 | > This is an awesome 'dodo' extension. It does nothing and |
|
1032 | > This is an awesome 'dodo' extension. It does nothing and | |
1033 | > writes 'Foo foo' |
|
1033 | > writes 'Foo foo' | |
1034 | > """ |
|
1034 | > """ | |
1035 | > from mercurial import commands, registrar |
|
1035 | > from mercurial import commands, registrar | |
1036 | > cmdtable = {} |
|
1036 | > cmdtable = {} | |
1037 | > command = registrar.command(cmdtable) |
|
1037 | > command = registrar.command(cmdtable) | |
1038 | > @command(b'dodo', [], b'hg dodo') |
|
1038 | > @command(b'dodo', [], b'hg dodo') | |
1039 | > def dodo(ui, *args, **kwargs): |
|
1039 | > def dodo(ui, *args, **kwargs): | |
1040 | > """Does nothing""" |
|
1040 | > """Does nothing""" | |
1041 | > ui.write(b"I do nothing. Yay\\n") |
|
1041 | > ui.write(b"I do nothing. Yay\\n") | |
1042 | > @command(b'foofoo', [], b'hg foofoo') |
|
1042 | > @command(b'foofoo', [], b'hg foofoo') | |
1043 | > def foofoo(ui, *args, **kwargs): |
|
1043 | > def foofoo(ui, *args, **kwargs): | |
1044 | > """Writes 'Foo foo'""" |
|
1044 | > """Writes 'Foo foo'""" | |
1045 | > ui.write(b"Foo foo\\n") |
|
1045 | > ui.write(b"Foo foo\\n") | |
1046 | > EOF |
|
1046 | > EOF | |
1047 | $ dodopath=$TESTTMP/d/dodo.py |
|
1047 | $ dodopath=$TESTTMP/d/dodo.py | |
1048 |
|
1048 | |||
1049 | $ echo "dodo = $dodopath" >> $HGRCPATH |
|
1049 | $ echo "dodo = $dodopath" >> $HGRCPATH | |
1050 |
|
1050 | |||
1051 | Make sure that user is asked to enter '-v -e' to get list of built-in aliases |
|
1051 | Make sure that user is asked to enter '-v -e' to get list of built-in aliases | |
1052 | $ hg help -e dodo |
|
1052 | $ hg help -e dodo | |
1053 | dodo extension - |
|
1053 | dodo extension - | |
1054 |
|
1054 | |||
1055 | This is an awesome 'dodo' extension. It does nothing and writes 'Foo foo' |
|
1055 | This is an awesome 'dodo' extension. It does nothing and writes 'Foo foo' | |
1056 |
|
1056 | |||
1057 | list of commands: |
|
1057 | list of commands: | |
1058 |
|
1058 | |||
1059 | dodo Does nothing |
|
1059 | dodo Does nothing | |
1060 | foofoo Writes 'Foo foo' |
|
1060 | foofoo Writes 'Foo foo' | |
1061 |
|
1061 | |||
1062 | (use 'hg help -v -e dodo' to show built-in aliases and global options) |
|
1062 | (use 'hg help -v -e dodo' to show built-in aliases and global options) | |
1063 |
|
1063 | |||
1064 | Make sure that '-v -e' prints list of built-in aliases along with |
|
1064 | Make sure that '-v -e' prints list of built-in aliases along with | |
1065 | extension help itself |
|
1065 | extension help itself | |
1066 | $ hg help -v -e dodo |
|
1066 | $ hg help -v -e dodo | |
1067 | dodo extension - |
|
1067 | dodo extension - | |
1068 |
|
1068 | |||
1069 | This is an awesome 'dodo' extension. It does nothing and writes 'Foo foo' |
|
1069 | This is an awesome 'dodo' extension. It does nothing and writes 'Foo foo' | |
1070 |
|
1070 | |||
1071 | list of commands: |
|
1071 | list of commands: | |
1072 |
|
1072 | |||
1073 | dodo Does nothing |
|
1073 | dodo Does nothing | |
1074 | foofoo Writes 'Foo foo' |
|
1074 | foofoo Writes 'Foo foo' | |
1075 |
|
1075 | |||
1076 | global options ([+] can be repeated): |
|
1076 | global options ([+] can be repeated): | |
1077 |
|
1077 | |||
1078 | -R --repository REPO repository root directory or name of overlay bundle |
|
1078 | -R --repository REPO repository root directory or name of overlay bundle | |
1079 | file |
|
1079 | file | |
1080 | --cwd DIR change working directory |
|
1080 | --cwd DIR change working directory | |
1081 | -y --noninteractive do not prompt, automatically pick the first choice for |
|
1081 | -y --noninteractive do not prompt, automatically pick the first choice for | |
1082 | all prompts |
|
1082 | all prompts | |
1083 | -q --quiet suppress output |
|
1083 | -q --quiet suppress output | |
1084 | -v --verbose enable additional output |
|
1084 | -v --verbose enable additional output | |
1085 | --color TYPE when to colorize (boolean, always, auto, never, or |
|
1085 | --color TYPE when to colorize (boolean, always, auto, never, or | |
1086 | debug) |
|
1086 | debug) | |
1087 | --config CONFIG [+] set/override config option (use 'section.name=value') |
|
1087 | --config CONFIG [+] set/override config option (use 'section.name=value') | |
1088 | --debug enable debugging output |
|
1088 | --debug enable debugging output | |
1089 | --debugger start debugger |
|
1089 | --debugger start debugger | |
1090 | --encoding ENCODE set the charset encoding (default: ascii) |
|
1090 | --encoding ENCODE set the charset encoding (default: ascii) | |
1091 | --encodingmode MODE set the charset encoding mode (default: strict) |
|
1091 | --encodingmode MODE set the charset encoding mode (default: strict) | |
1092 | --traceback always print a traceback on exception |
|
1092 | --traceback always print a traceback on exception | |
1093 | --time time how long the command takes |
|
1093 | --time time how long the command takes | |
1094 | --profile print command execution profile |
|
1094 | --profile print command execution profile | |
1095 | --version output version information and exit |
|
1095 | --version output version information and exit | |
1096 | -h --help display help and exit |
|
1096 | -h --help display help and exit | |
1097 | --hidden consider hidden changesets |
|
1097 | --hidden consider hidden changesets | |
1098 | --pager TYPE when to paginate (boolean, always, auto, or never) |
|
1098 | --pager TYPE when to paginate (boolean, always, auto, or never) | |
1099 | (default: auto) |
|
1099 | (default: auto) | |
1100 |
|
1100 | |||
1101 | Make sure that single '-v' option shows help and built-ins only for 'dodo' command |
|
1101 | Make sure that single '-v' option shows help and built-ins only for 'dodo' command | |
1102 | $ hg help -v dodo |
|
1102 | $ hg help -v dodo | |
1103 | hg dodo |
|
1103 | hg dodo | |
1104 |
|
1104 | |||
1105 | Does nothing |
|
1105 | Does nothing | |
1106 |
|
1106 | |||
1107 | (use 'hg help -e dodo' to show help for the dodo extension) |
|
1107 | (use 'hg help -e dodo' to show help for the dodo extension) | |
1108 |
|
1108 | |||
1109 | options: |
|
1109 | options: | |
1110 |
|
1110 | |||
1111 | --mq operate on patch repository |
|
1111 | --mq operate on patch repository | |
1112 |
|
1112 | |||
1113 | global options ([+] can be repeated): |
|
1113 | global options ([+] can be repeated): | |
1114 |
|
1114 | |||
1115 | -R --repository REPO repository root directory or name of overlay bundle |
|
1115 | -R --repository REPO repository root directory or name of overlay bundle | |
1116 | file |
|
1116 | file | |
1117 | --cwd DIR change working directory |
|
1117 | --cwd DIR change working directory | |
1118 | -y --noninteractive do not prompt, automatically pick the first choice for |
|
1118 | -y --noninteractive do not prompt, automatically pick the first choice for | |
1119 | all prompts |
|
1119 | all prompts | |
1120 | -q --quiet suppress output |
|
1120 | -q --quiet suppress output | |
1121 | -v --verbose enable additional output |
|
1121 | -v --verbose enable additional output | |
1122 | --color TYPE when to colorize (boolean, always, auto, never, or |
|
1122 | --color TYPE when to colorize (boolean, always, auto, never, or | |
1123 | debug) |
|
1123 | debug) | |
1124 | --config CONFIG [+] set/override config option (use 'section.name=value') |
|
1124 | --config CONFIG [+] set/override config option (use 'section.name=value') | |
1125 | --debug enable debugging output |
|
1125 | --debug enable debugging output | |
1126 | --debugger start debugger |
|
1126 | --debugger start debugger | |
1127 | --encoding ENCODE set the charset encoding (default: ascii) |
|
1127 | --encoding ENCODE set the charset encoding (default: ascii) | |
1128 | --encodingmode MODE set the charset encoding mode (default: strict) |
|
1128 | --encodingmode MODE set the charset encoding mode (default: strict) | |
1129 | --traceback always print a traceback on exception |
|
1129 | --traceback always print a traceback on exception | |
1130 | --time time how long the command takes |
|
1130 | --time time how long the command takes | |
1131 | --profile print command execution profile |
|
1131 | --profile print command execution profile | |
1132 | --version output version information and exit |
|
1132 | --version output version information and exit | |
1133 | -h --help display help and exit |
|
1133 | -h --help display help and exit | |
1134 | --hidden consider hidden changesets |
|
1134 | --hidden consider hidden changesets | |
1135 | --pager TYPE when to paginate (boolean, always, auto, or never) |
|
1135 | --pager TYPE when to paginate (boolean, always, auto, or never) | |
1136 | (default: auto) |
|
1136 | (default: auto) | |
1137 |
|
1137 | |||
1138 | In case when extension name doesn't match any of its commands, |
|
1138 | In case when extension name doesn't match any of its commands, | |
1139 | help message should ask for '-v' to get list of built-in aliases |
|
1139 | help message should ask for '-v' to get list of built-in aliases | |
1140 | along with extension help |
|
1140 | along with extension help | |
1141 | $ cat > $TESTTMP/d/dudu.py <<EOF |
|
1141 | $ cat > $TESTTMP/d/dudu.py <<EOF | |
1142 | > """ |
|
1142 | > """ | |
1143 | > This is an awesome 'dudu' extension. It does something and |
|
1143 | > This is an awesome 'dudu' extension. It does something and | |
1144 | > also writes 'Beep beep' |
|
1144 | > also writes 'Beep beep' | |
1145 | > """ |
|
1145 | > """ | |
1146 | > from mercurial import commands, registrar |
|
1146 | > from mercurial import commands, registrar | |
1147 | > cmdtable = {} |
|
1147 | > cmdtable = {} | |
1148 | > command = registrar.command(cmdtable) |
|
1148 | > command = registrar.command(cmdtable) | |
1149 | > @command(b'something', [], b'hg something') |
|
1149 | > @command(b'something', [], b'hg something') | |
1150 | > def something(ui, *args, **kwargs): |
|
1150 | > def something(ui, *args, **kwargs): | |
1151 | > """Does something""" |
|
1151 | > """Does something""" | |
1152 | > ui.write(b"I do something. Yaaay\\n") |
|
1152 | > ui.write(b"I do something. Yaaay\\n") | |
1153 | > @command(b'beep', [], b'hg beep') |
|
1153 | > @command(b'beep', [], b'hg beep') | |
1154 | > def beep(ui, *args, **kwargs): |
|
1154 | > def beep(ui, *args, **kwargs): | |
1155 | > """Writes 'Beep beep'""" |
|
1155 | > """Writes 'Beep beep'""" | |
1156 | > ui.write(b"Beep beep\\n") |
|
1156 | > ui.write(b"Beep beep\\n") | |
1157 | > EOF |
|
1157 | > EOF | |
1158 | $ dudupath=$TESTTMP/d/dudu.py |
|
1158 | $ dudupath=$TESTTMP/d/dudu.py | |
1159 |
|
1159 | |||
1160 | $ echo "dudu = $dudupath" >> $HGRCPATH |
|
1160 | $ echo "dudu = $dudupath" >> $HGRCPATH | |
1161 |
|
1161 | |||
1162 | $ hg help -e dudu |
|
1162 | $ hg help -e dudu | |
1163 | dudu extension - |
|
1163 | dudu extension - | |
1164 |
|
1164 | |||
1165 | This is an awesome 'dudu' extension. It does something and also writes 'Beep |
|
1165 | This is an awesome 'dudu' extension. It does something and also writes 'Beep | |
1166 | beep' |
|
1166 | beep' | |
1167 |
|
1167 | |||
1168 | list of commands: |
|
1168 | list of commands: | |
1169 |
|
1169 | |||
1170 | beep Writes 'Beep beep' |
|
1170 | beep Writes 'Beep beep' | |
1171 | something Does something |
|
1171 | something Does something | |
1172 |
|
1172 | |||
1173 | (use 'hg help -v dudu' to show built-in aliases and global options) |
|
1173 | (use 'hg help -v dudu' to show built-in aliases and global options) | |
1174 |
|
1174 | |||
1175 | In case when extension name doesn't match any of its commands, |
|
1175 | In case when extension name doesn't match any of its commands, | |
1176 | help options '-v' and '-v -e' should be equivalent |
|
1176 | help options '-v' and '-v -e' should be equivalent | |
1177 | $ hg help -v dudu |
|
1177 | $ hg help -v dudu | |
1178 | dudu extension - |
|
1178 | dudu extension - | |
1179 |
|
1179 | |||
1180 | This is an awesome 'dudu' extension. It does something and also writes 'Beep |
|
1180 | This is an awesome 'dudu' extension. It does something and also writes 'Beep | |
1181 | beep' |
|
1181 | beep' | |
1182 |
|
1182 | |||
1183 | list of commands: |
|
1183 | list of commands: | |
1184 |
|
1184 | |||
1185 | beep Writes 'Beep beep' |
|
1185 | beep Writes 'Beep beep' | |
1186 | something Does something |
|
1186 | something Does something | |
1187 |
|
1187 | |||
1188 | global options ([+] can be repeated): |
|
1188 | global options ([+] can be repeated): | |
1189 |
|
1189 | |||
1190 | -R --repository REPO repository root directory or name of overlay bundle |
|
1190 | -R --repository REPO repository root directory or name of overlay bundle | |
1191 | file |
|
1191 | file | |
1192 | --cwd DIR change working directory |
|
1192 | --cwd DIR change working directory | |
1193 | -y --noninteractive do not prompt, automatically pick the first choice for |
|
1193 | -y --noninteractive do not prompt, automatically pick the first choice for | |
1194 | all prompts |
|
1194 | all prompts | |
1195 | -q --quiet suppress output |
|
1195 | -q --quiet suppress output | |
1196 | -v --verbose enable additional output |
|
1196 | -v --verbose enable additional output | |
1197 | --color TYPE when to colorize (boolean, always, auto, never, or |
|
1197 | --color TYPE when to colorize (boolean, always, auto, never, or | |
1198 | debug) |
|
1198 | debug) | |
1199 | --config CONFIG [+] set/override config option (use 'section.name=value') |
|
1199 | --config CONFIG [+] set/override config option (use 'section.name=value') | |
1200 | --debug enable debugging output |
|
1200 | --debug enable debugging output | |
1201 | --debugger start debugger |
|
1201 | --debugger start debugger | |
1202 | --encoding ENCODE set the charset encoding (default: ascii) |
|
1202 | --encoding ENCODE set the charset encoding (default: ascii) | |
1203 | --encodingmode MODE set the charset encoding mode (default: strict) |
|
1203 | --encodingmode MODE set the charset encoding mode (default: strict) | |
1204 | --traceback always print a traceback on exception |
|
1204 | --traceback always print a traceback on exception | |
1205 | --time time how long the command takes |
|
1205 | --time time how long the command takes | |
1206 | --profile print command execution profile |
|
1206 | --profile print command execution profile | |
1207 | --version output version information and exit |
|
1207 | --version output version information and exit | |
1208 | -h --help display help and exit |
|
1208 | -h --help display help and exit | |
1209 | --hidden consider hidden changesets |
|
1209 | --hidden consider hidden changesets | |
1210 | --pager TYPE when to paginate (boolean, always, auto, or never) |
|
1210 | --pager TYPE when to paginate (boolean, always, auto, or never) | |
1211 | (default: auto) |
|
1211 | (default: auto) | |
1212 |
|
1212 | |||
1213 | $ hg help -v -e dudu |
|
1213 | $ hg help -v -e dudu | |
1214 | dudu extension - |
|
1214 | dudu extension - | |
1215 |
|
1215 | |||
1216 | This is an awesome 'dudu' extension. It does something and also writes 'Beep |
|
1216 | This is an awesome 'dudu' extension. It does something and also writes 'Beep | |
1217 | beep' |
|
1217 | beep' | |
1218 |
|
1218 | |||
1219 | list of commands: |
|
1219 | list of commands: | |
1220 |
|
1220 | |||
1221 | beep Writes 'Beep beep' |
|
1221 | beep Writes 'Beep beep' | |
1222 | something Does something |
|
1222 | something Does something | |
1223 |
|
1223 | |||
1224 | global options ([+] can be repeated): |
|
1224 | global options ([+] can be repeated): | |
1225 |
|
1225 | |||
1226 | -R --repository REPO repository root directory or name of overlay bundle |
|
1226 | -R --repository REPO repository root directory or name of overlay bundle | |
1227 | file |
|
1227 | file | |
1228 | --cwd DIR change working directory |
|
1228 | --cwd DIR change working directory | |
1229 | -y --noninteractive do not prompt, automatically pick the first choice for |
|
1229 | -y --noninteractive do not prompt, automatically pick the first choice for | |
1230 | all prompts |
|
1230 | all prompts | |
1231 | -q --quiet suppress output |
|
1231 | -q --quiet suppress output | |
1232 | -v --verbose enable additional output |
|
1232 | -v --verbose enable additional output | |
1233 | --color TYPE when to colorize (boolean, always, auto, never, or |
|
1233 | --color TYPE when to colorize (boolean, always, auto, never, or | |
1234 | debug) |
|
1234 | debug) | |
1235 | --config CONFIG [+] set/override config option (use 'section.name=value') |
|
1235 | --config CONFIG [+] set/override config option (use 'section.name=value') | |
1236 | --debug enable debugging output |
|
1236 | --debug enable debugging output | |
1237 | --debugger start debugger |
|
1237 | --debugger start debugger | |
1238 | --encoding ENCODE set the charset encoding (default: ascii) |
|
1238 | --encoding ENCODE set the charset encoding (default: ascii) | |
1239 | --encodingmode MODE set the charset encoding mode (default: strict) |
|
1239 | --encodingmode MODE set the charset encoding mode (default: strict) | |
1240 | --traceback always print a traceback on exception |
|
1240 | --traceback always print a traceback on exception | |
1241 | --time time how long the command takes |
|
1241 | --time time how long the command takes | |
1242 | --profile print command execution profile |
|
1242 | --profile print command execution profile | |
1243 | --version output version information and exit |
|
1243 | --version output version information and exit | |
1244 | -h --help display help and exit |
|
1244 | -h --help display help and exit | |
1245 | --hidden consider hidden changesets |
|
1245 | --hidden consider hidden changesets | |
1246 | --pager TYPE when to paginate (boolean, always, auto, or never) |
|
1246 | --pager TYPE when to paginate (boolean, always, auto, or never) | |
1247 | (default: auto) |
|
1247 | (default: auto) | |
1248 |
|
1248 | |||
1249 | Disabled extension commands: |
|
1249 | Disabled extension commands: | |
1250 |
|
1250 | |||
1251 | $ ORGHGRCPATH=$HGRCPATH |
|
1251 | $ ORGHGRCPATH=$HGRCPATH | |
1252 | $ HGRCPATH= |
|
1252 | $ HGRCPATH= | |
1253 | $ export HGRCPATH |
|
1253 | $ export HGRCPATH | |
1254 | $ hg help email |
|
1254 | $ hg help email | |
1255 | 'email' is provided by the following extension: |
|
1255 | 'email' is provided by the following extension: | |
1256 |
|
1256 | |||
1257 | patchbomb command to send changesets as (a series of) patch emails |
|
1257 | patchbomb command to send changesets as (a series of) patch emails | |
1258 |
|
1258 | |||
1259 | (use 'hg help extensions' for information on enabling extensions) |
|
1259 | (use 'hg help extensions' for information on enabling extensions) | |
1260 |
|
1260 | |||
1261 |
|
1261 | |||
1262 | $ hg qdel |
|
1262 | $ hg qdel | |
1263 | hg: unknown command 'qdel' |
|
1263 | hg: unknown command 'qdel' | |
1264 | 'qdelete' is provided by the following extension: |
|
1264 | 'qdelete' is provided by the following extension: | |
1265 |
|
1265 | |||
1266 | mq manage a stack of patches |
|
1266 | mq manage a stack of patches | |
1267 |
|
1267 | |||
1268 | (use 'hg help extensions' for information on enabling extensions) |
|
1268 | (use 'hg help extensions' for information on enabling extensions) | |
1269 | [255] |
|
1269 | [255] | |
1270 |
|
1270 | |||
1271 |
|
1271 | |||
1272 | $ hg churn |
|
1272 | $ hg churn | |
1273 | hg: unknown command 'churn' |
|
1273 | hg: unknown command 'churn' | |
1274 | 'churn' is provided by the following extension: |
|
1274 | 'churn' is provided by the following extension: | |
1275 |
|
1275 | |||
1276 | churn command to display statistics about repository history |
|
1276 | churn command to display statistics about repository history | |
1277 |
|
1277 | |||
1278 | (use 'hg help extensions' for information on enabling extensions) |
|
1278 | (use 'hg help extensions' for information on enabling extensions) | |
1279 | [255] |
|
1279 | [255] | |
1280 |
|
1280 | |||
1281 |
|
1281 | |||
1282 |
|
1282 | |||
1283 | Disabled extensions: |
|
1283 | Disabled extensions: | |
1284 |
|
1284 | |||
1285 | $ hg help churn |
|
1285 | $ hg help churn | |
1286 | churn extension - command to display statistics about repository history |
|
1286 | churn extension - command to display statistics about repository history | |
1287 |
|
1287 | |||
1288 | (use 'hg help extensions' for information on enabling extensions) |
|
1288 | (use 'hg help extensions' for information on enabling extensions) | |
1289 |
|
1289 | |||
1290 | $ hg help patchbomb |
|
1290 | $ hg help patchbomb | |
1291 | patchbomb extension - command to send changesets as (a series of) patch emails |
|
1291 | patchbomb extension - command to send changesets as (a series of) patch emails | |
1292 |
|
1292 | |||
1293 | The series is started off with a "[PATCH 0 of N]" introduction, which |
|
1293 | The series is started off with a "[PATCH 0 of N]" introduction, which | |
1294 | describes the series as a whole. |
|
1294 | describes the series as a whole. | |
1295 |
|
1295 | |||
1296 | Each patch email has a Subject line of "[PATCH M of N] ...", using the first |
|
1296 | Each patch email has a Subject line of "[PATCH M of N] ...", using the first | |
1297 | line of the changeset description as the subject text. The message contains |
|
1297 | line of the changeset description as the subject text. The message contains | |
1298 | two or three body parts: |
|
1298 | two or three body parts: | |
1299 |
|
1299 | |||
1300 | - The changeset description. |
|
1300 | - The changeset description. | |
1301 | - [Optional] The result of running diffstat on the patch. |
|
1301 | - [Optional] The result of running diffstat on the patch. | |
1302 | - The patch itself, as generated by 'hg export'. |
|
1302 | - The patch itself, as generated by 'hg export'. | |
1303 |
|
1303 | |||
1304 | Each message refers to the first in the series using the In-Reply-To and |
|
1304 | Each message refers to the first in the series using the In-Reply-To and | |
1305 | References headers, so they will show up as a sequence in threaded mail and |
|
1305 | References headers, so they will show up as a sequence in threaded mail and | |
1306 | news readers, and in mail archives. |
|
1306 | news readers, and in mail archives. | |
1307 |
|
1307 | |||
1308 | To configure other defaults, add a section like this to your configuration |
|
1308 | To configure other defaults, add a section like this to your configuration | |
1309 | file: |
|
1309 | file: | |
1310 |
|
1310 | |||
1311 | [email] |
|
1311 | [email] | |
1312 | from = My Name <my@email> |
|
1312 | from = My Name <my@email> | |
1313 | to = recipient1, recipient2, ... |
|
1313 | to = recipient1, recipient2, ... | |
1314 | cc = cc1, cc2, ... |
|
1314 | cc = cc1, cc2, ... | |
1315 | bcc = bcc1, bcc2, ... |
|
1315 | bcc = bcc1, bcc2, ... | |
1316 | reply-to = address1, address2, ... |
|
1316 | reply-to = address1, address2, ... | |
1317 |
|
1317 | |||
1318 | Use "[patchbomb]" as configuration section name if you need to override global |
|
1318 | Use "[patchbomb]" as configuration section name if you need to override global | |
1319 | "[email]" address settings. |
|
1319 | "[email]" address settings. | |
1320 |
|
1320 | |||
1321 | Then you can use the 'hg email' command to mail a series of changesets as a |
|
1321 | Then you can use the 'hg email' command to mail a series of changesets as a | |
1322 | patchbomb. |
|
1322 | patchbomb. | |
1323 |
|
1323 | |||
1324 | You can also either configure the method option in the email section to be a |
|
1324 | You can also either configure the method option in the email section to be a | |
1325 | sendmail compatible mailer or fill out the [smtp] section so that the |
|
1325 | sendmail compatible mailer or fill out the [smtp] section so that the | |
1326 | patchbomb extension can automatically send patchbombs directly from the |
|
1326 | patchbomb extension can automatically send patchbombs directly from the | |
1327 | commandline. See the [email] and [smtp] sections in hgrc(5) for details. |
|
1327 | commandline. See the [email] and [smtp] sections in hgrc(5) for details. | |
1328 |
|
1328 | |||
1329 | By default, 'hg email' will prompt for a "To" or "CC" header if you do not |
|
1329 | By default, 'hg email' will prompt for a "To" or "CC" header if you do not | |
1330 | supply one via configuration or the command line. You can override this to |
|
1330 | supply one via configuration or the command line. You can override this to | |
1331 | never prompt by configuring an empty value: |
|
1331 | never prompt by configuring an empty value: | |
1332 |
|
1332 | |||
1333 | [email] |
|
1333 | [email] | |
1334 | cc = |
|
1334 | cc = | |
1335 |
|
1335 | |||
1336 | You can control the default inclusion of an introduction message with the |
|
1336 | You can control the default inclusion of an introduction message with the | |
1337 | "patchbomb.intro" configuration option. The configuration is always |
|
1337 | "patchbomb.intro" configuration option. The configuration is always | |
1338 | overwritten by command line flags like --intro and --desc: |
|
1338 | overwritten by command line flags like --intro and --desc: | |
1339 |
|
1339 | |||
1340 | [patchbomb] |
|
1340 | [patchbomb] | |
1341 | intro=auto # include introduction message if more than 1 patch (default) |
|
1341 | intro=auto # include introduction message if more than 1 patch (default) | |
1342 | intro=never # never include an introduction message |
|
1342 | intro=never # never include an introduction message | |
1343 | intro=always # always include an introduction message |
|
1343 | intro=always # always include an introduction message | |
1344 |
|
1344 | |||
1345 | You can specify a template for flags to be added in subject prefixes. Flags |
|
1345 | You can specify a template for flags to be added in subject prefixes. Flags | |
1346 | specified by --flag option are exported as "{flags}" keyword: |
|
1346 | specified by --flag option are exported as "{flags}" keyword: | |
1347 |
|
1347 | |||
1348 | [patchbomb] |
|
1348 | [patchbomb] | |
1349 | flagtemplate = "{separate(' ', |
|
1349 | flagtemplate = "{separate(' ', | |
1350 | ifeq(branch, 'default', '', branch|upper), |
|
1350 | ifeq(branch, 'default', '', branch|upper), | |
1351 | flags)}" |
|
1351 | flags)}" | |
1352 |
|
1352 | |||
1353 | You can set patchbomb to always ask for confirmation by setting |
|
1353 | You can set patchbomb to always ask for confirmation by setting | |
1354 | "patchbomb.confirm" to true. |
|
1354 | "patchbomb.confirm" to true. | |
1355 |
|
1355 | |||
1356 | (use 'hg help extensions' for information on enabling extensions) |
|
1356 | (use 'hg help extensions' for information on enabling extensions) | |
1357 |
|
1357 | |||
1358 |
|
1358 | |||
1359 | Broken disabled extension and command: |
|
1359 | Broken disabled extension and command: | |
1360 |
|
1360 | |||
1361 | $ mkdir hgext |
|
1361 | $ mkdir hgext | |
1362 | $ echo > hgext/__init__.py |
|
1362 | $ echo > hgext/__init__.py | |
1363 | $ cat > hgext/broken.py <<NO_CHECK_EOF |
|
1363 | $ cat > hgext/broken.py <<NO_CHECK_EOF | |
1364 | > "broken extension' |
|
1364 | > "broken extension' | |
1365 | > NO_CHECK_EOF |
|
1365 | > NO_CHECK_EOF | |
1366 | $ cat > path.py <<EOF |
|
1366 | $ cat > path.py <<EOF | |
1367 | > import os |
|
1367 | > import os | |
1368 | > import sys |
|
1368 | > import sys | |
1369 | > sys.path.insert(0, os.environ['HGEXTPATH']) |
|
1369 | > sys.path.insert(0, os.environ['HGEXTPATH']) | |
1370 | > EOF |
|
1370 | > EOF | |
1371 | $ HGEXTPATH=`pwd` |
|
1371 | $ HGEXTPATH=`pwd` | |
1372 | $ export HGEXTPATH |
|
1372 | $ export HGEXTPATH | |
1373 |
|
1373 | |||
1374 | $ hg --config extensions.path=./path.py help broken |
|
1374 | $ hg --config extensions.path=./path.py help broken | |
1375 | broken extension - (no help text available) |
|
1375 | broken extension - (no help text available) | |
1376 |
|
1376 | |||
1377 | (use 'hg help extensions' for information on enabling extensions) |
|
1377 | (use 'hg help extensions' for information on enabling extensions) | |
1378 |
|
1378 | |||
1379 |
|
1379 | |||
1380 | $ cat > hgext/forest.py <<EOF |
|
1380 | $ cat > hgext/forest.py <<EOF | |
1381 | > cmdtable = None |
|
1381 | > cmdtable = None | |
1382 | > @command() |
|
1382 | > @command() | |
1383 | > def f(): |
|
1383 | > def f(): | |
1384 | > pass |
|
1384 | > pass | |
1385 | > @command(123) |
|
1385 | > @command(123) | |
1386 | > def g(): |
|
1386 | > def g(): | |
1387 | > pass |
|
1387 | > pass | |
1388 | > EOF |
|
1388 | > EOF | |
1389 | $ hg --config extensions.path=./path.py help foo |
|
1389 | $ hg --config extensions.path=./path.py help foo | |
1390 | abort: no such help topic: foo |
|
1390 | abort: no such help topic: foo | |
1391 | (try 'hg help --keyword foo') |
|
1391 | (try 'hg help --keyword foo') | |
1392 | [255] |
|
1392 | [255] | |
1393 |
|
1393 | |||
1394 | $ cat > throw.py <<EOF |
|
1394 | $ cat > throw.py <<EOF | |
1395 | > from mercurial import commands, registrar, util |
|
1395 | > from mercurial import commands, registrar, util | |
1396 | > cmdtable = {} |
|
1396 | > cmdtable = {} | |
1397 | > command = registrar.command(cmdtable) |
|
1397 | > command = registrar.command(cmdtable) | |
1398 | > class Bogon(Exception): pass |
|
1398 | > class Bogon(Exception): pass | |
1399 | > @command(b'throw', [], b'hg throw', norepo=True) |
|
1399 | > @command(b'throw', [], b'hg throw', norepo=True) | |
1400 | > def throw(ui, **opts): |
|
1400 | > def throw(ui, **opts): | |
1401 | > """throws an exception""" |
|
1401 | > """throws an exception""" | |
1402 | > raise Bogon() |
|
1402 | > raise Bogon() | |
1403 | > EOF |
|
1403 | > EOF | |
1404 |
|
1404 | |||
1405 | No declared supported version, extension complains: |
|
1405 | No declared supported version, extension complains: | |
1406 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' |
|
1406 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' | |
1407 | ** Unknown exception encountered with possibly-broken third-party extension throw |
|
1407 | ** Unknown exception encountered with possibly-broken third-party extension throw | |
1408 | ** which supports versions unknown of Mercurial. |
|
1408 | ** which supports versions unknown of Mercurial. | |
1409 | ** Please disable throw and try your action again. |
|
1409 | ** Please disable throw and try your action again. | |
1410 | ** If that fixes the bug please report it to the extension author. |
|
1410 | ** If that fixes the bug please report it to the extension author. | |
1411 | ** Python * (glob) |
|
1411 | ** Python * (glob) | |
1412 | ** Mercurial Distributed SCM * (glob) |
|
1412 | ** Mercurial Distributed SCM * (glob) | |
1413 | ** Extensions loaded: throw |
|
1413 | ** Extensions loaded: throw | |
1414 |
|
1414 | |||
1415 | empty declaration of supported version, extension complains: |
|
1415 | empty declaration of supported version, extension complains: | |
1416 | $ echo "testedwith = ''" >> throw.py |
|
1416 | $ echo "testedwith = ''" >> throw.py | |
1417 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' |
|
1417 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' | |
1418 | ** Unknown exception encountered with possibly-broken third-party extension throw |
|
1418 | ** Unknown exception encountered with possibly-broken third-party extension throw | |
1419 | ** which supports versions unknown of Mercurial. |
|
1419 | ** which supports versions unknown of Mercurial. | |
1420 | ** Please disable throw and try your action again. |
|
1420 | ** Please disable throw and try your action again. | |
1421 | ** If that fixes the bug please report it to the extension author. |
|
1421 | ** If that fixes the bug please report it to the extension author. | |
1422 | ** Python * (glob) |
|
1422 | ** Python * (glob) | |
1423 | ** Mercurial Distributed SCM (*) (glob) |
|
1423 | ** Mercurial Distributed SCM (*) (glob) | |
1424 | ** Extensions loaded: throw |
|
1424 | ** Extensions loaded: throw | |
1425 |
|
1425 | |||
1426 | If the extension specifies a buglink, show that: |
|
1426 | If the extension specifies a buglink, show that: | |
1427 | $ echo 'buglink = "http://example.com/bts"' >> throw.py |
|
1427 | $ echo 'buglink = "http://example.com/bts"' >> throw.py | |
1428 | $ rm -f throw.pyc throw.pyo |
|
1428 | $ rm -f throw.pyc throw.pyo | |
1429 | $ rm -Rf __pycache__ |
|
1429 | $ rm -Rf __pycache__ | |
1430 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' |
|
1430 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' | |
1431 | ** Unknown exception encountered with possibly-broken third-party extension throw |
|
1431 | ** Unknown exception encountered with possibly-broken third-party extension throw | |
1432 | ** which supports versions unknown of Mercurial. |
|
1432 | ** which supports versions unknown of Mercurial. | |
1433 | ** Please disable throw and try your action again. |
|
1433 | ** Please disable throw and try your action again. | |
1434 | ** If that fixes the bug please report it to http://example.com/bts |
|
1434 | ** If that fixes the bug please report it to http://example.com/bts | |
1435 | ** Python * (glob) |
|
1435 | ** Python * (glob) | |
1436 | ** Mercurial Distributed SCM (*) (glob) |
|
1436 | ** Mercurial Distributed SCM (*) (glob) | |
1437 | ** Extensions loaded: throw |
|
1437 | ** Extensions loaded: throw | |
1438 |
|
1438 | |||
1439 | If the extensions declare outdated versions, accuse the older extension first: |
|
1439 | If the extensions declare outdated versions, accuse the older extension first: | |
1440 | $ echo "from mercurial import util" >> older.py |
|
1440 | $ echo "from mercurial import util" >> older.py | |
1441 | $ echo "util.version = lambda:b'2.2'" >> older.py |
|
1441 | $ echo "util.version = lambda:b'2.2'" >> older.py | |
1442 | $ echo "testedwith = b'1.9.3'" >> older.py |
|
1442 | $ echo "testedwith = b'1.9.3'" >> older.py | |
1443 | $ echo "testedwith = b'2.1.1'" >> throw.py |
|
1443 | $ echo "testedwith = b'2.1.1'" >> throw.py | |
1444 | $ rm -f throw.pyc throw.pyo |
|
1444 | $ rm -f throw.pyc throw.pyo | |
1445 | $ rm -Rf __pycache__ |
|
1445 | $ rm -Rf __pycache__ | |
1446 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ |
|
1446 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ | |
1447 | > throw 2>&1 | egrep '^\*\*' |
|
1447 | > throw 2>&1 | egrep '^\*\*' | |
1448 | ** Unknown exception encountered with possibly-broken third-party extension older |
|
1448 | ** Unknown exception encountered with possibly-broken third-party extension older | |
1449 | ** which supports versions 1.9 of Mercurial. |
|
1449 | ** which supports versions 1.9 of Mercurial. | |
1450 | ** Please disable older and try your action again. |
|
1450 | ** Please disable older and try your action again. | |
1451 | ** If that fixes the bug please report it to the extension author. |
|
1451 | ** If that fixes the bug please report it to the extension author. | |
1452 | ** Python * (glob) |
|
1452 | ** Python * (glob) | |
1453 | ** Mercurial Distributed SCM (version 2.2) |
|
1453 | ** Mercurial Distributed SCM (version 2.2) | |
1454 | ** Extensions loaded: throw, older |
|
1454 | ** Extensions loaded: throw, older | |
1455 |
|
1455 | |||
1456 | One extension only tested with older, one only with newer versions: |
|
1456 | One extension only tested with older, one only with newer versions: | |
1457 | $ echo "util.version = lambda:b'2.1'" >> older.py |
|
1457 | $ echo "util.version = lambda:b'2.1'" >> older.py | |
1458 | $ rm -f older.pyc older.pyo |
|
1458 | $ rm -f older.pyc older.pyo | |
1459 | $ rm -Rf __pycache__ |
|
1459 | $ rm -Rf __pycache__ | |
1460 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ |
|
1460 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ | |
1461 | > throw 2>&1 | egrep '^\*\*' |
|
1461 | > throw 2>&1 | egrep '^\*\*' | |
1462 | ** Unknown exception encountered with possibly-broken third-party extension older |
|
1462 | ** Unknown exception encountered with possibly-broken third-party extension older | |
1463 | ** which supports versions 1.9 of Mercurial. |
|
1463 | ** which supports versions 1.9 of Mercurial. | |
1464 | ** Please disable older and try your action again. |
|
1464 | ** Please disable older and try your action again. | |
1465 | ** If that fixes the bug please report it to the extension author. |
|
1465 | ** If that fixes the bug please report it to the extension author. | |
1466 | ** Python * (glob) |
|
1466 | ** Python * (glob) | |
1467 | ** Mercurial Distributed SCM (version 2.1) |
|
1467 | ** Mercurial Distributed SCM (version 2.1) | |
1468 | ** Extensions loaded: throw, older |
|
1468 | ** Extensions loaded: throw, older | |
1469 |
|
1469 | |||
1470 | Older extension is tested with current version, the other only with newer: |
|
1470 | Older extension is tested with current version, the other only with newer: | |
1471 | $ echo "util.version = lambda:b'1.9.3'" >> older.py |
|
1471 | $ echo "util.version = lambda:b'1.9.3'" >> older.py | |
1472 | $ rm -f older.pyc older.pyo |
|
1472 | $ rm -f older.pyc older.pyo | |
1473 | $ rm -Rf __pycache__ |
|
1473 | $ rm -Rf __pycache__ | |
1474 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ |
|
1474 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ | |
1475 | > throw 2>&1 | egrep '^\*\*' |
|
1475 | > throw 2>&1 | egrep '^\*\*' | |
1476 | ** Unknown exception encountered with possibly-broken third-party extension throw |
|
1476 | ** Unknown exception encountered with possibly-broken third-party extension throw | |
1477 | ** which supports versions 2.1 of Mercurial. |
|
1477 | ** which supports versions 2.1 of Mercurial. | |
1478 | ** Please disable throw and try your action again. |
|
1478 | ** Please disable throw and try your action again. | |
1479 | ** If that fixes the bug please report it to http://example.com/bts |
|
1479 | ** If that fixes the bug please report it to http://example.com/bts | |
1480 | ** Python * (glob) |
|
1480 | ** Python * (glob) | |
1481 | ** Mercurial Distributed SCM (version 1.9.3) |
|
1481 | ** Mercurial Distributed SCM (version 1.9.3) | |
1482 | ** Extensions loaded: throw, older |
|
1482 | ** Extensions loaded: throw, older | |
1483 |
|
1483 | |||
1484 | Ability to point to a different point |
|
1484 | Ability to point to a different point | |
1485 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ |
|
1485 | $ hg --config extensions.throw=throw.py --config extensions.older=older.py \ | |
1486 | > --config ui.supportcontact='Your Local Goat Lenders' throw 2>&1 | egrep '^\*\*' |
|
1486 | > --config ui.supportcontact='Your Local Goat Lenders' throw 2>&1 | egrep '^\*\*' | |
1487 | ** unknown exception encountered, please report by visiting |
|
1487 | ** unknown exception encountered, please report by visiting | |
1488 | ** Your Local Goat Lenders |
|
1488 | ** Your Local Goat Lenders | |
1489 | ** Python * (glob) |
|
1489 | ** Python * (glob) | |
1490 | ** Mercurial Distributed SCM (*) (glob) |
|
1490 | ** Mercurial Distributed SCM (*) (glob) | |
1491 | ** Extensions loaded: throw, older |
|
1491 | ** Extensions loaded: throw, older | |
1492 |
|
1492 | |||
1493 | Declare the version as supporting this hg version, show regular bts link: |
|
1493 | Declare the version as supporting this hg version, show regular bts link: | |
1494 | $ hgver=`hg debuginstall -T '{hgver}'` |
|
1494 | $ hgver=`hg debuginstall -T '{hgver}'` | |
1495 | $ echo 'testedwith = """'"$hgver"'"""' >> throw.py |
|
1495 | $ echo 'testedwith = """'"$hgver"'"""' >> throw.py | |
1496 | $ if [ -z "$hgver" ]; then |
|
1496 | $ if [ -z "$hgver" ]; then | |
1497 | > echo "unable to fetch a mercurial version. Make sure __version__ is correct"; |
|
1497 | > echo "unable to fetch a mercurial version. Make sure __version__ is correct"; | |
1498 | > fi |
|
1498 | > fi | |
1499 | $ rm -f throw.pyc throw.pyo |
|
1499 | $ rm -f throw.pyc throw.pyo | |
1500 | $ rm -Rf __pycache__ |
|
1500 | $ rm -Rf __pycache__ | |
1501 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' |
|
1501 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' | |
1502 | ** unknown exception encountered, please report by visiting |
|
1502 | ** unknown exception encountered, please report by visiting | |
1503 | ** https://mercurial-scm.org/wiki/BugTracker |
|
1503 | ** https://mercurial-scm.org/wiki/BugTracker | |
1504 | ** Python * (glob) |
|
1504 | ** Python * (glob) | |
1505 | ** Mercurial Distributed SCM (*) (glob) |
|
1505 | ** Mercurial Distributed SCM (*) (glob) | |
1506 | ** Extensions loaded: throw |
|
1506 | ** Extensions loaded: throw | |
1507 |
|
1507 | |||
1508 | Patch version is ignored during compatibility check |
|
1508 | Patch version is ignored during compatibility check | |
1509 | $ echo "testedwith = b'3.2'" >> throw.py |
|
1509 | $ echo "testedwith = b'3.2'" >> throw.py | |
1510 | $ echo "util.version = lambda:b'3.2.2'" >> throw.py |
|
1510 | $ echo "util.version = lambda:b'3.2.2'" >> throw.py | |
1511 | $ rm -f throw.pyc throw.pyo |
|
1511 | $ rm -f throw.pyc throw.pyo | |
1512 | $ rm -Rf __pycache__ |
|
1512 | $ rm -Rf __pycache__ | |
1513 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' |
|
1513 | $ hg --config extensions.throw=throw.py throw 2>&1 | egrep '^\*\*' | |
1514 | ** unknown exception encountered, please report by visiting |
|
1514 | ** unknown exception encountered, please report by visiting | |
1515 | ** https://mercurial-scm.org/wiki/BugTracker |
|
1515 | ** https://mercurial-scm.org/wiki/BugTracker | |
1516 | ** Python * (glob) |
|
1516 | ** Python * (glob) | |
1517 | ** Mercurial Distributed SCM (*) (glob) |
|
1517 | ** Mercurial Distributed SCM (*) (glob) | |
1518 | ** Extensions loaded: throw |
|
1518 | ** Extensions loaded: throw | |
1519 |
|
1519 | |||
1520 | Test version number support in 'hg version': |
|
1520 | Test version number support in 'hg version': | |
1521 | $ echo '__version__ = (1, 2, 3)' >> throw.py |
|
1521 | $ echo '__version__ = (1, 2, 3)' >> throw.py | |
1522 | $ rm -f throw.pyc throw.pyo |
|
1522 | $ rm -f throw.pyc throw.pyo | |
1523 | $ rm -Rf __pycache__ |
|
1523 | $ rm -Rf __pycache__ | |
1524 | $ hg version -v |
|
1524 | $ hg version -v | |
1525 | Mercurial Distributed SCM (version *) (glob) |
|
1525 | Mercurial Distributed SCM (version *) (glob) | |
1526 | (see https://mercurial-scm.org for more information) |
|
1526 | (see https://mercurial-scm.org for more information) | |
1527 |
|
1527 | |||
1528 | Copyright (C) 2005-* Matt Mackall and others (glob) |
|
1528 | Copyright (C) 2005-* Matt Mackall and others (glob) | |
1529 | This is free software; see the source for copying conditions. There is NO |
|
1529 | This is free software; see the source for copying conditions. There is NO | |
1530 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
1530 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
1531 |
|
1531 | |||
1532 | Enabled extensions: |
|
1532 | Enabled extensions: | |
1533 |
|
1533 | |||
1534 |
|
1534 | |||
1535 | $ hg version -v --config extensions.throw=throw.py |
|
1535 | $ hg version -v --config extensions.throw=throw.py | |
1536 | Mercurial Distributed SCM (version *) (glob) |
|
1536 | Mercurial Distributed SCM (version *) (glob) | |
1537 | (see https://mercurial-scm.org for more information) |
|
1537 | (see https://mercurial-scm.org for more information) | |
1538 |
|
1538 | |||
1539 | Copyright (C) 2005-* Matt Mackall and others (glob) |
|
1539 | Copyright (C) 2005-* Matt Mackall and others (glob) | |
1540 | This is free software; see the source for copying conditions. There is NO |
|
1540 | This is free software; see the source for copying conditions. There is NO | |
1541 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
1541 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
1542 |
|
1542 | |||
1543 | Enabled extensions: |
|
1543 | Enabled extensions: | |
1544 |
|
1544 | |||
1545 | throw external 1.2.3 |
|
1545 | throw external 1.2.3 | |
1546 | $ echo 'getversion = lambda: b"1.twentythree"' >> throw.py |
|
1546 | $ echo 'getversion = lambda: b"1.twentythree"' >> throw.py | |
1547 | $ rm -f throw.pyc throw.pyo |
|
1547 | $ rm -f throw.pyc throw.pyo | |
1548 | $ rm -Rf __pycache__ |
|
1548 | $ rm -Rf __pycache__ | |
1549 | $ hg version -v --config extensions.throw=throw.py --config extensions.strip= |
|
1549 | $ hg version -v --config extensions.throw=throw.py --config extensions.strip= | |
1550 | Mercurial Distributed SCM (version *) (glob) |
|
1550 | Mercurial Distributed SCM (version *) (glob) | |
1551 | (see https://mercurial-scm.org for more information) |
|
1551 | (see https://mercurial-scm.org for more information) | |
1552 |
|
1552 | |||
1553 | Copyright (C) 2005-* Matt Mackall and others (glob) |
|
1553 | Copyright (C) 2005-* Matt Mackall and others (glob) | |
1554 | This is free software; see the source for copying conditions. There is NO |
|
1554 | This is free software; see the source for copying conditions. There is NO | |
1555 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
1555 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
1556 |
|
1556 | |||
1557 | Enabled extensions: |
|
1557 | Enabled extensions: | |
1558 |
|
1558 | |||
1559 | throw external 1.twentythree |
|
1559 | throw external 1.twentythree | |
1560 | strip internal |
|
1560 | strip internal | |
1561 |
|
1561 | |||
1562 | $ hg version -q --config extensions.throw=throw.py |
|
1562 | $ hg version -q --config extensions.throw=throw.py | |
1563 | Mercurial Distributed SCM (version *) (glob) |
|
1563 | Mercurial Distributed SCM (version *) (glob) | |
1564 |
|
1564 | |||
1565 | Test template output: |
|
1565 | Test template output: | |
1566 |
|
1566 | |||
1567 | $ hg version --config extensions.strip= -T'{extensions}' |
|
1567 | $ hg version --config extensions.strip= -T'{extensions}' | |
1568 | strip |
|
1568 | strip | |
1569 |
|
1569 | |||
1570 | Test JSON output of version: |
|
1570 | Test JSON output of version: | |
1571 |
|
1571 | |||
1572 | $ hg version -Tjson |
|
1572 | $ hg version -Tjson | |
1573 | [ |
|
1573 | [ | |
1574 | { |
|
1574 | { | |
1575 | "extensions": [], |
|
1575 | "extensions": [], | |
1576 | "ver": "*" (glob) |
|
1576 | "ver": "*" (glob) | |
1577 | } |
|
1577 | } | |
1578 | ] |
|
1578 | ] | |
1579 |
|
1579 | |||
1580 | $ hg version --config extensions.throw=throw.py -Tjson |
|
1580 | $ hg version --config extensions.throw=throw.py -Tjson | |
1581 | [ |
|
1581 | [ | |
1582 | { |
|
1582 | { | |
1583 | "extensions": [{"bundled": false, "name": "throw", "ver": "1.twentythree"}], |
|
1583 | "extensions": [{"bundled": false, "name": "throw", "ver": "1.twentythree"}], | |
1584 | "ver": "3.2.2" |
|
1584 | "ver": "3.2.2" | |
1585 | } |
|
1585 | } | |
1586 | ] |
|
1586 | ] | |
1587 |
|
1587 | |||
1588 | $ hg version --config extensions.strip= -Tjson |
|
1588 | $ hg version --config extensions.strip= -Tjson | |
1589 | [ |
|
1589 | [ | |
1590 | { |
|
1590 | { | |
1591 | "extensions": [{"bundled": true, "name": "strip", "ver": null}], |
|
1591 | "extensions": [{"bundled": true, "name": "strip", "ver": null}], | |
1592 | "ver": "*" (glob) |
|
1592 | "ver": "*" (glob) | |
1593 | } |
|
1593 | } | |
1594 | ] |
|
1594 | ] | |
1595 |
|
1595 | |||
1596 | Test template output of version: |
|
1596 | Test template output of version: | |
1597 |
|
1597 | |||
1598 | $ hg version --config extensions.throw=throw.py --config extensions.strip= \ |
|
1598 | $ hg version --config extensions.throw=throw.py --config extensions.strip= \ | |
1599 | > -T'{extensions % "{name} {pad(ver, 16)} ({if(bundled, "internal", "external")})\n"}' |
|
1599 | > -T'{extensions % "{name} {pad(ver, 16)} ({if(bundled, "internal", "external")})\n"}' | |
1600 | throw 1.twentythree (external) |
|
1600 | throw 1.twentythree (external) | |
1601 | strip (internal) |
|
1601 | strip (internal) | |
1602 |
|
1602 | |||
1603 | Refuse to load extensions with minimum version requirements |
|
1603 | Refuse to load extensions with minimum version requirements | |
1604 |
|
1604 | |||
1605 | $ cat > minversion1.py << EOF |
|
1605 | $ cat > minversion1.py << EOF | |
1606 | > from mercurial import util |
|
1606 | > from mercurial import util | |
1607 | > util.version = lambda: b'3.5.2' |
|
1607 | > util.version = lambda: b'3.5.2' | |
1608 | > minimumhgversion = b'3.6' |
|
1608 | > minimumhgversion = b'3.6' | |
1609 | > EOF |
|
1609 | > EOF | |
1610 | $ hg --config extensions.minversion=minversion1.py version |
|
1610 | $ hg --config extensions.minversion=minversion1.py version | |
1611 | (third party extension minversion requires version 3.6 or newer of Mercurial (current: 3.5.2); disabling) |
|
1611 | (third party extension minversion requires version 3.6 or newer of Mercurial (current: 3.5.2); disabling) | |
1612 | Mercurial Distributed SCM (version 3.5.2) |
|
1612 | Mercurial Distributed SCM (version 3.5.2) | |
1613 | (see https://mercurial-scm.org for more information) |
|
1613 | (see https://mercurial-scm.org for more information) | |
1614 |
|
1614 | |||
1615 | Copyright (C) 2005-* Matt Mackall and others (glob) |
|
1615 | Copyright (C) 2005-* Matt Mackall and others (glob) | |
1616 | This is free software; see the source for copying conditions. There is NO |
|
1616 | This is free software; see the source for copying conditions. There is NO | |
1617 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
1617 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
1618 |
|
1618 | |||
1619 | $ cat > minversion2.py << EOF |
|
1619 | $ cat > minversion2.py << EOF | |
1620 | > from mercurial import util |
|
1620 | > from mercurial import util | |
1621 | > util.version = lambda: b'3.6' |
|
1621 | > util.version = lambda: b'3.6' | |
1622 | > minimumhgversion = b'3.7' |
|
1622 | > minimumhgversion = b'3.7' | |
1623 | > EOF |
|
1623 | > EOF | |
1624 | $ hg --config extensions.minversion=minversion2.py version 2>&1 | egrep '\(third' |
|
1624 | $ hg --config extensions.minversion=minversion2.py version 2>&1 | egrep '\(third' | |
1625 | (third party extension minversion requires version 3.7 or newer of Mercurial (current: 3.6); disabling) |
|
1625 | (third party extension minversion requires version 3.7 or newer of Mercurial (current: 3.6); disabling) | |
1626 |
|
1626 | |||
1627 | Can load version that is only off by point release |
|
1627 | Can load version that is only off by point release | |
1628 |
|
1628 | |||
1629 | $ cat > minversion2.py << EOF |
|
1629 | $ cat > minversion2.py << EOF | |
1630 | > from mercurial import util |
|
1630 | > from mercurial import util | |
1631 | > util.version = lambda: b'3.6.1' |
|
1631 | > util.version = lambda: b'3.6.1' | |
1632 | > minimumhgversion = b'3.6' |
|
1632 | > minimumhgversion = b'3.6' | |
1633 | > EOF |
|
1633 | > EOF | |
1634 | $ hg --config extensions.minversion=minversion3.py version 2>&1 | egrep '\(third' |
|
1634 | $ hg --config extensions.minversion=minversion3.py version 2>&1 | egrep '\(third' | |
1635 | [1] |
|
1635 | [1] | |
1636 |
|
1636 | |||
1637 | Can load minimum version identical to current |
|
1637 | Can load minimum version identical to current | |
1638 |
|
1638 | |||
1639 | $ cat > minversion3.py << EOF |
|
1639 | $ cat > minversion3.py << EOF | |
1640 | > from mercurial import util |
|
1640 | > from mercurial import util | |
1641 | > util.version = lambda: b'3.5' |
|
1641 | > util.version = lambda: b'3.5' | |
1642 | > minimumhgversion = b'3.5' |
|
1642 | > minimumhgversion = b'3.5' | |
1643 | > EOF |
|
1643 | > EOF | |
1644 | $ hg --config extensions.minversion=minversion3.py version 2>&1 | egrep '\(third' |
|
1644 | $ hg --config extensions.minversion=minversion3.py version 2>&1 | egrep '\(third' | |
1645 | [1] |
|
1645 | [1] | |
1646 |
|
1646 | |||
1647 | Restore HGRCPATH |
|
1647 | Restore HGRCPATH | |
1648 |
|
1648 | |||
1649 | $ HGRCPATH=$ORGHGRCPATH |
|
1649 | $ HGRCPATH=$ORGHGRCPATH | |
1650 | $ export HGRCPATH |
|
1650 | $ export HGRCPATH | |
1651 |
|
1651 | |||
1652 | Commands handling multiple repositories at a time should invoke only |
|
1652 | Commands handling multiple repositories at a time should invoke only | |
1653 | "reposetup()" of extensions enabling in the target repository. |
|
1653 | "reposetup()" of extensions enabling in the target repository. | |
1654 |
|
1654 | |||
1655 | $ mkdir reposetup-test |
|
1655 | $ mkdir reposetup-test | |
1656 | $ cd reposetup-test |
|
1656 | $ cd reposetup-test | |
1657 |
|
1657 | |||
1658 | $ cat > $TESTTMP/reposetuptest.py <<EOF |
|
1658 | $ cat > $TESTTMP/reposetuptest.py <<EOF | |
1659 | > from mercurial import extensions |
|
1659 | > from mercurial import extensions | |
1660 | > def reposetup(ui, repo): |
|
1660 | > def reposetup(ui, repo): | |
1661 | > ui.write(b'reposetup() for %s\n' % (repo.root)) |
|
1661 | > ui.write(b'reposetup() for %s\n' % (repo.root)) | |
1662 | > ui.flush() |
|
1662 | > ui.flush() | |
1663 | > EOF |
|
1663 | > EOF | |
1664 | $ hg init src |
|
1664 | $ hg init src | |
1665 | $ echo a > src/a |
|
1665 | $ echo a > src/a | |
1666 | $ hg -R src commit -Am '#0 at src/a' |
|
1666 | $ hg -R src commit -Am '#0 at src/a' | |
1667 | adding a |
|
1667 | adding a | |
1668 | $ echo '[extensions]' >> src/.hg/hgrc |
|
1668 | $ echo '[extensions]' >> src/.hg/hgrc | |
1669 | $ echo '# enable extension locally' >> src/.hg/hgrc |
|
1669 | $ echo '# enable extension locally' >> src/.hg/hgrc | |
1670 | $ echo "reposetuptest = $TESTTMP/reposetuptest.py" >> src/.hg/hgrc |
|
1670 | $ echo "reposetuptest = $TESTTMP/reposetuptest.py" >> src/.hg/hgrc | |
1671 | $ hg -R src status |
|
1671 | $ hg -R src status | |
1672 | reposetup() for $TESTTMP/reposetup-test/src |
|
1672 | reposetup() for $TESTTMP/reposetup-test/src | |
1673 | reposetup() for $TESTTMP/reposetup-test/src (chg !) |
|
1673 | reposetup() for $TESTTMP/reposetup-test/src (chg !) | |
1674 |
|
1674 | |||
1675 | #if no-extraextensions |
|
1675 | #if no-extraextensions | |
1676 | $ hg --cwd src debugextensions |
|
1676 | $ hg --cwd src debugextensions | |
1677 | reposetup() for $TESTTMP/reposetup-test/src |
|
1677 | reposetup() for $TESTTMP/reposetup-test/src | |
1678 | dodo (untested!) |
|
1678 | dodo (untested!) | |
1679 | dudu (untested!) |
|
1679 | dudu (untested!) | |
1680 | mq |
|
1680 | mq | |
1681 | reposetuptest (untested!) |
|
1681 | reposetuptest (untested!) | |
1682 | strip |
|
1682 | strip | |
1683 | #endif |
|
1683 | #endif | |
1684 |
|
1684 | |||
1685 | $ hg clone -U src clone-dst1 |
|
1685 | $ hg clone -U src clone-dst1 | |
1686 | reposetup() for $TESTTMP/reposetup-test/src |
|
1686 | reposetup() for $TESTTMP/reposetup-test/src | |
1687 | $ hg init push-dst1 |
|
1687 | $ hg init push-dst1 | |
1688 | $ hg -q -R src push push-dst1 |
|
1688 | $ hg -q -R src push push-dst1 | |
1689 | reposetup() for $TESTTMP/reposetup-test/src |
|
1689 | reposetup() for $TESTTMP/reposetup-test/src | |
1690 | $ hg init pull-src1 |
|
1690 | $ hg init pull-src1 | |
1691 | $ hg -q -R pull-src1 pull src |
|
1691 | $ hg -q -R pull-src1 pull src | |
1692 | reposetup() for $TESTTMP/reposetup-test/src |
|
1692 | reposetup() for $TESTTMP/reposetup-test/src | |
1693 |
|
1693 | |||
1694 | $ cat <<EOF >> $HGRCPATH |
|
1694 | $ cat <<EOF >> $HGRCPATH | |
1695 | > [extensions] |
|
1695 | > [extensions] | |
1696 | > # disable extension globally and explicitly |
|
1696 | > # disable extension globally and explicitly | |
1697 | > reposetuptest = ! |
|
1697 | > reposetuptest = ! | |
1698 | > EOF |
|
1698 | > EOF | |
1699 | $ hg clone -U src clone-dst2 |
|
1699 | $ hg clone -U src clone-dst2 | |
1700 | reposetup() for $TESTTMP/reposetup-test/src |
|
1700 | reposetup() for $TESTTMP/reposetup-test/src | |
1701 | $ hg init push-dst2 |
|
1701 | $ hg init push-dst2 | |
1702 | $ hg -q -R src push push-dst2 |
|
1702 | $ hg -q -R src push push-dst2 | |
1703 | reposetup() for $TESTTMP/reposetup-test/src |
|
1703 | reposetup() for $TESTTMP/reposetup-test/src | |
1704 | $ hg init pull-src2 |
|
1704 | $ hg init pull-src2 | |
1705 | $ hg -q -R pull-src2 pull src |
|
1705 | $ hg -q -R pull-src2 pull src | |
1706 | reposetup() for $TESTTMP/reposetup-test/src |
|
1706 | reposetup() for $TESTTMP/reposetup-test/src | |
1707 |
|
1707 | |||
1708 | $ cat <<EOF >> $HGRCPATH |
|
1708 | $ cat <<EOF >> $HGRCPATH | |
1709 | > [extensions] |
|
1709 | > [extensions] | |
1710 | > # enable extension globally |
|
1710 | > # enable extension globally | |
1711 | > reposetuptest = $TESTTMP/reposetuptest.py |
|
1711 | > reposetuptest = $TESTTMP/reposetuptest.py | |
1712 | > EOF |
|
1712 | > EOF | |
1713 | $ hg clone -U src clone-dst3 |
|
1713 | $ hg clone -U src clone-dst3 | |
1714 | reposetup() for $TESTTMP/reposetup-test/src |
|
1714 | reposetup() for $TESTTMP/reposetup-test/src | |
1715 | reposetup() for $TESTTMP/reposetup-test/clone-dst3 |
|
1715 | reposetup() for $TESTTMP/reposetup-test/clone-dst3 | |
1716 | $ hg init push-dst3 |
|
1716 | $ hg init push-dst3 | |
1717 | reposetup() for $TESTTMP/reposetup-test/push-dst3 |
|
1717 | reposetup() for $TESTTMP/reposetup-test/push-dst3 | |
1718 | $ hg -q -R src push push-dst3 |
|
1718 | $ hg -q -R src push push-dst3 | |
1719 | reposetup() for $TESTTMP/reposetup-test/src |
|
1719 | reposetup() for $TESTTMP/reposetup-test/src | |
1720 | reposetup() for $TESTTMP/reposetup-test/push-dst3 |
|
1720 | reposetup() for $TESTTMP/reposetup-test/push-dst3 | |
1721 | $ hg init pull-src3 |
|
1721 | $ hg init pull-src3 | |
1722 | reposetup() for $TESTTMP/reposetup-test/pull-src3 |
|
1722 | reposetup() for $TESTTMP/reposetup-test/pull-src3 | |
1723 | $ hg -q -R pull-src3 pull src |
|
1723 | $ hg -q -R pull-src3 pull src | |
1724 | reposetup() for $TESTTMP/reposetup-test/pull-src3 |
|
1724 | reposetup() for $TESTTMP/reposetup-test/pull-src3 | |
1725 | reposetup() for $TESTTMP/reposetup-test/src |
|
1725 | reposetup() for $TESTTMP/reposetup-test/src | |
1726 |
|
1726 | |||
1727 | $ echo '[extensions]' >> src/.hg/hgrc |
|
1727 | $ echo '[extensions]' >> src/.hg/hgrc | |
1728 | $ echo '# disable extension locally' >> src/.hg/hgrc |
|
1728 | $ echo '# disable extension locally' >> src/.hg/hgrc | |
1729 | $ echo 'reposetuptest = !' >> src/.hg/hgrc |
|
1729 | $ echo 'reposetuptest = !' >> src/.hg/hgrc | |
1730 | $ hg clone -U src clone-dst4 |
|
1730 | $ hg clone -U src clone-dst4 | |
1731 | reposetup() for $TESTTMP/reposetup-test/clone-dst4 |
|
1731 | reposetup() for $TESTTMP/reposetup-test/clone-dst4 | |
1732 | $ hg init push-dst4 |
|
1732 | $ hg init push-dst4 | |
1733 | reposetup() for $TESTTMP/reposetup-test/push-dst4 |
|
1733 | reposetup() for $TESTTMP/reposetup-test/push-dst4 | |
1734 | $ hg -q -R src push push-dst4 |
|
1734 | $ hg -q -R src push push-dst4 | |
1735 | reposetup() for $TESTTMP/reposetup-test/push-dst4 |
|
1735 | reposetup() for $TESTTMP/reposetup-test/push-dst4 | |
1736 | $ hg init pull-src4 |
|
1736 | $ hg init pull-src4 | |
1737 | reposetup() for $TESTTMP/reposetup-test/pull-src4 |
|
1737 | reposetup() for $TESTTMP/reposetup-test/pull-src4 | |
1738 | $ hg -q -R pull-src4 pull src |
|
1738 | $ hg -q -R pull-src4 pull src | |
1739 | reposetup() for $TESTTMP/reposetup-test/pull-src4 |
|
1739 | reposetup() for $TESTTMP/reposetup-test/pull-src4 | |
1740 |
|
1740 | |||
1741 | disabling in command line overlays with all configuration |
|
1741 | disabling in command line overlays with all configuration | |
1742 | $ hg --config extensions.reposetuptest=! clone -U src clone-dst5 |
|
1742 | $ hg --config extensions.reposetuptest=! clone -U src clone-dst5 | |
1743 | $ hg --config extensions.reposetuptest=! init push-dst5 |
|
1743 | $ hg --config extensions.reposetuptest=! init push-dst5 | |
1744 | $ hg --config extensions.reposetuptest=! -q -R src push push-dst5 |
|
1744 | $ hg --config extensions.reposetuptest=! -q -R src push push-dst5 | |
1745 | $ hg --config extensions.reposetuptest=! init pull-src5 |
|
1745 | $ hg --config extensions.reposetuptest=! init pull-src5 | |
1746 | $ hg --config extensions.reposetuptest=! -q -R pull-src5 pull src |
|
1746 | $ hg --config extensions.reposetuptest=! -q -R pull-src5 pull src | |
1747 |
|
1747 | |||
1748 | $ cat <<EOF >> $HGRCPATH |
|
1748 | $ cat <<EOF >> $HGRCPATH | |
1749 | > [extensions] |
|
1749 | > [extensions] | |
1750 | > # disable extension globally and explicitly |
|
1750 | > # disable extension globally and explicitly | |
1751 | > reposetuptest = ! |
|
1751 | > reposetuptest = ! | |
1752 | > EOF |
|
1752 | > EOF | |
1753 | $ hg init parent |
|
1753 | $ hg init parent | |
1754 | $ hg init parent/sub1 |
|
1754 | $ hg init parent/sub1 | |
1755 | $ echo 1 > parent/sub1/1 |
|
1755 | $ echo 1 > parent/sub1/1 | |
1756 | $ hg -R parent/sub1 commit -Am '#0 at parent/sub1' |
|
1756 | $ hg -R parent/sub1 commit -Am '#0 at parent/sub1' | |
1757 | adding 1 |
|
1757 | adding 1 | |
1758 | $ hg init parent/sub2 |
|
1758 | $ hg init parent/sub2 | |
1759 | $ hg init parent/sub2/sub21 |
|
1759 | $ hg init parent/sub2/sub21 | |
1760 | $ echo 21 > parent/sub2/sub21/21 |
|
1760 | $ echo 21 > parent/sub2/sub21/21 | |
1761 | $ hg -R parent/sub2/sub21 commit -Am '#0 at parent/sub2/sub21' |
|
1761 | $ hg -R parent/sub2/sub21 commit -Am '#0 at parent/sub2/sub21' | |
1762 | adding 21 |
|
1762 | adding 21 | |
1763 | $ cat > parent/sub2/.hgsub <<EOF |
|
1763 | $ cat > parent/sub2/.hgsub <<EOF | |
1764 | > sub21 = sub21 |
|
1764 | > sub21 = sub21 | |
1765 | > EOF |
|
1765 | > EOF | |
1766 | $ hg -R parent/sub2 commit -Am '#0 at parent/sub2' |
|
1766 | $ hg -R parent/sub2 commit -Am '#0 at parent/sub2' | |
1767 | adding .hgsub |
|
1767 | adding .hgsub | |
1768 | $ hg init parent/sub3 |
|
1768 | $ hg init parent/sub3 | |
1769 | $ echo 3 > parent/sub3/3 |
|
1769 | $ echo 3 > parent/sub3/3 | |
1770 | $ hg -R parent/sub3 commit -Am '#0 at parent/sub3' |
|
1770 | $ hg -R parent/sub3 commit -Am '#0 at parent/sub3' | |
1771 | adding 3 |
|
1771 | adding 3 | |
1772 | $ cat > parent/.hgsub <<EOF |
|
1772 | $ cat > parent/.hgsub <<EOF | |
1773 | > sub1 = sub1 |
|
1773 | > sub1 = sub1 | |
1774 | > sub2 = sub2 |
|
1774 | > sub2 = sub2 | |
1775 | > sub3 = sub3 |
|
1775 | > sub3 = sub3 | |
1776 | > EOF |
|
1776 | > EOF | |
1777 | $ hg -R parent commit -Am '#0 at parent' |
|
1777 | $ hg -R parent commit -Am '#0 at parent' | |
1778 | adding .hgsub |
|
1778 | adding .hgsub | |
1779 | $ echo '[extensions]' >> parent/.hg/hgrc |
|
1779 | $ echo '[extensions]' >> parent/.hg/hgrc | |
1780 | $ echo '# enable extension locally' >> parent/.hg/hgrc |
|
1780 | $ echo '# enable extension locally' >> parent/.hg/hgrc | |
1781 | $ echo "reposetuptest = $TESTTMP/reposetuptest.py" >> parent/.hg/hgrc |
|
1781 | $ echo "reposetuptest = $TESTTMP/reposetuptest.py" >> parent/.hg/hgrc | |
1782 | $ cp parent/.hg/hgrc parent/sub2/.hg/hgrc |
|
1782 | $ cp parent/.hg/hgrc parent/sub2/.hg/hgrc | |
1783 | $ hg -R parent status -S -A |
|
1783 | $ hg -R parent status -S -A | |
1784 | reposetup() for $TESTTMP/reposetup-test/parent |
|
1784 | reposetup() for $TESTTMP/reposetup-test/parent | |
1785 | reposetup() for $TESTTMP/reposetup-test/parent/sub2 |
|
1785 | reposetup() for $TESTTMP/reposetup-test/parent/sub2 | |
1786 | C .hgsub |
|
1786 | C .hgsub | |
1787 | C .hgsubstate |
|
1787 | C .hgsubstate | |
1788 | C sub1/1 |
|
1788 | C sub1/1 | |
1789 | C sub2/.hgsub |
|
1789 | C sub2/.hgsub | |
1790 | C sub2/.hgsubstate |
|
1790 | C sub2/.hgsubstate | |
1791 | C sub2/sub21/21 |
|
1791 | C sub2/sub21/21 | |
1792 | C sub3/3 |
|
1792 | C sub3/3 | |
1793 |
|
1793 | |||
1794 | $ cd .. |
|
1794 | $ cd .. | |
1795 |
|
1795 | |||
1796 | Prohibit registration of commands that don't use @command (issue5137) |
|
1796 | Prohibit registration of commands that don't use @command (issue5137) | |
1797 |
|
1797 | |||
1798 | $ hg init deprecated |
|
1798 | $ hg init deprecated | |
1799 | $ cd deprecated |
|
1799 | $ cd deprecated | |
1800 |
|
1800 | |||
1801 | $ cat <<EOF > deprecatedcmd.py |
|
1801 | $ cat <<EOF > deprecatedcmd.py | |
1802 | > def deprecatedcmd(repo, ui): |
|
1802 | > def deprecatedcmd(repo, ui): | |
1803 | > pass |
|
1803 | > pass | |
1804 | > cmdtable = { |
|
1804 | > cmdtable = { | |
1805 | > b'deprecatedcmd': (deprecatedcmd, [], b''), |
|
1805 | > b'deprecatedcmd': (deprecatedcmd, [], b''), | |
1806 | > } |
|
1806 | > } | |
1807 | > EOF |
|
1807 | > EOF | |
1808 | $ cat <<EOF > .hg/hgrc |
|
1808 | $ cat <<EOF > .hg/hgrc | |
1809 | > [extensions] |
|
1809 | > [extensions] | |
1810 | > deprecatedcmd = `pwd`/deprecatedcmd.py |
|
1810 | > deprecatedcmd = `pwd`/deprecatedcmd.py | |
1811 | > mq = ! |
|
1811 | > mq = ! | |
1812 | > hgext.mq = ! |
|
1812 | > hgext.mq = ! | |
1813 | > hgext/mq = ! |
|
1813 | > hgext/mq = ! | |
1814 | > EOF |
|
1814 | > EOF | |
1815 |
|
1815 | |||
1816 | $ hg deprecatedcmd > /dev/null |
|
1816 | $ hg deprecatedcmd > /dev/null | |
1817 | *** failed to import extension deprecatedcmd from $TESTTMP/deprecated/deprecatedcmd.py: missing attributes: norepo, optionalrepo, inferrepo |
|
1817 | *** failed to import extension deprecatedcmd from $TESTTMP/deprecated/deprecatedcmd.py: missing attributes: norepo, optionalrepo, inferrepo | |
1818 | *** (use @command decorator to register 'deprecatedcmd') |
|
1818 | *** (use @command decorator to register 'deprecatedcmd') | |
1819 | hg: unknown command 'deprecatedcmd' |
|
1819 | hg: unknown command 'deprecatedcmd' | |
1820 | (use 'hg help' for a list of commands) |
|
1820 | (use 'hg help' for a list of commands) | |
1821 | [255] |
|
1821 | [255] | |
1822 |
|
1822 | |||
1823 | the extension shouldn't be loaded at all so the mq works: |
|
1823 | the extension shouldn't be loaded at all so the mq works: | |
1824 |
|
1824 | |||
1825 | $ hg qseries --config extensions.mq= > /dev/null |
|
1825 | $ hg qseries --config extensions.mq= > /dev/null | |
1826 | *** failed to import extension deprecatedcmd from $TESTTMP/deprecated/deprecatedcmd.py: missing attributes: norepo, optionalrepo, inferrepo |
|
1826 | *** failed to import extension deprecatedcmd from $TESTTMP/deprecated/deprecatedcmd.py: missing attributes: norepo, optionalrepo, inferrepo | |
1827 | *** (use @command decorator to register 'deprecatedcmd') |
|
1827 | *** (use @command decorator to register 'deprecatedcmd') | |
1828 |
|
1828 | |||
1829 | $ cd .. |
|
1829 | $ cd .. | |
1830 |
|
1830 | |||
1831 | Test synopsis and docstring extending |
|
1831 | Test synopsis and docstring extending | |
1832 |
|
1832 | |||
1833 | $ hg init exthelp |
|
1833 | $ hg init exthelp | |
1834 | $ cat > exthelp.py <<EOF |
|
1834 | $ cat > exthelp.py <<EOF | |
1835 | > from mercurial import commands, extensions |
|
1835 | > from mercurial import commands, extensions | |
1836 | > def exbookmarks(orig, *args, **opts): |
|
1836 | > def exbookmarks(orig, *args, **opts): | |
1837 | > return orig(*args, **opts) |
|
1837 | > return orig(*args, **opts) | |
1838 | > def uisetup(ui): |
|
1838 | > def uisetup(ui): | |
1839 | > synopsis = b' GREPME [--foo] [-x]' |
|
1839 | > synopsis = b' GREPME [--foo] [-x]' | |
1840 | > docstring = ''' |
|
1840 | > docstring = ''' | |
1841 | > GREPME make sure that this is in the help! |
|
1841 | > GREPME make sure that this is in the help! | |
1842 | > ''' |
|
1842 | > ''' | |
1843 | > extensions.wrapcommand(commands.table, b'bookmarks', exbookmarks, |
|
1843 | > extensions.wrapcommand(commands.table, b'bookmarks', exbookmarks, | |
1844 | > synopsis, docstring) |
|
1844 | > synopsis, docstring) | |
1845 | > EOF |
|
1845 | > EOF | |
1846 | $ abspath=`pwd`/exthelp.py |
|
1846 | $ abspath=`pwd`/exthelp.py | |
1847 | $ echo '[extensions]' >> $HGRCPATH |
|
1847 | $ echo '[extensions]' >> $HGRCPATH | |
1848 | $ echo "exthelp = $abspath" >> $HGRCPATH |
|
1848 | $ echo "exthelp = $abspath" >> $HGRCPATH | |
1849 | $ cd exthelp |
|
1849 | $ cd exthelp | |
1850 | $ hg help bookmarks | grep GREPME |
|
1850 | $ hg help bookmarks | grep GREPME | |
1851 | hg bookmarks [OPTIONS]... [NAME]... GREPME [--foo] [-x] |
|
1851 | hg bookmarks [OPTIONS]... [NAME]... GREPME [--foo] [-x] | |
1852 | GREPME make sure that this is in the help! |
|
1852 | GREPME make sure that this is in the help! | |
1853 | $ cd .. |
|
1853 | $ cd .. | |
1854 |
|
1854 | |||
1855 | Show deprecation warning for the use of cmdutil.command |
|
1855 | Show deprecation warning for the use of cmdutil.command | |
1856 |
|
1856 | |||
1857 | $ cat > nonregistrar.py <<EOF |
|
1857 | $ cat > nonregistrar.py <<EOF | |
1858 | > from mercurial import cmdutil |
|
1858 | > from mercurial import cmdutil | |
1859 | > cmdtable = {} |
|
1859 | > cmdtable = {} | |
1860 | > command = cmdutil.command(cmdtable) |
|
1860 | > command = cmdutil.command(cmdtable) | |
1861 | > @command(b'foo', [], norepo=True) |
|
1861 | > @command(b'foo', [], norepo=True) | |
1862 | > def foo(ui): |
|
1862 | > def foo(ui): | |
1863 | > pass |
|
1863 | > pass | |
1864 | > EOF |
|
1864 | > EOF | |
1865 |
|
1865 | |||
1866 | Prohibit the use of unicode strings as the default value of options |
|
1866 | Prohibit the use of unicode strings as the default value of options | |
1867 |
|
1867 | |||
1868 | $ hg init $TESTTMP/opt-unicode-default |
|
1868 | $ hg init $TESTTMP/opt-unicode-default | |
1869 |
|
1869 | |||
1870 | $ cat > $TESTTMP/test_unicode_default_value.py << EOF |
|
1870 | $ cat > $TESTTMP/test_unicode_default_value.py << EOF | |
1871 | > from __future__ import print_function |
|
1871 | > from __future__ import print_function | |
1872 | > from mercurial import registrar |
|
1872 | > from mercurial import registrar | |
1873 | > cmdtable = {} |
|
1873 | > cmdtable = {} | |
1874 | > command = registrar.command(cmdtable) |
|
1874 | > command = registrar.command(cmdtable) | |
1875 | > @command(b'dummy', [(b'', b'opt', u'value', u'help')], 'ext [OPTIONS]') |
|
1875 | > @command(b'dummy', [(b'', b'opt', u'value', u'help')], 'ext [OPTIONS]') | |
1876 | > def ext(*args, **opts): |
|
1876 | > def ext(*args, **opts): | |
1877 | > print(opts[b'opt'], flush=True) |
|
1877 | > print(opts[b'opt'], flush=True) | |
1878 | > EOF |
|
1878 | > EOF | |
1879 | $ "$PYTHON" $TESTTMP/unflush.py $TESTTMP/test_unicode_default_value.py |
|
1879 | $ "$PYTHON" $TESTTMP/unflush.py $TESTTMP/test_unicode_default_value.py | |
1880 | $ cat > $TESTTMP/opt-unicode-default/.hg/hgrc << EOF |
|
1880 | $ cat > $TESTTMP/opt-unicode-default/.hg/hgrc << EOF | |
1881 | > [extensions] |
|
1881 | > [extensions] | |
1882 | > test_unicode_default_value = $TESTTMP/test_unicode_default_value.py |
|
1882 | > test_unicode_default_value = $TESTTMP/test_unicode_default_value.py | |
1883 | > EOF |
|
1883 | > EOF | |
1884 | $ hg -R $TESTTMP/opt-unicode-default dummy |
|
1884 | $ hg -R $TESTTMP/opt-unicode-default dummy | |
1885 | *** failed to import extension test_unicode_default_value from $TESTTMP/test_unicode_default_value.py: unicode *'value' found in cmdtable.dummy (glob) |
|
1885 | *** failed to import extension test_unicode_default_value from $TESTTMP/test_unicode_default_value.py: unicode *'value' found in cmdtable.dummy (glob) | |
1886 | *** (use b'' to make it byte string) |
|
1886 | *** (use b'' to make it byte string) | |
1887 | hg: unknown command 'dummy' |
|
1887 | hg: unknown command 'dummy' | |
1888 | (did you mean summary?) |
|
1888 | (did you mean summary?) | |
1889 | [255] |
|
1889 | [255] |
@@ -1,95 +1,98 b'' | |||||
1 | #testcases tree flat-fncache flat-nofncache |
|
1 | #testcases tree flat-fncache flat-nofncache | |
2 |
|
2 | |||
3 | Tests narrow stream clones |
|
3 | Tests narrow stream clones | |
4 |
|
4 | |||
5 | $ . "$TESTDIR/narrow-library.sh" |
|
5 | $ . "$TESTDIR/narrow-library.sh" | |
6 |
|
6 | |||
7 | #if tree |
|
7 | #if tree | |
8 | $ cat << EOF >> $HGRCPATH |
|
8 | $ cat << EOF >> $HGRCPATH | |
9 | > [experimental] |
|
9 | > [experimental] | |
10 | > treemanifest = 1 |
|
10 | > treemanifest = 1 | |
11 | > EOF |
|
11 | > EOF | |
12 | #endif |
|
12 | #endif | |
13 |
|
13 | |||
14 | #if flat-nofncache |
|
14 | #if flat-nofncache | |
15 | $ cat << EOF >> $HGRCPATH |
|
15 | $ cat << EOF >> $HGRCPATH | |
16 | > [format] |
|
16 | > [format] | |
17 | > usefncache = 0 |
|
17 | > usefncache = 0 | |
18 | > EOF |
|
18 | > EOF | |
19 | #endif |
|
19 | #endif | |
20 |
|
20 | |||
21 | Server setup |
|
21 | Server setup | |
22 |
|
22 | |||
23 | $ hg init master |
|
23 | $ hg init master | |
24 | $ cd master |
|
24 | $ cd master | |
25 | $ mkdir dir |
|
25 | $ mkdir dir | |
26 | $ mkdir dir/src |
|
26 | $ mkdir dir/src | |
27 | $ cd dir/src |
|
27 | $ cd dir/src | |
28 | $ for x in `$TESTDIR/seq.py 20`; do echo $x > "F$x"; hg add "F$x"; hg commit -m "Commit src $x"; done |
|
28 | $ for x in `$TESTDIR/seq.py 20`; do echo $x > "F$x"; hg add "F$x"; hg commit -m "Commit src $x"; done | |
29 |
|
29 | |||
30 | $ cd .. |
|
30 | $ cd .. | |
31 | $ mkdir tests |
|
31 | $ mkdir tests | |
32 | $ cd tests |
|
32 | $ cd tests | |
33 | $ for x in `$TESTDIR/seq.py 20`; do echo $x > "F$x"; hg add "F$x"; hg commit -m "Commit src $x"; done |
|
33 | $ for x in `$TESTDIR/seq.py 20`; do echo $x > "F$x"; hg add "F$x"; hg commit -m "Commit src $x"; done | |
34 | $ cd ../../.. |
|
34 | $ cd ../../.. | |
35 |
|
35 | |||
36 | Trying to stream clone when the server does not support it |
|
36 | Trying to stream clone when the server does not support it | |
37 |
|
37 | |||
38 | $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/F10" --stream |
|
38 | $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/F10" --stream | |
39 | streaming all changes |
|
39 | streaming all changes | |
40 | remote: abort: server does not support narrow stream clones |
|
40 | remote: abort: server does not support narrow stream clones | |
41 | abort: pull failed on remote |
|
41 | abort: pull failed on remote | |
42 | [255] |
|
42 | [255] | |
43 |
|
43 | |||
44 | Enable stream clone on the server |
|
44 | Enable stream clone on the server | |
45 |
|
45 | |||
46 | $ echo "[experimental]" >> master/.hg/hgrc |
|
46 | $ echo "[experimental]" >> master/.hg/hgrc | |
47 | $ echo "server.stream-narrow-clones=True" >> master/.hg/hgrc |
|
47 | $ echo "server.stream-narrow-clones=True" >> master/.hg/hgrc | |
48 |
|
48 | |||
49 | Cloning a specific file when stream clone is supported |
|
49 | Cloning a specific file when stream clone is supported | |
50 |
|
50 | |||
51 | $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/F10" --stream |
|
51 | $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/F10" --stream | |
52 | streaming all changes |
|
52 | streaming all changes | |
53 | * files to transfer, * KB of data (glob) |
|
53 | * files to transfer, * KB of data (glob) | |
54 | transferred * KB in * seconds (* */sec) (glob) |
|
54 | transferred * KB in * seconds (* */sec) (glob) | |
55 |
|
55 | |||
56 | $ cd narrow |
|
56 | $ cd narrow | |
57 | $ ls |
|
57 | $ ls | |
58 | $ hg tracked |
|
58 | $ hg tracked | |
59 | I path:dir/src/F10 |
|
59 | I path:dir/src/F10 | |
60 |
|
60 | |||
61 | Making sure we have the correct set of requirements |
|
61 | Making sure we have the correct set of requirements | |
62 |
|
62 | |||
63 | $ cat .hg/requires |
|
63 | $ cat .hg/requires | |
64 |
dotencode (tree |
|
64 | dotencode (tree !) | |
65 |
|
|
65 | dotencode (flat-fncache !) | |
|
66 | fncache (tree !) | |||
|
67 | fncache (flat-fncache !) | |||
66 | generaldelta |
|
68 | generaldelta | |
67 | narrowhg-experimental |
|
69 | narrowhg-experimental | |
68 | revlogv1 |
|
70 | revlogv1 | |
69 | sparserevlog |
|
71 | sparserevlog | |
70 | store |
|
72 | store | |
71 | treemanifest (tree !) |
|
73 | treemanifest (tree !) | |
72 |
|
74 | |||
73 | Making sure store has the required files |
|
75 | Making sure store has the required files | |
74 |
|
76 | |||
75 | $ ls .hg/store/ |
|
77 | $ ls .hg/store/ | |
76 | 00changelog.i |
|
78 | 00changelog.i | |
77 | 00manifest.i |
|
79 | 00manifest.i | |
78 | data (tree flat-fncache !) |
|
80 | data | |
79 |
fncache (tree |
|
81 | fncache (tree !) | |
|
82 | fncache (flat-fncache !) | |||
80 | meta (tree !) |
|
83 | meta (tree !) | |
81 | narrowspec |
|
84 | narrowspec | |
82 | undo |
|
85 | undo | |
83 | undo.backupfiles |
|
86 | undo.backupfiles | |
84 | undo.narrowspec |
|
87 | undo.narrowspec | |
85 | undo.phaseroots |
|
88 | undo.phaseroots | |
86 |
|
89 | |||
87 | Checking that repository has all the required data and not broken |
|
90 | Checking that repository has all the required data and not broken | |
88 |
|
91 | |||
89 | $ hg verify |
|
92 | $ hg verify | |
90 | checking changesets |
|
93 | checking changesets | |
91 | checking manifests |
|
94 | checking manifests | |
92 | checking directory manifests (tree !) |
|
95 | checking directory manifests (tree !) | |
93 | crosschecking files in changesets and manifests |
|
96 | crosschecking files in changesets and manifests | |
94 | checking files |
|
97 | checking files | |
95 | checked 40 changesets with 1 changes to 1 files |
|
98 | checked 40 changesets with 1 changes to 1 files |
@@ -1,425 +1,425 b'' | |||||
1 | #testcases tree flat |
|
1 | #testcases tree flat | |
2 | $ . "$TESTDIR/narrow-library.sh" |
|
2 | $ . "$TESTDIR/narrow-library.sh" | |
3 |
|
3 | |||
4 | #if tree |
|
4 | #if tree | |
5 | $ cat << EOF >> $HGRCPATH |
|
5 | $ cat << EOF >> $HGRCPATH | |
6 | > [experimental] |
|
6 | > [experimental] | |
7 | > treemanifest = 1 |
|
7 | > treemanifest = 1 | |
8 | > EOF |
|
8 | > EOF | |
9 | #endif |
|
9 | #endif | |
10 |
|
10 | |||
11 | $ hg init master |
|
11 | $ hg init master | |
12 | $ cd master |
|
12 | $ cd master | |
13 |
|
13 | |||
14 | $ mkdir inside |
|
14 | $ mkdir inside | |
15 | $ echo 'inside' > inside/f |
|
15 | $ echo 'inside' > inside/f | |
16 | $ hg add inside/f |
|
16 | $ hg add inside/f | |
17 | $ hg commit -m 'add inside' |
|
17 | $ hg commit -m 'add inside' | |
18 |
|
18 | |||
19 | $ mkdir widest |
|
19 | $ mkdir widest | |
20 | $ echo 'widest' > widest/f |
|
20 | $ echo 'widest' > widest/f | |
21 | $ hg add widest/f |
|
21 | $ hg add widest/f | |
22 | $ hg commit -m 'add widest' |
|
22 | $ hg commit -m 'add widest' | |
23 |
|
23 | |||
24 | $ mkdir outside |
|
24 | $ mkdir outside | |
25 | $ echo 'outside' > outside/f |
|
25 | $ echo 'outside' > outside/f | |
26 | $ hg add outside/f |
|
26 | $ hg add outside/f | |
27 | $ hg commit -m 'add outside' |
|
27 | $ hg commit -m 'add outside' | |
28 |
|
28 | |||
29 | $ cd .. |
|
29 | $ cd .. | |
30 |
|
30 | |||
31 | narrow clone the inside file |
|
31 | narrow clone the inside file | |
32 |
|
32 | |||
33 | $ hg clone --narrow ssh://user@dummy/master narrow |
|
33 | $ hg clone --narrow ssh://user@dummy/master narrow | |
34 | requesting all changes |
|
34 | requesting all changes | |
35 | adding changesets |
|
35 | adding changesets | |
36 | adding manifests |
|
36 | adding manifests | |
37 | adding file changes |
|
37 | adding file changes | |
38 | added 3 changesets with 0 changes to 0 files |
|
38 | added 3 changesets with 0 changes to 0 files | |
39 | new changesets *:* (glob) |
|
39 | new changesets *:* (glob) | |
40 | updating to branch default |
|
40 | updating to branch default | |
41 | 0 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
41 | 0 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
42 | $ cd narrow |
|
42 | $ cd narrow | |
43 | $ hg tracked |
|
43 | $ hg tracked | |
44 | $ hg files |
|
44 | $ hg files | |
45 | [1] |
|
45 | [1] | |
46 |
|
46 | |||
47 | widen from an empty clone |
|
47 | widen from an empty clone | |
48 |
|
48 | |||
49 | $ hg tracked --addinclude inside |
|
49 | $ hg tracked --addinclude inside | |
50 | comparing with ssh://user@dummy/master |
|
50 | comparing with ssh://user@dummy/master | |
51 | searching for changes |
|
51 | searching for changes | |
52 | adding changesets |
|
52 | adding changesets | |
53 | adding manifests |
|
53 | adding manifests | |
54 | adding file changes |
|
54 | adding file changes | |
55 | added 0 changesets with 1 changes to 1 files |
|
55 | added 0 changesets with 1 changes to 1 files | |
56 | $ hg tracked |
|
56 | $ hg tracked | |
57 | I path:inside |
|
57 | I path:inside | |
58 | $ ls |
|
58 | $ ls | |
59 | inside |
|
59 | inside | |
60 | $ cat inside/f |
|
60 | $ cat inside/f | |
61 | inside |
|
61 | inside | |
62 | $ cd .. |
|
62 | $ cd .. | |
63 |
|
63 | |||
64 | add more upstream files which we will include in a wider narrow spec |
|
64 | add more upstream files which we will include in a wider narrow spec | |
65 |
|
65 | |||
66 | $ cd master |
|
66 | $ cd master | |
67 |
|
67 | |||
68 | $ mkdir wider |
|
68 | $ mkdir wider | |
69 | $ echo 'wider' > wider/f |
|
69 | $ echo 'wider' > wider/f | |
70 | $ hg add wider/f |
|
70 | $ hg add wider/f | |
71 | $ echo 'widest v2' > widest/f |
|
71 | $ echo 'widest v2' > widest/f | |
72 | $ hg commit -m 'add wider, update widest' |
|
72 | $ hg commit -m 'add wider, update widest' | |
73 |
|
73 | |||
74 | $ echo 'widest v3' > widest/f |
|
74 | $ echo 'widest v3' > widest/f | |
75 | $ hg commit -m 'update widest v3' |
|
75 | $ hg commit -m 'update widest v3' | |
76 |
|
76 | |||
77 | $ echo 'inside v2' > inside/f |
|
77 | $ echo 'inside v2' > inside/f | |
78 | $ hg commit -m 'update inside' |
|
78 | $ hg commit -m 'update inside' | |
79 |
|
79 | |||
80 | $ mkdir outside2 |
|
80 | $ mkdir outside2 | |
81 | $ echo 'outside2' > outside2/f |
|
81 | $ echo 'outside2' > outside2/f | |
82 | $ hg add outside2/f |
|
82 | $ hg add outside2/f | |
83 | $ hg commit -m 'add outside2' |
|
83 | $ hg commit -m 'add outside2' | |
84 |
|
84 | |||
85 | $ echo 'widest v4' > widest/f |
|
85 | $ echo 'widest v4' > widest/f | |
86 | $ hg commit -m 'update widest v4' |
|
86 | $ hg commit -m 'update widest v4' | |
87 |
|
87 | |||
88 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
88 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
89 | 7: update widest v4 |
|
89 | 7: update widest v4 | |
90 | 6: add outside2 |
|
90 | 6: add outside2 | |
91 | 5: update inside |
|
91 | 5: update inside | |
92 | 4: update widest v3 |
|
92 | 4: update widest v3 | |
93 | 3: add wider, update widest |
|
93 | 3: add wider, update widest | |
94 | 2: add outside |
|
94 | 2: add outside | |
95 | 1: add widest |
|
95 | 1: add widest | |
96 | 0: add inside |
|
96 | 0: add inside | |
97 |
|
97 | |||
98 | $ cd .. |
|
98 | $ cd .. | |
99 |
|
99 | |||
100 | Widen the narrow spec to see the widest file. This should not get the newly |
|
100 | Widen the narrow spec to see the widest file. This should not get the newly | |
101 | added upstream revisions. |
|
101 | added upstream revisions. | |
102 |
|
102 | |||
103 | $ cd narrow |
|
103 | $ cd narrow | |
104 | $ hg id -n |
|
104 | $ hg id -n | |
105 | 2 |
|
105 | 2 | |
106 |
|
106 | |||
107 | $ hg tracked --addinclude widest/f --debug |
|
107 | $ hg tracked --addinclude widest/f --debug | |
108 | comparing with ssh://user@dummy/master |
|
108 | comparing with ssh://user@dummy/master | |
109 | running python "*dummyssh" *user@dummy* *hg -R master serve --stdio* (glob) |
|
109 | running python "*dummyssh" *user@dummy* *hg -R master serve --stdio* (glob) | |
110 | sending hello command |
|
110 | sending hello command | |
111 | sending between command |
|
111 | sending between command | |
112 | remote: * (glob) |
|
112 | remote: * (glob) | |
113 | remote: capabilities: * (glob) |
|
113 | remote: capabilities: * (glob) | |
114 | remote: 1 |
|
114 | remote: 1 | |
115 | sending protocaps command |
|
115 | sending protocaps command | |
116 | query 1; heads |
|
116 | query 1; heads | |
117 | sending batch command |
|
117 | sending batch command | |
118 | searching for changes |
|
118 | searching for changes | |
119 | all local heads known remotely |
|
119 | all local heads known remotely | |
120 | sending narrow_widen command |
|
120 | sending narrow_widen command | |
121 | bundle2-input-bundle: with-transaction |
|
121 | bundle2-input-bundle: with-transaction | |
122 | bundle2-input-part: "changegroup" (params: * mandatory) supported (glob) |
|
122 | bundle2-input-part: "changegroup" (params: * mandatory) supported (glob) | |
123 | adding changesets |
|
123 | adding changesets | |
124 | adding manifests |
|
124 | adding manifests | |
125 | adding widest/ revisions (tree !) |
|
125 | adding widest/ revisions (tree !) | |
126 | adding file changes |
|
126 | adding file changes | |
127 |
adding widest/f revisions |
|
127 | adding widest/f revisions | |
128 | added 0 changesets with 1 changes to 1 files |
|
128 | added 0 changesets with 1 changes to 1 files | |
129 | bundle2-input-part: total payload size * (glob) |
|
129 | bundle2-input-part: total payload size * (glob) | |
130 | bundle2-input-bundle: 0 parts total |
|
130 | bundle2-input-bundle: 0 parts total | |
131 | widest/f: narrowspec updated -> g |
|
131 | widest/f: narrowspec updated -> g | |
132 | getting widest/f |
|
132 | getting widest/f | |
133 | $ hg tracked |
|
133 | $ hg tracked | |
134 | I path:inside |
|
134 | I path:inside | |
135 | I path:widest/f |
|
135 | I path:widest/f | |
136 |
|
136 | |||
137 | $ cat widest/f |
|
137 | $ cat widest/f | |
138 | widest |
|
138 | widest | |
139 |
|
139 | |||
140 | $ hg id -n |
|
140 | $ hg id -n | |
141 | 2 |
|
141 | 2 | |
142 |
|
142 | |||
143 | Test that extending already included files should not call narrow_widen |
|
143 | Test that extending already included files should not call narrow_widen | |
144 | wireprotocol command |
|
144 | wireprotocol command | |
145 |
|
145 | |||
146 | $ hg tracked --addinclude widest/f |
|
146 | $ hg tracked --addinclude widest/f | |
147 | nothing to widen or narrow |
|
147 | nothing to widen or narrow | |
148 |
|
148 | |||
149 | Pull down the newly added upstream revision. |
|
149 | Pull down the newly added upstream revision. | |
150 |
|
150 | |||
151 | $ hg pull |
|
151 | $ hg pull | |
152 | pulling from ssh://user@dummy/master |
|
152 | pulling from ssh://user@dummy/master | |
153 | searching for changes |
|
153 | searching for changes | |
154 | adding changesets |
|
154 | adding changesets | |
155 | adding manifests |
|
155 | adding manifests | |
156 | adding file changes |
|
156 | adding file changes | |
157 | added 5 changesets with 4 changes to 2 files |
|
157 | added 5 changesets with 4 changes to 2 files | |
158 | new changesets *:* (glob) |
|
158 | new changesets *:* (glob) | |
159 | (run 'hg update' to get a working copy) |
|
159 | (run 'hg update' to get a working copy) | |
160 | $ hg update -r 'desc("add wider")' |
|
160 | $ hg update -r 'desc("add wider")' | |
161 | 1 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
161 | 1 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
162 |
|
162 | |||
163 | $ cat widest/f |
|
163 | $ cat widest/f | |
164 | widest v2 |
|
164 | widest v2 | |
165 |
|
165 | |||
166 | $ hg update -r 'desc("update inside")' |
|
166 | $ hg update -r 'desc("update inside")' | |
167 | 2 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
167 | 2 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
168 | $ cat widest/f |
|
168 | $ cat widest/f | |
169 | widest v3 |
|
169 | widest v3 | |
170 | $ cat inside/f |
|
170 | $ cat inside/f | |
171 | inside v2 |
|
171 | inside v2 | |
172 |
|
172 | |||
173 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
173 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
174 | 7: update widest v4 |
|
174 | 7: update widest v4 | |
175 | 6: add outside2 |
|
175 | 6: add outside2 | |
176 | 5: update inside |
|
176 | 5: update inside | |
177 | 4: update widest v3 |
|
177 | 4: update widest v3 | |
178 | 3: add wider, update widest |
|
178 | 3: add wider, update widest | |
179 | 2: add outside |
|
179 | 2: add outside | |
180 | 1: add widest |
|
180 | 1: add widest | |
181 | 0: add inside |
|
181 | 0: add inside | |
182 |
|
182 | |||
183 | Check that widening with a newline fails |
|
183 | Check that widening with a newline fails | |
184 |
|
184 | |||
185 | $ hg tracked --addinclude 'widest |
|
185 | $ hg tracked --addinclude 'widest | |
186 | > ' |
|
186 | > ' | |
187 | abort: newlines are not allowed in narrowspec paths |
|
187 | abort: newlines are not allowed in narrowspec paths | |
188 | [255] |
|
188 | [255] | |
189 |
|
189 | |||
190 | widen the narrow spec to include the wider file |
|
190 | widen the narrow spec to include the wider file | |
191 |
|
191 | |||
192 | $ hg tracked --addinclude wider |
|
192 | $ hg tracked --addinclude wider | |
193 | comparing with ssh://user@dummy/master |
|
193 | comparing with ssh://user@dummy/master | |
194 | searching for changes |
|
194 | searching for changes | |
195 | adding changesets |
|
195 | adding changesets | |
196 | adding manifests |
|
196 | adding manifests | |
197 | adding file changes |
|
197 | adding file changes | |
198 | added 0 changesets with 1 changes to 1 files |
|
198 | added 0 changesets with 1 changes to 1 files | |
199 | $ hg tracked |
|
199 | $ hg tracked | |
200 | I path:inside |
|
200 | I path:inside | |
201 | I path:wider |
|
201 | I path:wider | |
202 | I path:widest/f |
|
202 | I path:widest/f | |
203 | $ hg update 'desc("add widest")' |
|
203 | $ hg update 'desc("add widest")' | |
204 | 2 files updated, 0 files merged, 1 files removed, 0 files unresolved |
|
204 | 2 files updated, 0 files merged, 1 files removed, 0 files unresolved | |
205 | $ cat widest/f |
|
205 | $ cat widest/f | |
206 | widest |
|
206 | widest | |
207 | $ hg update 'desc("add wider, update widest")' |
|
207 | $ hg update 'desc("add wider, update widest")' | |
208 | 2 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
208 | 2 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
209 | $ cat wider/f |
|
209 | $ cat wider/f | |
210 | wider |
|
210 | wider | |
211 | $ cat widest/f |
|
211 | $ cat widest/f | |
212 | widest v2 |
|
212 | widest v2 | |
213 | $ hg update 'desc("update widest v3")' |
|
213 | $ hg update 'desc("update widest v3")' | |
214 | 1 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
214 | 1 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
215 | $ cat widest/f |
|
215 | $ cat widest/f | |
216 | widest v3 |
|
216 | widest v3 | |
217 | $ hg update 'desc("update widest v4")' |
|
217 | $ hg update 'desc("update widest v4")' | |
218 | 2 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
218 | 2 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
219 | $ cat widest/f |
|
219 | $ cat widest/f | |
220 | widest v4 |
|
220 | widest v4 | |
221 |
|
221 | |||
222 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
222 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
223 | 7: update widest v4 |
|
223 | 7: update widest v4 | |
224 | 6: add outside2 |
|
224 | 6: add outside2 | |
225 | 5: update inside |
|
225 | 5: update inside | |
226 | 4: update widest v3 |
|
226 | 4: update widest v3 | |
227 | 3: add wider, update widest |
|
227 | 3: add wider, update widest | |
228 | 2: add outside |
|
228 | 2: add outside | |
229 | 1: add widest |
|
229 | 1: add widest | |
230 | 0: add inside |
|
230 | 0: add inside | |
231 |
|
231 | |||
232 | separate suite of tests: files from 0-10 modified in changes 0-10. This allows |
|
232 | separate suite of tests: files from 0-10 modified in changes 0-10. This allows | |
233 | more obvious precise tests tickling particular corner cases. |
|
233 | more obvious precise tests tickling particular corner cases. | |
234 |
|
234 | |||
235 | $ cd .. |
|
235 | $ cd .. | |
236 | $ hg init upstream |
|
236 | $ hg init upstream | |
237 | $ cd upstream |
|
237 | $ cd upstream | |
238 | $ for x in `$TESTDIR/seq.py 0 10` |
|
238 | $ for x in `$TESTDIR/seq.py 0 10` | |
239 | > do |
|
239 | > do | |
240 | > mkdir d$x |
|
240 | > mkdir d$x | |
241 | > echo $x > d$x/f |
|
241 | > echo $x > d$x/f | |
242 | > hg add d$x/f |
|
242 | > hg add d$x/f | |
243 | > hg commit -m "add d$x/f" |
|
243 | > hg commit -m "add d$x/f" | |
244 | > done |
|
244 | > done | |
245 | $ hg log -T "{rev}: {desc}\n" |
|
245 | $ hg log -T "{rev}: {desc}\n" | |
246 | 10: add d10/f |
|
246 | 10: add d10/f | |
247 | 9: add d9/f |
|
247 | 9: add d9/f | |
248 | 8: add d8/f |
|
248 | 8: add d8/f | |
249 | 7: add d7/f |
|
249 | 7: add d7/f | |
250 | 6: add d6/f |
|
250 | 6: add d6/f | |
251 | 5: add d5/f |
|
251 | 5: add d5/f | |
252 | 4: add d4/f |
|
252 | 4: add d4/f | |
253 | 3: add d3/f |
|
253 | 3: add d3/f | |
254 | 2: add d2/f |
|
254 | 2: add d2/f | |
255 | 1: add d1/f |
|
255 | 1: add d1/f | |
256 | 0: add d0/f |
|
256 | 0: add d0/f | |
257 |
|
257 | |||
258 | make narrow clone with every third node. |
|
258 | make narrow clone with every third node. | |
259 |
|
259 | |||
260 | $ cd .. |
|
260 | $ cd .. | |
261 | $ hg clone --narrow ssh://user@dummy/upstream narrow2 --include d0 --include d3 --include d6 --include d9 |
|
261 | $ hg clone --narrow ssh://user@dummy/upstream narrow2 --include d0 --include d3 --include d6 --include d9 | |
262 | requesting all changes |
|
262 | requesting all changes | |
263 | adding changesets |
|
263 | adding changesets | |
264 | adding manifests |
|
264 | adding manifests | |
265 | adding file changes |
|
265 | adding file changes | |
266 | added 11 changesets with 4 changes to 4 files |
|
266 | added 11 changesets with 4 changes to 4 files | |
267 | new changesets *:* (glob) |
|
267 | new changesets *:* (glob) | |
268 | updating to branch default |
|
268 | updating to branch default | |
269 | 4 files updated, 0 files merged, 0 files removed, 0 files unresolved |
|
269 | 4 files updated, 0 files merged, 0 files removed, 0 files unresolved | |
270 | $ cd narrow2 |
|
270 | $ cd narrow2 | |
271 | $ hg tracked |
|
271 | $ hg tracked | |
272 | I path:d0 |
|
272 | I path:d0 | |
273 | I path:d3 |
|
273 | I path:d3 | |
274 | I path:d6 |
|
274 | I path:d6 | |
275 | I path:d9 |
|
275 | I path:d9 | |
276 | $ hg verify |
|
276 | $ hg verify | |
277 | checking changesets |
|
277 | checking changesets | |
278 | checking manifests |
|
278 | checking manifests | |
279 | checking directory manifests (tree !) |
|
279 | checking directory manifests (tree !) | |
280 | crosschecking files in changesets and manifests |
|
280 | crosschecking files in changesets and manifests | |
281 | checking files |
|
281 | checking files | |
282 | checked 11 changesets with 4 changes to 4 files |
|
282 | checked 11 changesets with 4 changes to 4 files | |
283 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
283 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
284 | 10: add d10/f |
|
284 | 10: add d10/f | |
285 | 9: add d9/f |
|
285 | 9: add d9/f | |
286 | 8: add d8/f |
|
286 | 8: add d8/f | |
287 | 7: add d7/f |
|
287 | 7: add d7/f | |
288 | 6: add d6/f |
|
288 | 6: add d6/f | |
289 | 5: add d5/f |
|
289 | 5: add d5/f | |
290 | 4: add d4/f |
|
290 | 4: add d4/f | |
291 | 3: add d3/f |
|
291 | 3: add d3/f | |
292 | 2: add d2/f |
|
292 | 2: add d2/f | |
293 | 1: add d1/f |
|
293 | 1: add d1/f | |
294 | 0: add d0/f |
|
294 | 0: add d0/f | |
295 | $ hg tracked --addinclude d1 |
|
295 | $ hg tracked --addinclude d1 | |
296 | comparing with ssh://user@dummy/upstream |
|
296 | comparing with ssh://user@dummy/upstream | |
297 | searching for changes |
|
297 | searching for changes | |
298 | adding changesets |
|
298 | adding changesets | |
299 | adding manifests |
|
299 | adding manifests | |
300 | adding file changes |
|
300 | adding file changes | |
301 | added 0 changesets with 1 changes to 1 files |
|
301 | added 0 changesets with 1 changes to 1 files | |
302 | $ hg tracked |
|
302 | $ hg tracked | |
303 | I path:d0 |
|
303 | I path:d0 | |
304 | I path:d1 |
|
304 | I path:d1 | |
305 | I path:d3 |
|
305 | I path:d3 | |
306 | I path:d6 |
|
306 | I path:d6 | |
307 | I path:d9 |
|
307 | I path:d9 | |
308 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
308 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
309 | 10: add d10/f |
|
309 | 10: add d10/f | |
310 | 9: add d9/f |
|
310 | 9: add d9/f | |
311 | 8: add d8/f |
|
311 | 8: add d8/f | |
312 | 7: add d7/f |
|
312 | 7: add d7/f | |
313 | 6: add d6/f |
|
313 | 6: add d6/f | |
314 | 5: add d5/f |
|
314 | 5: add d5/f | |
315 | 4: add d4/f |
|
315 | 4: add d4/f | |
316 | 3: add d3/f |
|
316 | 3: add d3/f | |
317 | 2: add d2/f |
|
317 | 2: add d2/f | |
318 | 1: add d1/f |
|
318 | 1: add d1/f | |
319 | 0: add d0/f |
|
319 | 0: add d0/f | |
320 |
|
320 | |||
321 | Verify shouldn't claim the repo is corrupt after a widen. |
|
321 | Verify shouldn't claim the repo is corrupt after a widen. | |
322 |
|
322 | |||
323 | $ hg verify |
|
323 | $ hg verify | |
324 | checking changesets |
|
324 | checking changesets | |
325 | checking manifests |
|
325 | checking manifests | |
326 | checking directory manifests (tree !) |
|
326 | checking directory manifests (tree !) | |
327 | crosschecking files in changesets and manifests |
|
327 | crosschecking files in changesets and manifests | |
328 | checking files |
|
328 | checking files | |
329 | checked 11 changesets with 5 changes to 5 files |
|
329 | checked 11 changesets with 5 changes to 5 files | |
330 |
|
330 | |||
331 | Widening preserves parent of local commit |
|
331 | Widening preserves parent of local commit | |
332 |
|
332 | |||
333 | $ cd .. |
|
333 | $ cd .. | |
334 | $ hg clone -q --narrow ssh://user@dummy/upstream narrow3 --include d2 -r 2 |
|
334 | $ hg clone -q --narrow ssh://user@dummy/upstream narrow3 --include d2 -r 2 | |
335 | $ cd narrow3 |
|
335 | $ cd narrow3 | |
336 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
336 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
337 | 2: add d2/f |
|
337 | 2: add d2/f | |
338 | 1: add d1/f |
|
338 | 1: add d1/f | |
339 | 0: add d0/f |
|
339 | 0: add d0/f | |
340 | $ hg pull -q -r 3 |
|
340 | $ hg pull -q -r 3 | |
341 | $ hg co -q tip |
|
341 | $ hg co -q tip | |
342 | $ hg pull -q -r 4 |
|
342 | $ hg pull -q -r 4 | |
343 | $ echo local > d2/f |
|
343 | $ echo local > d2/f | |
344 | $ hg ci -m local |
|
344 | $ hg ci -m local | |
345 | created new head |
|
345 | created new head | |
346 | $ hg tracked -q --addinclude d0 --addinclude d9 |
|
346 | $ hg tracked -q --addinclude d0 --addinclude d9 | |
347 |
|
347 | |||
348 | Widening preserves bookmarks |
|
348 | Widening preserves bookmarks | |
349 |
|
349 | |||
350 | $ cd .. |
|
350 | $ cd .. | |
351 | $ hg clone -q --narrow ssh://user@dummy/upstream narrow-bookmarks --include d4 |
|
351 | $ hg clone -q --narrow ssh://user@dummy/upstream narrow-bookmarks --include d4 | |
352 | $ cd narrow-bookmarks |
|
352 | $ cd narrow-bookmarks | |
353 | $ echo local > d4/f |
|
353 | $ echo local > d4/f | |
354 | $ hg ci -m local |
|
354 | $ hg ci -m local | |
355 | $ hg bookmarks bookmark |
|
355 | $ hg bookmarks bookmark | |
356 | $ hg bookmarks |
|
356 | $ hg bookmarks | |
357 | * bookmark 11:* (glob) |
|
357 | * bookmark 11:* (glob) | |
358 | $ hg -q tracked --addinclude d2 |
|
358 | $ hg -q tracked --addinclude d2 | |
359 | $ hg bookmarks |
|
359 | $ hg bookmarks | |
360 | * bookmark 11:* (glob) |
|
360 | * bookmark 11:* (glob) | |
361 | $ hg log -r bookmark -T '{desc}\n' |
|
361 | $ hg log -r bookmark -T '{desc}\n' | |
362 | local |
|
362 | local | |
363 |
|
363 | |||
364 | Widening that fails can be recovered from |
|
364 | Widening that fails can be recovered from | |
365 |
|
365 | |||
366 | $ cd .. |
|
366 | $ cd .. | |
367 | $ hg clone -q --narrow ssh://user@dummy/upstream interrupted --include d0 |
|
367 | $ hg clone -q --narrow ssh://user@dummy/upstream interrupted --include d0 | |
368 | $ cd interrupted |
|
368 | $ cd interrupted | |
369 | $ echo local > d0/f |
|
369 | $ echo local > d0/f | |
370 | $ hg ci -m local |
|
370 | $ hg ci -m local | |
371 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
371 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
372 | 11: local |
|
372 | 11: local | |
373 | 10: add d10/f |
|
373 | 10: add d10/f | |
374 | 9: add d9/f |
|
374 | 9: add d9/f | |
375 | 8: add d8/f |
|
375 | 8: add d8/f | |
376 | 7: add d7/f |
|
376 | 7: add d7/f | |
377 | 6: add d6/f |
|
377 | 6: add d6/f | |
378 | 5: add d5/f |
|
378 | 5: add d5/f | |
379 | 4: add d4/f |
|
379 | 4: add d4/f | |
380 | 3: add d3/f |
|
380 | 3: add d3/f | |
381 | 2: add d2/f |
|
381 | 2: add d2/f | |
382 | 1: add d1/f |
|
382 | 1: add d1/f | |
383 | 0: add d0/f |
|
383 | 0: add d0/f | |
384 | $ hg bookmarks bookmark |
|
384 | $ hg bookmarks bookmark | |
385 | $ hg --config hooks.pretxnchangegroup.bad=false tracked --addinclude d1 |
|
385 | $ hg --config hooks.pretxnchangegroup.bad=false tracked --addinclude d1 | |
386 | comparing with ssh://user@dummy/upstream |
|
386 | comparing with ssh://user@dummy/upstream | |
387 | searching for changes |
|
387 | searching for changes | |
388 | adding changesets |
|
388 | adding changesets | |
389 | adding manifests |
|
389 | adding manifests | |
390 | adding file changes |
|
390 | adding file changes | |
391 | added 0 changesets with 1 changes to 1 files |
|
391 | added 0 changesets with 1 changes to 1 files | |
392 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
392 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
393 | 11: local |
|
393 | 11: local | |
394 | 10: add d10/f |
|
394 | 10: add d10/f | |
395 | 9: add d9/f |
|
395 | 9: add d9/f | |
396 | 8: add d8/f |
|
396 | 8: add d8/f | |
397 | 7: add d7/f |
|
397 | 7: add d7/f | |
398 | 6: add d6/f |
|
398 | 6: add d6/f | |
399 | 5: add d5/f |
|
399 | 5: add d5/f | |
400 | 4: add d4/f |
|
400 | 4: add d4/f | |
401 | 3: add d3/f |
|
401 | 3: add d3/f | |
402 | 2: add d2/f |
|
402 | 2: add d2/f | |
403 | 1: add d1/f |
|
403 | 1: add d1/f | |
404 | 0: add d0/f |
|
404 | 0: add d0/f | |
405 | $ hg bookmarks |
|
405 | $ hg bookmarks | |
406 | * bookmark 11:* (glob) |
|
406 | * bookmark 11:* (glob) | |
407 | $ hg unbundle .hg/strip-backup/*-widen.hg |
|
407 | $ hg unbundle .hg/strip-backup/*-widen.hg | |
408 | abort: .hg/strip-backup/*-widen.hg: $ENOTDIR$ (windows !) |
|
408 | abort: .hg/strip-backup/*-widen.hg: $ENOTDIR$ (windows !) | |
409 | abort: $ENOENT$: '.hg/strip-backup/*-widen.hg' (no-windows !) |
|
409 | abort: $ENOENT$: '.hg/strip-backup/*-widen.hg' (no-windows !) | |
410 | [255] |
|
410 | [255] | |
411 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" |
|
411 | $ hg log -T "{if(ellipsis, '...')}{rev}: {desc}\n" | |
412 | 11: local |
|
412 | 11: local | |
413 | 10: add d10/f |
|
413 | 10: add d10/f | |
414 | 9: add d9/f |
|
414 | 9: add d9/f | |
415 | 8: add d8/f |
|
415 | 8: add d8/f | |
416 | 7: add d7/f |
|
416 | 7: add d7/f | |
417 | 6: add d6/f |
|
417 | 6: add d6/f | |
418 | 5: add d5/f |
|
418 | 5: add d5/f | |
419 | 4: add d4/f |
|
419 | 4: add d4/f | |
420 | 3: add d3/f |
|
420 | 3: add d3/f | |
421 | 2: add d2/f |
|
421 | 2: add d2/f | |
422 | 1: add d1/f |
|
422 | 1: add d1/f | |
423 | 0: add d0/f |
|
423 | 0: add d0/f | |
424 | $ hg bookmarks |
|
424 | $ hg bookmarks | |
425 | * bookmark 11:* (glob) |
|
425 | * bookmark 11:* (glob) |
@@ -1,1938 +1,2005 b'' | |||||
1 | This file tests the behavior of run-tests.py itself. |
|
1 | This file tests the behavior of run-tests.py itself. | |
2 |
|
2 | |||
3 | Avoid interference from actual test env: |
|
3 | Avoid interference from actual test env: | |
4 |
|
4 | |||
5 | $ . "$TESTDIR/helper-runtests.sh" |
|
5 | $ . "$TESTDIR/helper-runtests.sh" | |
6 |
|
6 | |||
7 | Smoke test with install |
|
7 | Smoke test with install | |
8 | ============ |
|
8 | ============ | |
9 | $ "$PYTHON" $TESTDIR/run-tests.py $HGTEST_RUN_TESTS_PURE -l |
|
9 | $ "$PYTHON" $TESTDIR/run-tests.py $HGTEST_RUN_TESTS_PURE -l | |
10 | running 0 tests using 0 parallel processes |
|
10 | running 0 tests using 0 parallel processes | |
11 |
|
11 | |||
12 | # Ran 0 tests, 0 skipped, 0 failed. |
|
12 | # Ran 0 tests, 0 skipped, 0 failed. | |
13 |
|
13 | |||
14 | Define a helper to avoid the install step |
|
14 | Define a helper to avoid the install step | |
15 | ============= |
|
15 | ============= | |
16 | $ rt() |
|
16 | $ rt() | |
17 | > { |
|
17 | > { | |
18 | > "$PYTHON" $TESTDIR/run-tests.py --with-hg=`which hg` -j1 "$@" |
|
18 | > "$PYTHON" $TESTDIR/run-tests.py --with-hg=`which hg` -j1 "$@" | |
19 | > } |
|
19 | > } | |
20 |
|
20 | |||
21 | error paths |
|
21 | error paths | |
22 |
|
22 | |||
23 | #if symlink |
|
23 | #if symlink | |
24 | $ ln -s `which true` hg |
|
24 | $ ln -s `which true` hg | |
25 | $ "$PYTHON" $TESTDIR/run-tests.py --with-hg=./hg |
|
25 | $ "$PYTHON" $TESTDIR/run-tests.py --with-hg=./hg | |
26 | warning: --with-hg should specify an hg script |
|
26 | warning: --with-hg should specify an hg script | |
27 | running 0 tests using 0 parallel processes |
|
27 | running 0 tests using 0 parallel processes | |
28 |
|
28 | |||
29 | # Ran 0 tests, 0 skipped, 0 failed. |
|
29 | # Ran 0 tests, 0 skipped, 0 failed. | |
30 | $ rm hg |
|
30 | $ rm hg | |
31 | #endif |
|
31 | #endif | |
32 |
|
32 | |||
33 | #if execbit |
|
33 | #if execbit | |
34 | $ touch hg |
|
34 | $ touch hg | |
35 | $ "$PYTHON" $TESTDIR/run-tests.py --with-hg=./hg |
|
35 | $ "$PYTHON" $TESTDIR/run-tests.py --with-hg=./hg | |
36 | usage: run-tests.py [options] [tests] |
|
36 | usage: run-tests.py [options] [tests] | |
37 | run-tests.py: error: --with-hg must specify an executable hg script |
|
37 | run-tests.py: error: --with-hg must specify an executable hg script | |
38 | [2] |
|
38 | [2] | |
39 | $ rm hg |
|
39 | $ rm hg | |
40 | #endif |
|
40 | #endif | |
41 |
|
41 | |||
42 | Features for testing optional lines |
|
42 | Features for testing optional lines | |
43 | =================================== |
|
43 | =================================== | |
44 |
|
44 | |||
45 | $ cat > hghaveaddon.py <<EOF |
|
45 | $ cat > hghaveaddon.py <<EOF | |
46 | > import hghave |
|
46 | > import hghave | |
47 | > @hghave.check("custom", "custom hghave feature") |
|
47 | > @hghave.check("custom", "custom hghave feature") | |
48 | > def has_custom(): |
|
48 | > def has_custom(): | |
49 | > return True |
|
49 | > return True | |
50 | > @hghave.check("missing", "missing hghave feature") |
|
50 | > @hghave.check("missing", "missing hghave feature") | |
51 | > def has_missing(): |
|
51 | > def has_missing(): | |
52 | > return False |
|
52 | > return False | |
53 | > EOF |
|
53 | > EOF | |
54 |
|
54 | |||
55 | an empty test |
|
55 | an empty test | |
56 | ======================= |
|
56 | ======================= | |
57 |
|
57 | |||
58 | $ touch test-empty.t |
|
58 | $ touch test-empty.t | |
59 | $ rt |
|
59 | $ rt | |
60 | running 1 tests using 1 parallel processes |
|
60 | running 1 tests using 1 parallel processes | |
61 | . |
|
61 | . | |
62 | # Ran 1 tests, 0 skipped, 0 failed. |
|
62 | # Ran 1 tests, 0 skipped, 0 failed. | |
63 | $ rm test-empty.t |
|
63 | $ rm test-empty.t | |
64 |
|
64 | |||
65 | a succesful test |
|
65 | a succesful test | |
66 | ======================= |
|
66 | ======================= | |
67 |
|
67 | |||
68 | $ cat > test-success.t << EOF |
|
68 | $ cat > test-success.t << EOF | |
69 | > $ echo babar |
|
69 | > $ echo babar | |
70 | > babar |
|
70 | > babar | |
71 | > $ echo xyzzy |
|
71 | > $ echo xyzzy | |
72 | > dont_print (?) |
|
72 | > dont_print (?) | |
73 | > nothing[42]line (re) (?) |
|
73 | > nothing[42]line (re) (?) | |
74 | > never*happens (glob) (?) |
|
74 | > never*happens (glob) (?) | |
75 | > more_nothing (?) |
|
75 | > more_nothing (?) | |
76 | > xyzzy |
|
76 | > xyzzy | |
77 | > nor this (?) |
|
77 | > nor this (?) | |
78 | > $ printf 'abc\ndef\nxyz\n' |
|
78 | > $ printf 'abc\ndef\nxyz\n' | |
79 | > 123 (?) |
|
79 | > 123 (?) | |
80 | > abc |
|
80 | > abc | |
81 | > def (?) |
|
81 | > def (?) | |
82 | > 456 (?) |
|
82 | > 456 (?) | |
83 | > xyz |
|
83 | > xyz | |
84 | > $ printf 'zyx\nwvu\ntsr\n' |
|
84 | > $ printf 'zyx\nwvu\ntsr\n' | |
85 | > abc (?) |
|
85 | > abc (?) | |
86 | > zyx (custom !) |
|
86 | > zyx (custom !) | |
87 | > wvu |
|
87 | > wvu | |
88 | > no_print (no-custom !) |
|
88 | > no_print (no-custom !) | |
89 | > tsr (no-missing !) |
|
89 | > tsr (no-missing !) | |
90 | > missing (missing !) |
|
90 | > missing (missing !) | |
91 | > EOF |
|
91 | > EOF | |
92 |
|
92 | |||
93 | $ rt |
|
93 | $ rt | |
94 | running 1 tests using 1 parallel processes |
|
94 | running 1 tests using 1 parallel processes | |
95 | . |
|
95 | . | |
96 | # Ran 1 tests, 0 skipped, 0 failed. |
|
96 | # Ran 1 tests, 0 skipped, 0 failed. | |
97 |
|
97 | |||
98 | failing test |
|
98 | failing test | |
99 | ================== |
|
99 | ================== | |
100 |
|
100 | |||
101 | test churn with globs |
|
101 | test churn with globs | |
102 | $ cat > test-failure.t <<EOF |
|
102 | $ cat > test-failure.t <<EOF | |
103 | > $ echo "bar-baz"; echo "bar-bad"; echo foo |
|
103 | > $ echo "bar-baz"; echo "bar-bad"; echo foo | |
104 | > bar*bad (glob) |
|
104 | > bar*bad (glob) | |
105 | > bar*baz (glob) |
|
105 | > bar*baz (glob) | |
106 | > | fo (re) |
|
106 | > | fo (re) | |
107 | > EOF |
|
107 | > EOF | |
108 | $ rt test-failure.t |
|
108 | $ rt test-failure.t | |
109 | running 1 tests using 1 parallel processes |
|
109 | running 1 tests using 1 parallel processes | |
110 |
|
110 | |||
111 | --- $TESTTMP/test-failure.t |
|
111 | --- $TESTTMP/test-failure.t | |
112 | +++ $TESTTMP/test-failure.t.err |
|
112 | +++ $TESTTMP/test-failure.t.err | |
113 | @@ -1,4 +1,4 @@ |
|
113 | @@ -1,4 +1,4 @@ | |
114 | $ echo "bar-baz"; echo "bar-bad"; echo foo |
|
114 | $ echo "bar-baz"; echo "bar-bad"; echo foo | |
115 | + bar*baz (glob) |
|
115 | + bar*baz (glob) | |
116 | bar*bad (glob) |
|
116 | bar*bad (glob) | |
117 | - bar*baz (glob) |
|
117 | - bar*baz (glob) | |
118 | - | fo (re) |
|
118 | - | fo (re) | |
119 | + foo |
|
119 | + foo | |
120 |
|
120 | |||
121 | ERROR: test-failure.t output changed |
|
121 | ERROR: test-failure.t output changed | |
122 | ! |
|
122 | ! | |
123 | Failed test-failure.t: output changed |
|
123 | Failed test-failure.t: output changed | |
124 | # Ran 1 tests, 0 skipped, 1 failed. |
|
124 | # Ran 1 tests, 0 skipped, 1 failed. | |
125 | python hash seed: * (glob) |
|
125 | python hash seed: * (glob) | |
126 | [1] |
|
126 | [1] | |
127 |
|
127 | |||
128 | test how multiple globs gets matched with lines in output |
|
128 | test how multiple globs gets matched with lines in output | |
129 | $ cat > test-failure-globs.t <<EOF |
|
129 | $ cat > test-failure-globs.t <<EOF | |
130 | > $ echo "context"; echo "context"; \ |
|
130 | > $ echo "context"; echo "context"; \ | |
131 | > echo "key: 1"; echo "value: not a"; \ |
|
131 | > echo "key: 1"; echo "value: not a"; \ | |
132 | > echo "key: 2"; echo "value: not b"; \ |
|
132 | > echo "key: 2"; echo "value: not b"; \ | |
133 | > echo "key: 3"; echo "value: c"; \ |
|
133 | > echo "key: 3"; echo "value: c"; \ | |
134 | > echo "key: 4"; echo "value: d" |
|
134 | > echo "key: 4"; echo "value: d" | |
135 | > context |
|
135 | > context | |
136 | > context |
|
136 | > context | |
137 | > key: 1 |
|
137 | > key: 1 | |
138 | > value: a |
|
138 | > value: a | |
139 | > key: 2 |
|
139 | > key: 2 | |
140 | > value: b |
|
140 | > value: b | |
141 | > key: 3 |
|
141 | > key: 3 | |
142 | > value: * (glob) |
|
142 | > value: * (glob) | |
143 | > key: 4 |
|
143 | > key: 4 | |
144 | > value: * (glob) |
|
144 | > value: * (glob) | |
145 | > EOF |
|
145 | > EOF | |
146 | $ rt test-failure-globs.t |
|
146 | $ rt test-failure-globs.t | |
147 | running 1 tests using 1 parallel processes |
|
147 | running 1 tests using 1 parallel processes | |
148 |
|
148 | |||
149 | --- $TESTTMP/test-failure-globs.t |
|
149 | --- $TESTTMP/test-failure-globs.t | |
150 | +++ $TESTTMP/test-failure-globs.t.err |
|
150 | +++ $TESTTMP/test-failure-globs.t.err | |
151 | @@ -2,9 +2,9 @@ |
|
151 | @@ -2,9 +2,9 @@ | |
152 | context |
|
152 | context | |
153 | context |
|
153 | context | |
154 | key: 1 |
|
154 | key: 1 | |
155 | - value: a |
|
155 | - value: a | |
156 | + value: not a |
|
156 | + value: not a | |
157 | key: 2 |
|
157 | key: 2 | |
158 | - value: b |
|
158 | - value: b | |
159 | + value: not b |
|
159 | + value: not b | |
160 | key: 3 |
|
160 | key: 3 | |
161 | value: * (glob) |
|
161 | value: * (glob) | |
162 | key: 4 |
|
162 | key: 4 | |
163 |
|
163 | |||
164 | ERROR: test-failure-globs.t output changed |
|
164 | ERROR: test-failure-globs.t output changed | |
165 | ! |
|
165 | ! | |
166 | Failed test-failure-globs.t: output changed |
|
166 | Failed test-failure-globs.t: output changed | |
167 | # Ran 1 tests, 0 skipped, 1 failed. |
|
167 | # Ran 1 tests, 0 skipped, 1 failed. | |
168 | python hash seed: * (glob) |
|
168 | python hash seed: * (glob) | |
169 | [1] |
|
169 | [1] | |
170 | $ rm test-failure-globs.t |
|
170 | $ rm test-failure-globs.t | |
171 |
|
171 | |||
172 | test diff colorisation |
|
172 | test diff colorisation | |
173 |
|
173 | |||
174 | #if no-windows pygments |
|
174 | #if no-windows pygments | |
175 | $ rt test-failure.t --color always |
|
175 | $ rt test-failure.t --color always | |
176 | running 1 tests using 1 parallel processes |
|
176 | running 1 tests using 1 parallel processes | |
177 |
|
177 | |||
178 | \x1b[38;5;124m--- $TESTTMP/test-failure.t\x1b[39m (esc) |
|
178 | \x1b[38;5;124m--- $TESTTMP/test-failure.t\x1b[39m (esc) | |
179 | \x1b[38;5;34m+++ $TESTTMP/test-failure.t.err\x1b[39m (esc) |
|
179 | \x1b[38;5;34m+++ $TESTTMP/test-failure.t.err\x1b[39m (esc) | |
180 | \x1b[38;5;90;01m@@ -1,4 +1,4 @@\x1b[39;00m (esc) |
|
180 | \x1b[38;5;90;01m@@ -1,4 +1,4 @@\x1b[39;00m (esc) | |
181 | $ echo "bar-baz"; echo "bar-bad"; echo foo |
|
181 | $ echo "bar-baz"; echo "bar-bad"; echo foo | |
182 | \x1b[38;5;34m+ bar*baz (glob)\x1b[39m (esc) |
|
182 | \x1b[38;5;34m+ bar*baz (glob)\x1b[39m (esc) | |
183 | bar*bad (glob) |
|
183 | bar*bad (glob) | |
184 | \x1b[38;5;124m- bar*baz (glob)\x1b[39m (esc) |
|
184 | \x1b[38;5;124m- bar*baz (glob)\x1b[39m (esc) | |
185 | \x1b[38;5;124m- | fo (re)\x1b[39m (esc) |
|
185 | \x1b[38;5;124m- | fo (re)\x1b[39m (esc) | |
186 | \x1b[38;5;34m+ foo\x1b[39m (esc) |
|
186 | \x1b[38;5;34m+ foo\x1b[39m (esc) | |
187 |
|
187 | |||
188 | \x1b[38;5;88mERROR: \x1b[39m\x1b[38;5;9mtest-failure.t\x1b[39m\x1b[38;5;88m output changed\x1b[39m (esc) |
|
188 | \x1b[38;5;88mERROR: \x1b[39m\x1b[38;5;9mtest-failure.t\x1b[39m\x1b[38;5;88m output changed\x1b[39m (esc) | |
189 | ! |
|
189 | ! | |
190 | \x1b[38;5;88mFailed \x1b[39m\x1b[38;5;9mtest-failure.t\x1b[39m\x1b[38;5;88m: output changed\x1b[39m (esc) |
|
190 | \x1b[38;5;88mFailed \x1b[39m\x1b[38;5;9mtest-failure.t\x1b[39m\x1b[38;5;88m: output changed\x1b[39m (esc) | |
191 | # Ran 1 tests, 0 skipped, 1 failed. |
|
191 | # Ran 1 tests, 0 skipped, 1 failed. | |
192 | python hash seed: * (glob) |
|
192 | python hash seed: * (glob) | |
193 | [1] |
|
193 | [1] | |
194 |
|
194 | |||
195 | $ rt test-failure.t 2> tmp.log |
|
195 | $ rt test-failure.t 2> tmp.log | |
196 | running 1 tests using 1 parallel processes |
|
196 | running 1 tests using 1 parallel processes | |
197 | [1] |
|
197 | [1] | |
198 | $ cat tmp.log |
|
198 | $ cat tmp.log | |
199 |
|
199 | |||
200 | --- $TESTTMP/test-failure.t |
|
200 | --- $TESTTMP/test-failure.t | |
201 | +++ $TESTTMP/test-failure.t.err |
|
201 | +++ $TESTTMP/test-failure.t.err | |
202 | @@ -1,4 +1,4 @@ |
|
202 | @@ -1,4 +1,4 @@ | |
203 | $ echo "bar-baz"; echo "bar-bad"; echo foo |
|
203 | $ echo "bar-baz"; echo "bar-bad"; echo foo | |
204 | + bar*baz (glob) |
|
204 | + bar*baz (glob) | |
205 | bar*bad (glob) |
|
205 | bar*bad (glob) | |
206 | - bar*baz (glob) |
|
206 | - bar*baz (glob) | |
207 | - | fo (re) |
|
207 | - | fo (re) | |
208 | + foo |
|
208 | + foo | |
209 |
|
209 | |||
210 | ERROR: test-failure.t output changed |
|
210 | ERROR: test-failure.t output changed | |
211 | ! |
|
211 | ! | |
212 | Failed test-failure.t: output changed |
|
212 | Failed test-failure.t: output changed | |
213 | # Ran 1 tests, 0 skipped, 1 failed. |
|
213 | # Ran 1 tests, 0 skipped, 1 failed. | |
214 | python hash seed: * (glob) |
|
214 | python hash seed: * (glob) | |
215 | #endif |
|
215 | #endif | |
216 |
|
216 | |||
217 | $ cat > test-failure.t << EOF |
|
217 | $ cat > test-failure.t << EOF | |
218 | > $ true |
|
218 | > $ true | |
219 | > should go away (true !) |
|
219 | > should go away (true !) | |
220 | > $ true |
|
220 | > $ true | |
221 | > should stay (false !) |
|
221 | > should stay (false !) | |
222 | > |
|
222 | > | |
223 | > Should remove first line, not second or third |
|
223 | > Should remove first line, not second or third | |
224 | > $ echo 'testing' |
|
224 | > $ echo 'testing' | |
225 | > baz*foo (glob) (true !) |
|
225 | > baz*foo (glob) (true !) | |
226 | > foobar*foo (glob) (false !) |
|
226 | > foobar*foo (glob) (false !) | |
227 | > te*ting (glob) (true !) |
|
227 | > te*ting (glob) (true !) | |
228 | > |
|
228 | > | |
229 | > Should keep first two lines, remove third and last |
|
229 | > Should keep first two lines, remove third and last | |
230 | > $ echo 'testing' |
|
230 | > $ echo 'testing' | |
231 | > test.ng (re) (true !) |
|
231 | > test.ng (re) (true !) | |
232 | > foo.ar (re) (false !) |
|
232 | > foo.ar (re) (false !) | |
233 | > b.r (re) (true !) |
|
233 | > b.r (re) (true !) | |
234 | > missing (?) |
|
234 | > missing (?) | |
235 | > awol (true !) |
|
235 | > awol (true !) | |
236 | > |
|
236 | > | |
237 | > The "missing" line should stay, even though awol is dropped |
|
237 | > The "missing" line should stay, even though awol is dropped | |
238 | > $ echo 'testing' |
|
238 | > $ echo 'testing' | |
239 | > test.ng (re) (true !) |
|
239 | > test.ng (re) (true !) | |
240 | > foo.ar (?) |
|
240 | > foo.ar (?) | |
241 | > awol |
|
241 | > awol | |
242 | > missing (?) |
|
242 | > missing (?) | |
243 | > EOF |
|
243 | > EOF | |
244 | $ rt test-failure.t |
|
244 | $ rt test-failure.t | |
245 | running 1 tests using 1 parallel processes |
|
245 | running 1 tests using 1 parallel processes | |
246 |
|
246 | |||
247 | --- $TESTTMP/test-failure.t |
|
247 | --- $TESTTMP/test-failure.t | |
248 | +++ $TESTTMP/test-failure.t.err |
|
248 | +++ $TESTTMP/test-failure.t.err | |
249 | @@ -1,11 +1,9 @@ |
|
249 | @@ -1,11 +1,9 @@ | |
250 | $ true |
|
250 | $ true | |
251 | - should go away (true !) |
|
251 | - should go away (true !) | |
252 | $ true |
|
252 | $ true | |
253 | should stay (false !) |
|
253 | should stay (false !) | |
254 |
|
254 | |||
255 | Should remove first line, not second or third |
|
255 | Should remove first line, not second or third | |
256 | $ echo 'testing' |
|
256 | $ echo 'testing' | |
257 | - baz*foo (glob) (true !) |
|
257 | - baz*foo (glob) (true !) | |
258 | foobar*foo (glob) (false !) |
|
258 | foobar*foo (glob) (false !) | |
259 | te*ting (glob) (true !) |
|
259 | te*ting (glob) (true !) | |
260 |
|
260 | |||
261 | foo.ar (re) (false !) |
|
261 | foo.ar (re) (false !) | |
262 | missing (?) |
|
262 | missing (?) | |
263 | @@ -13,13 +11,10 @@ |
|
263 | @@ -13,13 +11,10 @@ | |
264 | $ echo 'testing' |
|
264 | $ echo 'testing' | |
265 | test.ng (re) (true !) |
|
265 | test.ng (re) (true !) | |
266 | foo.ar (re) (false !) |
|
266 | foo.ar (re) (false !) | |
267 | - b.r (re) (true !) |
|
267 | - b.r (re) (true !) | |
268 | missing (?) |
|
268 | missing (?) | |
269 | - awol (true !) |
|
269 | - awol (true !) | |
270 |
|
270 | |||
271 | The "missing" line should stay, even though awol is dropped |
|
271 | The "missing" line should stay, even though awol is dropped | |
272 | $ echo 'testing' |
|
272 | $ echo 'testing' | |
273 | test.ng (re) (true !) |
|
273 | test.ng (re) (true !) | |
274 | foo.ar (?) |
|
274 | foo.ar (?) | |
275 | - awol |
|
275 | - awol | |
276 | missing (?) |
|
276 | missing (?) | |
277 |
|
277 | |||
278 | ERROR: test-failure.t output changed |
|
278 | ERROR: test-failure.t output changed | |
279 | ! |
|
279 | ! | |
280 | Failed test-failure.t: output changed |
|
280 | Failed test-failure.t: output changed | |
281 | # Ran 1 tests, 0 skipped, 1 failed. |
|
281 | # Ran 1 tests, 0 skipped, 1 failed. | |
282 | python hash seed: * (glob) |
|
282 | python hash seed: * (glob) | |
283 | [1] |
|
283 | [1] | |
284 |
|
284 | |||
285 | basic failing test |
|
285 | basic failing test | |
286 | $ cat > test-failure.t << EOF |
|
286 | $ cat > test-failure.t << EOF | |
287 | > $ echo babar |
|
287 | > $ echo babar | |
288 | > rataxes |
|
288 | > rataxes | |
289 | > This is a noop statement so that |
|
289 | > This is a noop statement so that | |
290 | > this test is still more bytes than success. |
|
290 | > this test is still more bytes than success. | |
291 | > pad pad pad pad............................................................ |
|
291 | > pad pad pad pad............................................................ | |
292 | > pad pad pad pad............................................................ |
|
292 | > pad pad pad pad............................................................ | |
293 | > pad pad pad pad............................................................ |
|
293 | > pad pad pad pad............................................................ | |
294 | > pad pad pad pad............................................................ |
|
294 | > pad pad pad pad............................................................ | |
295 | > pad pad pad pad............................................................ |
|
295 | > pad pad pad pad............................................................ | |
296 | > pad pad pad pad............................................................ |
|
296 | > pad pad pad pad............................................................ | |
297 | > EOF |
|
297 | > EOF | |
298 |
|
298 | |||
299 | >>> fh = open('test-failure-unicode.t', 'wb') |
|
299 | >>> fh = open('test-failure-unicode.t', 'wb') | |
300 | >>> fh.write(u' $ echo babar\u03b1\n'.encode('utf-8')) and None |
|
300 | >>> fh.write(u' $ echo babar\u03b1\n'.encode('utf-8')) and None | |
301 | >>> fh.write(u' l\u03b5\u03b5t\n'.encode('utf-8')) and None |
|
301 | >>> fh.write(u' l\u03b5\u03b5t\n'.encode('utf-8')) and None | |
302 |
|
302 | |||
303 | $ rt |
|
303 | $ rt | |
304 | running 3 tests using 1 parallel processes |
|
304 | running 3 tests using 1 parallel processes | |
305 |
|
305 | |||
306 | --- $TESTTMP/test-failure.t |
|
306 | --- $TESTTMP/test-failure.t | |
307 | +++ $TESTTMP/test-failure.t.err |
|
307 | +++ $TESTTMP/test-failure.t.err | |
308 | @@ -1,5 +1,5 @@ |
|
308 | @@ -1,5 +1,5 @@ | |
309 | $ echo babar |
|
309 | $ echo babar | |
310 | - rataxes |
|
310 | - rataxes | |
311 | + babar |
|
311 | + babar | |
312 | This is a noop statement so that |
|
312 | This is a noop statement so that | |
313 | this test is still more bytes than success. |
|
313 | this test is still more bytes than success. | |
314 | pad pad pad pad............................................................ |
|
314 | pad pad pad pad............................................................ | |
315 |
|
315 | |||
316 | ERROR: test-failure.t output changed |
|
316 | ERROR: test-failure.t output changed | |
317 | !. |
|
317 | !. | |
318 | --- $TESTTMP/test-failure-unicode.t |
|
318 | --- $TESTTMP/test-failure-unicode.t | |
319 | +++ $TESTTMP/test-failure-unicode.t.err |
|
319 | +++ $TESTTMP/test-failure-unicode.t.err | |
320 | @@ -1,2 +1,2 @@ |
|
320 | @@ -1,2 +1,2 @@ | |
321 | $ echo babar\xce\xb1 (esc) |
|
321 | $ echo babar\xce\xb1 (esc) | |
322 | - l\xce\xb5\xce\xb5t (esc) |
|
322 | - l\xce\xb5\xce\xb5t (esc) | |
323 | + babar\xce\xb1 (esc) |
|
323 | + babar\xce\xb1 (esc) | |
324 |
|
324 | |||
325 | ERROR: test-failure-unicode.t output changed |
|
325 | ERROR: test-failure-unicode.t output changed | |
326 | ! |
|
326 | ! | |
327 | Failed test-failure-unicode.t: output changed |
|
327 | Failed test-failure-unicode.t: output changed | |
328 | Failed test-failure.t: output changed |
|
328 | Failed test-failure.t: output changed | |
329 | # Ran 3 tests, 0 skipped, 2 failed. |
|
329 | # Ran 3 tests, 0 skipped, 2 failed. | |
330 | python hash seed: * (glob) |
|
330 | python hash seed: * (glob) | |
331 | [1] |
|
331 | [1] | |
332 |
|
332 | |||
333 | test --outputdir |
|
333 | test --outputdir | |
334 | $ mkdir output |
|
334 | $ mkdir output | |
335 | $ rt --outputdir output |
|
335 | $ rt --outputdir output | |
336 | running 3 tests using 1 parallel processes |
|
336 | running 3 tests using 1 parallel processes | |
337 |
|
337 | |||
338 | --- $TESTTMP/test-failure.t |
|
338 | --- $TESTTMP/test-failure.t | |
339 | +++ $TESTTMP/output/test-failure.t.err |
|
339 | +++ $TESTTMP/output/test-failure.t.err | |
340 | @@ -1,5 +1,5 @@ |
|
340 | @@ -1,5 +1,5 @@ | |
341 | $ echo babar |
|
341 | $ echo babar | |
342 | - rataxes |
|
342 | - rataxes | |
343 | + babar |
|
343 | + babar | |
344 | This is a noop statement so that |
|
344 | This is a noop statement so that | |
345 | this test is still more bytes than success. |
|
345 | this test is still more bytes than success. | |
346 | pad pad pad pad............................................................ |
|
346 | pad pad pad pad............................................................ | |
347 |
|
347 | |||
348 | ERROR: test-failure.t output changed |
|
348 | ERROR: test-failure.t output changed | |
349 | !. |
|
349 | !. | |
350 | --- $TESTTMP/test-failure-unicode.t |
|
350 | --- $TESTTMP/test-failure-unicode.t | |
351 | +++ $TESTTMP/output/test-failure-unicode.t.err |
|
351 | +++ $TESTTMP/output/test-failure-unicode.t.err | |
352 | @@ -1,2 +1,2 @@ |
|
352 | @@ -1,2 +1,2 @@ | |
353 | $ echo babar\xce\xb1 (esc) |
|
353 | $ echo babar\xce\xb1 (esc) | |
354 | - l\xce\xb5\xce\xb5t (esc) |
|
354 | - l\xce\xb5\xce\xb5t (esc) | |
355 | + babar\xce\xb1 (esc) |
|
355 | + babar\xce\xb1 (esc) | |
356 |
|
356 | |||
357 | ERROR: test-failure-unicode.t output changed |
|
357 | ERROR: test-failure-unicode.t output changed | |
358 | ! |
|
358 | ! | |
359 | Failed test-failure-unicode.t: output changed |
|
359 | Failed test-failure-unicode.t: output changed | |
360 | Failed test-failure.t: output changed |
|
360 | Failed test-failure.t: output changed | |
361 | # Ran 3 tests, 0 skipped, 2 failed. |
|
361 | # Ran 3 tests, 0 skipped, 2 failed. | |
362 | python hash seed: * (glob) |
|
362 | python hash seed: * (glob) | |
363 | [1] |
|
363 | [1] | |
364 | $ ls -a output |
|
364 | $ ls -a output | |
365 | . |
|
365 | . | |
366 | .. |
|
366 | .. | |
367 | .testtimes |
|
367 | .testtimes | |
368 | test-failure-unicode.t.err |
|
368 | test-failure-unicode.t.err | |
369 | test-failure.t.err |
|
369 | test-failure.t.err | |
370 |
|
370 | |||
371 | test --xunit support |
|
371 | test --xunit support | |
372 | $ rt --xunit=xunit.xml |
|
372 | $ rt --xunit=xunit.xml | |
373 | running 3 tests using 1 parallel processes |
|
373 | running 3 tests using 1 parallel processes | |
374 |
|
374 | |||
375 | --- $TESTTMP/test-failure.t |
|
375 | --- $TESTTMP/test-failure.t | |
376 | +++ $TESTTMP/test-failure.t.err |
|
376 | +++ $TESTTMP/test-failure.t.err | |
377 | @@ -1,5 +1,5 @@ |
|
377 | @@ -1,5 +1,5 @@ | |
378 | $ echo babar |
|
378 | $ echo babar | |
379 | - rataxes |
|
379 | - rataxes | |
380 | + babar |
|
380 | + babar | |
381 | This is a noop statement so that |
|
381 | This is a noop statement so that | |
382 | this test is still more bytes than success. |
|
382 | this test is still more bytes than success. | |
383 | pad pad pad pad............................................................ |
|
383 | pad pad pad pad............................................................ | |
384 |
|
384 | |||
385 | ERROR: test-failure.t output changed |
|
385 | ERROR: test-failure.t output changed | |
386 | !. |
|
386 | !. | |
387 | --- $TESTTMP/test-failure-unicode.t |
|
387 | --- $TESTTMP/test-failure-unicode.t | |
388 | +++ $TESTTMP/test-failure-unicode.t.err |
|
388 | +++ $TESTTMP/test-failure-unicode.t.err | |
389 | @@ -1,2 +1,2 @@ |
|
389 | @@ -1,2 +1,2 @@ | |
390 | $ echo babar\xce\xb1 (esc) |
|
390 | $ echo babar\xce\xb1 (esc) | |
391 | - l\xce\xb5\xce\xb5t (esc) |
|
391 | - l\xce\xb5\xce\xb5t (esc) | |
392 | + babar\xce\xb1 (esc) |
|
392 | + babar\xce\xb1 (esc) | |
393 |
|
393 | |||
394 | ERROR: test-failure-unicode.t output changed |
|
394 | ERROR: test-failure-unicode.t output changed | |
395 | ! |
|
395 | ! | |
396 | Failed test-failure-unicode.t: output changed |
|
396 | Failed test-failure-unicode.t: output changed | |
397 | Failed test-failure.t: output changed |
|
397 | Failed test-failure.t: output changed | |
398 | # Ran 3 tests, 0 skipped, 2 failed. |
|
398 | # Ran 3 tests, 0 skipped, 2 failed. | |
399 | python hash seed: * (glob) |
|
399 | python hash seed: * (glob) | |
400 | [1] |
|
400 | [1] | |
401 | $ cat xunit.xml |
|
401 | $ cat xunit.xml | |
402 | <?xml version="1.0" encoding="utf-8"?> |
|
402 | <?xml version="1.0" encoding="utf-8"?> | |
403 | <testsuite errors="0" failures="2" name="run-tests" skipped="0" tests="3"> |
|
403 | <testsuite errors="0" failures="2" name="run-tests" skipped="0" tests="3"> | |
404 | <testcase name="test-success.t" time="*"/> (glob) |
|
404 | <testcase name="test-success.t" time="*"/> (glob) | |
405 | <testcase name="test-failure-unicode.t" time="*"> (glob) |
|
405 | <testcase name="test-failure-unicode.t" time="*"> (glob) | |
406 | <failure message="output changed" type="output-mismatch"> |
|
406 | <failure message="output changed" type="output-mismatch"> | |
407 | <![CDATA[--- $TESTTMP/test-failure-unicode.t |
|
407 | <![CDATA[--- $TESTTMP/test-failure-unicode.t | |
408 | +++ $TESTTMP/test-failure-unicode.t.err |
|
408 | +++ $TESTTMP/test-failure-unicode.t.err | |
409 | @@ -1,2 +1,2 @@ |
|
409 | @@ -1,2 +1,2 @@ | |
410 | $ echo babar\xce\xb1 (esc) |
|
410 | $ echo babar\xce\xb1 (esc) | |
411 | - l\xce\xb5\xce\xb5t (esc) |
|
411 | - l\xce\xb5\xce\xb5t (esc) | |
412 | + babar\xce\xb1 (esc) |
|
412 | + babar\xce\xb1 (esc) | |
413 | ]]> </failure> |
|
413 | ]]> </failure> | |
414 | </testcase> |
|
414 | </testcase> | |
415 | <testcase name="test-failure.t" time="*"> (glob) |
|
415 | <testcase name="test-failure.t" time="*"> (glob) | |
416 | <failure message="output changed" type="output-mismatch"> |
|
416 | <failure message="output changed" type="output-mismatch"> | |
417 | <![CDATA[--- $TESTTMP/test-failure.t |
|
417 | <![CDATA[--- $TESTTMP/test-failure.t | |
418 | +++ $TESTTMP/test-failure.t.err |
|
418 | +++ $TESTTMP/test-failure.t.err | |
419 | @@ -1,5 +1,5 @@ |
|
419 | @@ -1,5 +1,5 @@ | |
420 | $ echo babar |
|
420 | $ echo babar | |
421 | - rataxes |
|
421 | - rataxes | |
422 | + babar |
|
422 | + babar | |
423 | This is a noop statement so that |
|
423 | This is a noop statement so that | |
424 | this test is still more bytes than success. |
|
424 | this test is still more bytes than success. | |
425 | pad pad pad pad............................................................ |
|
425 | pad pad pad pad............................................................ | |
426 | ]]> </failure> |
|
426 | ]]> </failure> | |
427 | </testcase> |
|
427 | </testcase> | |
428 | </testsuite> |
|
428 | </testsuite> | |
429 |
|
429 | |||
430 | $ cat .testtimes |
|
430 | $ cat .testtimes | |
431 | test-empty.t * (glob) |
|
431 | test-empty.t * (glob) | |
432 | test-failure-globs.t * (glob) |
|
432 | test-failure-globs.t * (glob) | |
433 | test-failure-unicode.t * (glob) |
|
433 | test-failure-unicode.t * (glob) | |
434 | test-failure.t * (glob) |
|
434 | test-failure.t * (glob) | |
435 | test-success.t * (glob) |
|
435 | test-success.t * (glob) | |
436 |
|
436 | |||
437 | $ rt --list-tests |
|
437 | $ rt --list-tests | |
438 | test-failure-unicode.t |
|
438 | test-failure-unicode.t | |
439 | test-failure.t |
|
439 | test-failure.t | |
440 | test-success.t |
|
440 | test-success.t | |
441 |
|
441 | |||
442 | $ rt --list-tests --json |
|
442 | $ rt --list-tests --json | |
443 | test-failure-unicode.t |
|
443 | test-failure-unicode.t | |
444 | test-failure.t |
|
444 | test-failure.t | |
445 | test-success.t |
|
445 | test-success.t | |
446 | $ cat report.json |
|
446 | $ cat report.json | |
447 | testreport ={ |
|
447 | testreport ={ | |
448 | "test-failure-unicode.t": { |
|
448 | "test-failure-unicode.t": { | |
449 | "result": "success" |
|
449 | "result": "success" | |
450 | }, |
|
450 | }, | |
451 | "test-failure.t": { |
|
451 | "test-failure.t": { | |
452 | "result": "success" |
|
452 | "result": "success" | |
453 | }, |
|
453 | }, | |
454 | "test-success.t": { |
|
454 | "test-success.t": { | |
455 | "result": "success" |
|
455 | "result": "success" | |
456 | } |
|
456 | } | |
457 | } (no-eol) |
|
457 | } (no-eol) | |
458 |
|
458 | |||
459 | $ rt --list-tests --xunit=xunit.xml |
|
459 | $ rt --list-tests --xunit=xunit.xml | |
460 | test-failure-unicode.t |
|
460 | test-failure-unicode.t | |
461 | test-failure.t |
|
461 | test-failure.t | |
462 | test-success.t |
|
462 | test-success.t | |
463 | $ cat xunit.xml |
|
463 | $ cat xunit.xml | |
464 | <?xml version="1.0" encoding="utf-8"?> |
|
464 | <?xml version="1.0" encoding="utf-8"?> | |
465 | <testsuite errors="0" failures="0" name="run-tests" skipped="0" tests="0"> |
|
465 | <testsuite errors="0" failures="0" name="run-tests" skipped="0" tests="0"> | |
466 | <testcase name="test-failure-unicode.t"/> |
|
466 | <testcase name="test-failure-unicode.t"/> | |
467 | <testcase name="test-failure.t"/> |
|
467 | <testcase name="test-failure.t"/> | |
468 | <testcase name="test-success.t"/> |
|
468 | <testcase name="test-success.t"/> | |
469 | </testsuite> |
|
469 | </testsuite> | |
470 |
|
470 | |||
471 | $ rt --list-tests test-failure* --json --xunit=xunit.xml --outputdir output |
|
471 | $ rt --list-tests test-failure* --json --xunit=xunit.xml --outputdir output | |
472 | test-failure-unicode.t |
|
472 | test-failure-unicode.t | |
473 | test-failure.t |
|
473 | test-failure.t | |
474 | $ cat output/report.json |
|
474 | $ cat output/report.json | |
475 | testreport ={ |
|
475 | testreport ={ | |
476 | "test-failure-unicode.t": { |
|
476 | "test-failure-unicode.t": { | |
477 | "result": "success" |
|
477 | "result": "success" | |
478 | }, |
|
478 | }, | |
479 | "test-failure.t": { |
|
479 | "test-failure.t": { | |
480 | "result": "success" |
|
480 | "result": "success" | |
481 | } |
|
481 | } | |
482 | } (no-eol) |
|
482 | } (no-eol) | |
483 | $ cat xunit.xml |
|
483 | $ cat xunit.xml | |
484 | <?xml version="1.0" encoding="utf-8"?> |
|
484 | <?xml version="1.0" encoding="utf-8"?> | |
485 | <testsuite errors="0" failures="0" name="run-tests" skipped="0" tests="0"> |
|
485 | <testsuite errors="0" failures="0" name="run-tests" skipped="0" tests="0"> | |
486 | <testcase name="test-failure-unicode.t"/> |
|
486 | <testcase name="test-failure-unicode.t"/> | |
487 | <testcase name="test-failure.t"/> |
|
487 | <testcase name="test-failure.t"/> | |
488 | </testsuite> |
|
488 | </testsuite> | |
489 |
|
489 | |||
490 | $ rm test-failure-unicode.t |
|
490 | $ rm test-failure-unicode.t | |
491 |
|
491 | |||
492 | test for --retest |
|
492 | test for --retest | |
493 | ==================== |
|
493 | ==================== | |
494 |
|
494 | |||
495 | $ rt --retest |
|
495 | $ rt --retest | |
496 | running 2 tests using 1 parallel processes |
|
496 | running 2 tests using 1 parallel processes | |
497 |
|
497 | |||
498 | --- $TESTTMP/test-failure.t |
|
498 | --- $TESTTMP/test-failure.t | |
499 | +++ $TESTTMP/test-failure.t.err |
|
499 | +++ $TESTTMP/test-failure.t.err | |
500 | @@ -1,5 +1,5 @@ |
|
500 | @@ -1,5 +1,5 @@ | |
501 | $ echo babar |
|
501 | $ echo babar | |
502 | - rataxes |
|
502 | - rataxes | |
503 | + babar |
|
503 | + babar | |
504 | This is a noop statement so that |
|
504 | This is a noop statement so that | |
505 | this test is still more bytes than success. |
|
505 | this test is still more bytes than success. | |
506 | pad pad pad pad............................................................ |
|
506 | pad pad pad pad............................................................ | |
507 |
|
507 | |||
508 | ERROR: test-failure.t output changed |
|
508 | ERROR: test-failure.t output changed | |
509 | ! |
|
509 | ! | |
510 | Failed test-failure.t: output changed |
|
510 | Failed test-failure.t: output changed | |
511 | # Ran 2 tests, 1 skipped, 1 failed. |
|
511 | # Ran 2 tests, 1 skipped, 1 failed. | |
512 | python hash seed: * (glob) |
|
512 | python hash seed: * (glob) | |
513 | [1] |
|
513 | [1] | |
514 |
|
514 | |||
515 | --retest works with --outputdir |
|
515 | --retest works with --outputdir | |
516 | $ rm -r output |
|
516 | $ rm -r output | |
517 | $ mkdir output |
|
517 | $ mkdir output | |
518 | $ mv test-failure.t.err output |
|
518 | $ mv test-failure.t.err output | |
519 | $ rt --retest --outputdir output |
|
519 | $ rt --retest --outputdir output | |
520 | running 2 tests using 1 parallel processes |
|
520 | running 2 tests using 1 parallel processes | |
521 |
|
521 | |||
522 | --- $TESTTMP/test-failure.t |
|
522 | --- $TESTTMP/test-failure.t | |
523 | +++ $TESTTMP/output/test-failure.t.err |
|
523 | +++ $TESTTMP/output/test-failure.t.err | |
524 | @@ -1,5 +1,5 @@ |
|
524 | @@ -1,5 +1,5 @@ | |
525 | $ echo babar |
|
525 | $ echo babar | |
526 | - rataxes |
|
526 | - rataxes | |
527 | + babar |
|
527 | + babar | |
528 | This is a noop statement so that |
|
528 | This is a noop statement so that | |
529 | this test is still more bytes than success. |
|
529 | this test is still more bytes than success. | |
530 | pad pad pad pad............................................................ |
|
530 | pad pad pad pad............................................................ | |
531 |
|
531 | |||
532 | ERROR: test-failure.t output changed |
|
532 | ERROR: test-failure.t output changed | |
533 | ! |
|
533 | ! | |
534 | Failed test-failure.t: output changed |
|
534 | Failed test-failure.t: output changed | |
535 | # Ran 2 tests, 1 skipped, 1 failed. |
|
535 | # Ran 2 tests, 1 skipped, 1 failed. | |
536 | python hash seed: * (glob) |
|
536 | python hash seed: * (glob) | |
537 | [1] |
|
537 | [1] | |
538 |
|
538 | |||
539 | Selecting Tests To Run |
|
539 | Selecting Tests To Run | |
540 | ====================== |
|
540 | ====================== | |
541 |
|
541 | |||
542 | successful |
|
542 | successful | |
543 |
|
543 | |||
544 | $ rt test-success.t |
|
544 | $ rt test-success.t | |
545 | running 1 tests using 1 parallel processes |
|
545 | running 1 tests using 1 parallel processes | |
546 | . |
|
546 | . | |
547 | # Ran 1 tests, 0 skipped, 0 failed. |
|
547 | # Ran 1 tests, 0 skipped, 0 failed. | |
548 |
|
548 | |||
549 | success w/ keyword |
|
549 | success w/ keyword | |
550 | $ rt -k xyzzy |
|
550 | $ rt -k xyzzy | |
551 | running 2 tests using 1 parallel processes |
|
551 | running 2 tests using 1 parallel processes | |
552 | . |
|
552 | . | |
553 | # Ran 2 tests, 1 skipped, 0 failed. |
|
553 | # Ran 2 tests, 1 skipped, 0 failed. | |
554 |
|
554 | |||
555 | failed |
|
555 | failed | |
556 |
|
556 | |||
557 | $ rt test-failure.t |
|
557 | $ rt test-failure.t | |
558 | running 1 tests using 1 parallel processes |
|
558 | running 1 tests using 1 parallel processes | |
559 |
|
559 | |||
560 | --- $TESTTMP/test-failure.t |
|
560 | --- $TESTTMP/test-failure.t | |
561 | +++ $TESTTMP/test-failure.t.err |
|
561 | +++ $TESTTMP/test-failure.t.err | |
562 | @@ -1,5 +1,5 @@ |
|
562 | @@ -1,5 +1,5 @@ | |
563 | $ echo babar |
|
563 | $ echo babar | |
564 | - rataxes |
|
564 | - rataxes | |
565 | + babar |
|
565 | + babar | |
566 | This is a noop statement so that |
|
566 | This is a noop statement so that | |
567 | this test is still more bytes than success. |
|
567 | this test is still more bytes than success. | |
568 | pad pad pad pad............................................................ |
|
568 | pad pad pad pad............................................................ | |
569 |
|
569 | |||
570 | ERROR: test-failure.t output changed |
|
570 | ERROR: test-failure.t output changed | |
571 | ! |
|
571 | ! | |
572 | Failed test-failure.t: output changed |
|
572 | Failed test-failure.t: output changed | |
573 | # Ran 1 tests, 0 skipped, 1 failed. |
|
573 | # Ran 1 tests, 0 skipped, 1 failed. | |
574 | python hash seed: * (glob) |
|
574 | python hash seed: * (glob) | |
575 | [1] |
|
575 | [1] | |
576 |
|
576 | |||
577 | failure w/ keyword |
|
577 | failure w/ keyword | |
578 | $ rt -k rataxes |
|
578 | $ rt -k rataxes | |
579 | running 2 tests using 1 parallel processes |
|
579 | running 2 tests using 1 parallel processes | |
580 |
|
580 | |||
581 | --- $TESTTMP/test-failure.t |
|
581 | --- $TESTTMP/test-failure.t | |
582 | +++ $TESTTMP/test-failure.t.err |
|
582 | +++ $TESTTMP/test-failure.t.err | |
583 | @@ -1,5 +1,5 @@ |
|
583 | @@ -1,5 +1,5 @@ | |
584 | $ echo babar |
|
584 | $ echo babar | |
585 | - rataxes |
|
585 | - rataxes | |
586 | + babar |
|
586 | + babar | |
587 | This is a noop statement so that |
|
587 | This is a noop statement so that | |
588 | this test is still more bytes than success. |
|
588 | this test is still more bytes than success. | |
589 | pad pad pad pad............................................................ |
|
589 | pad pad pad pad............................................................ | |
590 |
|
590 | |||
591 | ERROR: test-failure.t output changed |
|
591 | ERROR: test-failure.t output changed | |
592 | ! |
|
592 | ! | |
593 | Failed test-failure.t: output changed |
|
593 | Failed test-failure.t: output changed | |
594 | # Ran 2 tests, 1 skipped, 1 failed. |
|
594 | # Ran 2 tests, 1 skipped, 1 failed. | |
595 | python hash seed: * (glob) |
|
595 | python hash seed: * (glob) | |
596 | [1] |
|
596 | [1] | |
597 |
|
597 | |||
598 | Verify that when a process fails to start we show a useful message |
|
598 | Verify that when a process fails to start we show a useful message | |
599 | ================================================================== |
|
599 | ================================================================== | |
600 |
|
600 | |||
601 | $ cat > test-serve-fail.t <<EOF |
|
601 | $ cat > test-serve-fail.t <<EOF | |
602 | > $ echo 'abort: child process failed to start blah' |
|
602 | > $ echo 'abort: child process failed to start blah' | |
603 | > EOF |
|
603 | > EOF | |
604 | $ rt test-serve-fail.t |
|
604 | $ rt test-serve-fail.t | |
605 | running 1 tests using 1 parallel processes |
|
605 | running 1 tests using 1 parallel processes | |
606 |
|
606 | |||
607 | --- $TESTTMP/test-serve-fail.t |
|
607 | --- $TESTTMP/test-serve-fail.t | |
608 | +++ $TESTTMP/test-serve-fail.t.err |
|
608 | +++ $TESTTMP/test-serve-fail.t.err | |
609 | @@ -1* +1,2 @@ (glob) |
|
609 | @@ -1* +1,2 @@ (glob) | |
610 | $ echo 'abort: child process failed to start blah' |
|
610 | $ echo 'abort: child process failed to start blah' | |
611 | + abort: child process failed to start blah |
|
611 | + abort: child process failed to start blah | |
612 |
|
612 | |||
613 | ERROR: test-serve-fail.t output changed |
|
613 | ERROR: test-serve-fail.t output changed | |
614 | ! |
|
614 | ! | |
615 | Failed test-serve-fail.t: server failed to start (HGPORT=*) (glob) |
|
615 | Failed test-serve-fail.t: server failed to start (HGPORT=*) (glob) | |
616 | # Ran 1 tests, 0 skipped, 1 failed. |
|
616 | # Ran 1 tests, 0 skipped, 1 failed. | |
617 | python hash seed: * (glob) |
|
617 | python hash seed: * (glob) | |
618 | [1] |
|
618 | [1] | |
619 | $ rm test-serve-fail.t |
|
619 | $ rm test-serve-fail.t | |
620 |
|
620 | |||
621 | Verify that we can try other ports |
|
621 | Verify that we can try other ports | |
622 | =================================== |
|
622 | =================================== | |
623 |
|
623 | |||
624 | Extensions aren't inherited by the invoked run-tests.py. An extension |
|
624 | Extensions aren't inherited by the invoked run-tests.py. An extension | |
625 | introducing a repository requirement could cause this to fail. So we force |
|
625 | introducing a repository requirement could cause this to fail. So we force | |
626 | HGRCPATH to get a clean environment. |
|
626 | HGRCPATH to get a clean environment. | |
627 |
|
627 | |||
628 | $ HGRCPATH= hg init inuse |
|
628 | $ HGRCPATH= hg init inuse | |
629 | $ hg serve -R inuse -p $HGPORT -d --pid-file=blocks.pid |
|
629 | $ hg serve -R inuse -p $HGPORT -d --pid-file=blocks.pid | |
630 | $ cat blocks.pid >> $DAEMON_PIDS |
|
630 | $ cat blocks.pid >> $DAEMON_PIDS | |
631 | $ cat > test-serve-inuse.t <<EOF |
|
631 | $ cat > test-serve-inuse.t <<EOF | |
632 | > $ hg serve -R `pwd`/inuse -p \$HGPORT -d --pid-file=hg.pid |
|
632 | > $ hg serve -R `pwd`/inuse -p \$HGPORT -d --pid-file=hg.pid | |
633 | > $ cat hg.pid >> \$DAEMON_PIDS |
|
633 | > $ cat hg.pid >> \$DAEMON_PIDS | |
634 | > EOF |
|
634 | > EOF | |
635 | $ rt test-serve-inuse.t |
|
635 | $ rt test-serve-inuse.t | |
636 | running 1 tests using 1 parallel processes |
|
636 | running 1 tests using 1 parallel processes | |
637 | . |
|
637 | . | |
638 | # Ran 1 tests, 0 skipped, 0 failed. |
|
638 | # Ran 1 tests, 0 skipped, 0 failed. | |
639 | $ rm test-serve-inuse.t |
|
639 | $ rm test-serve-inuse.t | |
640 | $ killdaemons.py $DAEMON_PIDS |
|
640 | $ killdaemons.py $DAEMON_PIDS | |
641 |
|
641 | |||
642 | Running In Debug Mode |
|
642 | Running In Debug Mode | |
643 | ====================== |
|
643 | ====================== | |
644 |
|
644 | |||
645 | $ rt --debug 2>&1 | grep -v pwd |
|
645 | $ rt --debug 2>&1 | grep -v pwd | |
646 | running 2 tests using 1 parallel processes |
|
646 | running 2 tests using 1 parallel processes | |
647 | + alias hg=hg.exe (windows !) |
|
647 | + alias hg=hg.exe (windows !) | |
648 | + echo *SALT* 0 0 (glob) |
|
648 | + echo *SALT* 0 0 (glob) | |
649 | *SALT* 0 0 (glob) |
|
649 | *SALT* 0 0 (glob) | |
650 | + echo babar |
|
650 | + echo babar | |
651 | babar |
|
651 | babar | |
652 | + echo *SALT* 10 0 (glob) |
|
652 | + echo *SALT* 10 0 (glob) | |
653 | *SALT* 10 0 (glob) |
|
653 | *SALT* 10 0 (glob) | |
654 | .+ alias hg=hg.exe (windows !) |
|
654 | .+ alias hg=hg.exe (windows !) | |
655 | *+ echo *SALT* 0 0 (glob) |
|
655 | *+ echo *SALT* 0 0 (glob) | |
656 | *SALT* 0 0 (glob) |
|
656 | *SALT* 0 0 (glob) | |
657 | + echo babar |
|
657 | + echo babar | |
658 | babar |
|
658 | babar | |
659 | + echo *SALT* 2 0 (glob) |
|
659 | + echo *SALT* 2 0 (glob) | |
660 | *SALT* 2 0 (glob) |
|
660 | *SALT* 2 0 (glob) | |
661 | + echo xyzzy |
|
661 | + echo xyzzy | |
662 | xyzzy |
|
662 | xyzzy | |
663 | + echo *SALT* 9 0 (glob) |
|
663 | + echo *SALT* 9 0 (glob) | |
664 | *SALT* 9 0 (glob) |
|
664 | *SALT* 9 0 (glob) | |
665 | + printf *abc\ndef\nxyz\n* (glob) |
|
665 | + printf *abc\ndef\nxyz\n* (glob) | |
666 | abc |
|
666 | abc | |
667 | def |
|
667 | def | |
668 | xyz |
|
668 | xyz | |
669 | + echo *SALT* 15 0 (glob) |
|
669 | + echo *SALT* 15 0 (glob) | |
670 | *SALT* 15 0 (glob) |
|
670 | *SALT* 15 0 (glob) | |
671 | + printf *zyx\nwvu\ntsr\n* (glob) |
|
671 | + printf *zyx\nwvu\ntsr\n* (glob) | |
672 | zyx |
|
672 | zyx | |
673 | wvu |
|
673 | wvu | |
674 | tsr |
|
674 | tsr | |
675 | + echo *SALT* 22 0 (glob) |
|
675 | + echo *SALT* 22 0 (glob) | |
676 | *SALT* 22 0 (glob) |
|
676 | *SALT* 22 0 (glob) | |
677 | . |
|
677 | . | |
678 | # Ran 2 tests, 0 skipped, 0 failed. |
|
678 | # Ran 2 tests, 0 skipped, 0 failed. | |
679 |
|
679 | |||
680 | Parallel runs |
|
680 | Parallel runs | |
681 | ============== |
|
681 | ============== | |
682 |
|
682 | |||
683 | (duplicate the failing test to get predictable output) |
|
683 | (duplicate the failing test to get predictable output) | |
684 | $ cp test-failure.t test-failure-copy.t |
|
684 | $ cp test-failure.t test-failure-copy.t | |
685 |
|
685 | |||
686 | $ rt --jobs 2 test-failure*.t -n |
|
686 | $ rt --jobs 2 test-failure*.t -n | |
687 | running 2 tests using 2 parallel processes |
|
687 | running 2 tests using 2 parallel processes | |
688 | !! |
|
688 | !! | |
689 | Failed test-failure*.t: output changed (glob) |
|
689 | Failed test-failure*.t: output changed (glob) | |
690 | Failed test-failure*.t: output changed (glob) |
|
690 | Failed test-failure*.t: output changed (glob) | |
691 | # Ran 2 tests, 0 skipped, 2 failed. |
|
691 | # Ran 2 tests, 0 skipped, 2 failed. | |
692 | python hash seed: * (glob) |
|
692 | python hash seed: * (glob) | |
693 | [1] |
|
693 | [1] | |
694 |
|
694 | |||
695 | failures in parallel with --first should only print one failure |
|
695 | failures in parallel with --first should only print one failure | |
696 | $ rt --jobs 2 --first test-failure*.t |
|
696 | $ rt --jobs 2 --first test-failure*.t | |
697 | running 2 tests using 2 parallel processes |
|
697 | running 2 tests using 2 parallel processes | |
698 |
|
698 | |||
699 | --- $TESTTMP/test-failure*.t (glob) |
|
699 | --- $TESTTMP/test-failure*.t (glob) | |
700 | +++ $TESTTMP/test-failure*.t.err (glob) |
|
700 | +++ $TESTTMP/test-failure*.t.err (glob) | |
701 | @@ -1,5 +1,5 @@ |
|
701 | @@ -1,5 +1,5 @@ | |
702 | $ echo babar |
|
702 | $ echo babar | |
703 | - rataxes |
|
703 | - rataxes | |
704 | + babar |
|
704 | + babar | |
705 | This is a noop statement so that |
|
705 | This is a noop statement so that | |
706 | this test is still more bytes than success. |
|
706 | this test is still more bytes than success. | |
707 | pad pad pad pad............................................................ |
|
707 | pad pad pad pad............................................................ | |
708 |
|
708 | |||
709 | Failed test-failure*.t: output changed (glob) |
|
709 | Failed test-failure*.t: output changed (glob) | |
710 | Failed test-failure*.t: output changed (glob) |
|
710 | Failed test-failure*.t: output changed (glob) | |
711 | # Ran 2 tests, 0 skipped, 2 failed. |
|
711 | # Ran 2 tests, 0 skipped, 2 failed. | |
712 | python hash seed: * (glob) |
|
712 | python hash seed: * (glob) | |
713 | [1] |
|
713 | [1] | |
714 |
|
714 | |||
715 |
|
715 | |||
716 | (delete the duplicated test file) |
|
716 | (delete the duplicated test file) | |
717 | $ rm test-failure-copy.t |
|
717 | $ rm test-failure-copy.t | |
718 |
|
718 | |||
719 | multiple runs per test should be parallelized |
|
719 | multiple runs per test should be parallelized | |
720 |
|
720 | |||
721 | $ rt --jobs 2 --runs-per-test 2 test-success.t |
|
721 | $ rt --jobs 2 --runs-per-test 2 test-success.t | |
722 | running 2 tests using 2 parallel processes |
|
722 | running 2 tests using 2 parallel processes | |
723 | .. |
|
723 | .. | |
724 | # Ran 2 tests, 0 skipped, 0 failed. |
|
724 | # Ran 2 tests, 0 skipped, 0 failed. | |
725 |
|
725 | |||
726 | Interactive run |
|
726 | Interactive run | |
727 | =============== |
|
727 | =============== | |
728 |
|
728 | |||
729 | (backup the failing test) |
|
729 | (backup the failing test) | |
730 | $ cp test-failure.t backup |
|
730 | $ cp test-failure.t backup | |
731 |
|
731 | |||
732 | Refuse the fix |
|
732 | Refuse the fix | |
733 |
|
733 | |||
734 | $ echo 'n' | rt -i |
|
734 | $ echo 'n' | rt -i | |
735 | running 2 tests using 1 parallel processes |
|
735 | running 2 tests using 1 parallel processes | |
736 |
|
736 | |||
737 | --- $TESTTMP/test-failure.t |
|
737 | --- $TESTTMP/test-failure.t | |
738 | +++ $TESTTMP/test-failure.t.err |
|
738 | +++ $TESTTMP/test-failure.t.err | |
739 | @@ -1,5 +1,5 @@ |
|
739 | @@ -1,5 +1,5 @@ | |
740 | $ echo babar |
|
740 | $ echo babar | |
741 | - rataxes |
|
741 | - rataxes | |
742 | + babar |
|
742 | + babar | |
743 | This is a noop statement so that |
|
743 | This is a noop statement so that | |
744 | this test is still more bytes than success. |
|
744 | this test is still more bytes than success. | |
745 | pad pad pad pad............................................................ |
|
745 | pad pad pad pad............................................................ | |
746 | Accept this change? [n] |
|
746 | Accept this change? [n] | |
747 | ERROR: test-failure.t output changed |
|
747 | ERROR: test-failure.t output changed | |
748 | !. |
|
748 | !. | |
749 | Failed test-failure.t: output changed |
|
749 | Failed test-failure.t: output changed | |
750 | # Ran 2 tests, 0 skipped, 1 failed. |
|
750 | # Ran 2 tests, 0 skipped, 1 failed. | |
751 | python hash seed: * (glob) |
|
751 | python hash seed: * (glob) | |
752 | [1] |
|
752 | [1] | |
753 |
|
753 | |||
754 | $ cat test-failure.t |
|
754 | $ cat test-failure.t | |
755 | $ echo babar |
|
755 | $ echo babar | |
756 | rataxes |
|
756 | rataxes | |
757 | This is a noop statement so that |
|
757 | This is a noop statement so that | |
758 | this test is still more bytes than success. |
|
758 | this test is still more bytes than success. | |
759 | pad pad pad pad............................................................ |
|
759 | pad pad pad pad............................................................ | |
760 | pad pad pad pad............................................................ |
|
760 | pad pad pad pad............................................................ | |
761 | pad pad pad pad............................................................ |
|
761 | pad pad pad pad............................................................ | |
762 | pad pad pad pad............................................................ |
|
762 | pad pad pad pad............................................................ | |
763 | pad pad pad pad............................................................ |
|
763 | pad pad pad pad............................................................ | |
764 | pad pad pad pad............................................................ |
|
764 | pad pad pad pad............................................................ | |
765 |
|
765 | |||
766 | Interactive with custom view |
|
766 | Interactive with custom view | |
767 |
|
767 | |||
768 | $ echo 'n' | rt -i --view echo |
|
768 | $ echo 'n' | rt -i --view echo | |
769 | running 2 tests using 1 parallel processes |
|
769 | running 2 tests using 1 parallel processes | |
770 | $TESTTMP/test-failure.t $TESTTMP/test-failure.t.err |
|
770 | $TESTTMP/test-failure.t $TESTTMP/test-failure.t.err | |
771 | Accept this change? [n]* (glob) |
|
771 | Accept this change? [n]* (glob) | |
772 | ERROR: test-failure.t output changed |
|
772 | ERROR: test-failure.t output changed | |
773 | !. |
|
773 | !. | |
774 | Failed test-failure.t: output changed |
|
774 | Failed test-failure.t: output changed | |
775 | # Ran 2 tests, 0 skipped, 1 failed. |
|
775 | # Ran 2 tests, 0 skipped, 1 failed. | |
776 | python hash seed: * (glob) |
|
776 | python hash seed: * (glob) | |
777 | [1] |
|
777 | [1] | |
778 |
|
778 | |||
779 | View the fix |
|
779 | View the fix | |
780 |
|
780 | |||
781 | $ echo 'y' | rt --view echo |
|
781 | $ echo 'y' | rt --view echo | |
782 | running 2 tests using 1 parallel processes |
|
782 | running 2 tests using 1 parallel processes | |
783 | $TESTTMP/test-failure.t $TESTTMP/test-failure.t.err |
|
783 | $TESTTMP/test-failure.t $TESTTMP/test-failure.t.err | |
784 |
|
784 | |||
785 | ERROR: test-failure.t output changed |
|
785 | ERROR: test-failure.t output changed | |
786 | !. |
|
786 | !. | |
787 | Failed test-failure.t: output changed |
|
787 | Failed test-failure.t: output changed | |
788 | # Ran 2 tests, 0 skipped, 1 failed. |
|
788 | # Ran 2 tests, 0 skipped, 1 failed. | |
789 | python hash seed: * (glob) |
|
789 | python hash seed: * (glob) | |
790 | [1] |
|
790 | [1] | |
791 |
|
791 | |||
792 | Accept the fix |
|
792 | Accept the fix | |
793 |
|
793 | |||
794 | $ cat >> test-failure.t <<EOF |
|
794 | $ cat >> test-failure.t <<EOF | |
795 | > $ echo 'saved backup bundle to \$TESTTMP/foo.hg' |
|
795 | > $ echo 'saved backup bundle to \$TESTTMP/foo.hg' | |
796 | > saved backup bundle to \$TESTTMP/foo.hg |
|
796 | > saved backup bundle to \$TESTTMP/foo.hg | |
797 | > $ echo 'saved backup bundle to \$TESTTMP/foo.hg' |
|
797 | > $ echo 'saved backup bundle to \$TESTTMP/foo.hg' | |
798 | > saved backup bundle to $TESTTMP\\foo.hg |
|
798 | > saved backup bundle to $TESTTMP\\foo.hg | |
799 | > $ echo 'saved backup bundle to \$TESTTMP/foo.hg' |
|
799 | > $ echo 'saved backup bundle to \$TESTTMP/foo.hg' | |
800 | > saved backup bundle to \$TESTTMP/*.hg (glob) |
|
800 | > saved backup bundle to \$TESTTMP/*.hg (glob) | |
801 | > EOF |
|
801 | > EOF | |
802 | $ echo 'y' | rt -i 2>&1 |
|
802 | $ echo 'y' | rt -i 2>&1 | |
803 | running 2 tests using 1 parallel processes |
|
803 | running 2 tests using 1 parallel processes | |
804 |
|
804 | |||
805 | --- $TESTTMP/test-failure.t |
|
805 | --- $TESTTMP/test-failure.t | |
806 | +++ $TESTTMP/test-failure.t.err |
|
806 | +++ $TESTTMP/test-failure.t.err | |
807 | @@ -1,5 +1,5 @@ |
|
807 | @@ -1,5 +1,5 @@ | |
808 | $ echo babar |
|
808 | $ echo babar | |
809 | - rataxes |
|
809 | - rataxes | |
810 | + babar |
|
810 | + babar | |
811 | This is a noop statement so that |
|
811 | This is a noop statement so that | |
812 | this test is still more bytes than success. |
|
812 | this test is still more bytes than success. | |
813 | pad pad pad pad............................................................ |
|
813 | pad pad pad pad............................................................ | |
814 | @@ -11,6 +11,6 @@ |
|
814 | @@ -11,6 +11,6 @@ | |
815 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' |
|
815 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' | |
816 | saved backup bundle to $TESTTMP/foo.hg |
|
816 | saved backup bundle to $TESTTMP/foo.hg | |
817 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' |
|
817 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' | |
818 | - saved backup bundle to $TESTTMP\foo.hg |
|
818 | - saved backup bundle to $TESTTMP\foo.hg | |
819 | + saved backup bundle to $TESTTMP/foo.hg |
|
819 | + saved backup bundle to $TESTTMP/foo.hg | |
820 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' |
|
820 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' | |
821 | saved backup bundle to $TESTTMP/*.hg (glob) |
|
821 | saved backup bundle to $TESTTMP/*.hg (glob) | |
822 | Accept this change? [n] .. |
|
822 | Accept this change? [n] .. | |
823 | # Ran 2 tests, 0 skipped, 0 failed. |
|
823 | # Ran 2 tests, 0 skipped, 0 failed. | |
824 |
|
824 | |||
825 | $ sed -e 's,(glob)$,&<,g' test-failure.t |
|
825 | $ sed -e 's,(glob)$,&<,g' test-failure.t | |
826 | $ echo babar |
|
826 | $ echo babar | |
827 | babar |
|
827 | babar | |
828 | This is a noop statement so that |
|
828 | This is a noop statement so that | |
829 | this test is still more bytes than success. |
|
829 | this test is still more bytes than success. | |
830 | pad pad pad pad............................................................ |
|
830 | pad pad pad pad............................................................ | |
831 | pad pad pad pad............................................................ |
|
831 | pad pad pad pad............................................................ | |
832 | pad pad pad pad............................................................ |
|
832 | pad pad pad pad............................................................ | |
833 | pad pad pad pad............................................................ |
|
833 | pad pad pad pad............................................................ | |
834 | pad pad pad pad............................................................ |
|
834 | pad pad pad pad............................................................ | |
835 | pad pad pad pad............................................................ |
|
835 | pad pad pad pad............................................................ | |
836 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' |
|
836 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' | |
837 | saved backup bundle to $TESTTMP/foo.hg |
|
837 | saved backup bundle to $TESTTMP/foo.hg | |
838 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' |
|
838 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' | |
839 | saved backup bundle to $TESTTMP/foo.hg |
|
839 | saved backup bundle to $TESTTMP/foo.hg | |
840 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' |
|
840 | $ echo 'saved backup bundle to $TESTTMP/foo.hg' | |
841 | saved backup bundle to $TESTTMP/*.hg (glob)< |
|
841 | saved backup bundle to $TESTTMP/*.hg (glob)< | |
842 |
|
842 | |||
843 | Race condition - test file was modified when test is running |
|
843 | Race condition - test file was modified when test is running | |
844 |
|
844 | |||
845 | $ TESTRACEDIR=`pwd` |
|
845 | $ TESTRACEDIR=`pwd` | |
846 | $ export TESTRACEDIR |
|
846 | $ export TESTRACEDIR | |
847 | $ cat > test-race.t <<EOF |
|
847 | $ cat > test-race.t <<EOF | |
848 | > $ echo 1 |
|
848 | > $ echo 1 | |
849 | > $ echo "# a new line" >> $TESTRACEDIR/test-race.t |
|
849 | > $ echo "# a new line" >> $TESTRACEDIR/test-race.t | |
850 | > EOF |
|
850 | > EOF | |
851 |
|
851 | |||
852 | $ rt -i test-race.t |
|
852 | $ rt -i test-race.t | |
853 | running 1 tests using 1 parallel processes |
|
853 | running 1 tests using 1 parallel processes | |
854 |
|
854 | |||
855 | --- $TESTTMP/test-race.t |
|
855 | --- $TESTTMP/test-race.t | |
856 | +++ $TESTTMP/test-race.t.err |
|
856 | +++ $TESTTMP/test-race.t.err | |
857 | @@ -1,2 +1,3 @@ |
|
857 | @@ -1,2 +1,3 @@ | |
858 | $ echo 1 |
|
858 | $ echo 1 | |
859 | + 1 |
|
859 | + 1 | |
860 | $ echo "# a new line" >> $TESTTMP/test-race.t |
|
860 | $ echo "# a new line" >> $TESTTMP/test-race.t | |
861 | Reference output has changed (run again to prompt changes) |
|
861 | Reference output has changed (run again to prompt changes) | |
862 | ERROR: test-race.t output changed |
|
862 | ERROR: test-race.t output changed | |
863 | ! |
|
863 | ! | |
864 | Failed test-race.t: output changed |
|
864 | Failed test-race.t: output changed | |
865 | # Ran 1 tests, 0 skipped, 1 failed. |
|
865 | # Ran 1 tests, 0 skipped, 1 failed. | |
866 | python hash seed: * (glob) |
|
866 | python hash seed: * (glob) | |
867 | [1] |
|
867 | [1] | |
868 |
|
868 | |||
869 | $ rm test-race.t |
|
869 | $ rm test-race.t | |
870 |
|
870 | |||
871 | When "#testcases" is used in .t files |
|
871 | When "#testcases" is used in .t files | |
872 |
|
872 | |||
873 | $ cat >> test-cases.t <<EOF |
|
873 | $ cat >> test-cases.t <<EOF | |
874 | > #testcases a b |
|
874 | > #testcases a b | |
875 | > #if a |
|
875 | > #if a | |
876 | > $ echo 1 |
|
876 | > $ echo 1 | |
877 | > #endif |
|
877 | > #endif | |
878 | > #if b |
|
878 | > #if b | |
879 | > $ echo 2 |
|
879 | > $ echo 2 | |
880 | > #endif |
|
880 | > #endif | |
881 | > EOF |
|
881 | > EOF | |
882 |
|
882 | |||
883 | $ cat <<EOF | rt -i test-cases.t 2>&1 |
|
883 | $ cat <<EOF | rt -i test-cases.t 2>&1 | |
884 | > y |
|
884 | > y | |
885 | > y |
|
885 | > y | |
886 | > EOF |
|
886 | > EOF | |
887 | running 2 tests using 1 parallel processes |
|
887 | running 2 tests using 1 parallel processes | |
888 |
|
888 | |||
889 | --- $TESTTMP/test-cases.t |
|
889 | --- $TESTTMP/test-cases.t | |
890 | +++ $TESTTMP/test-cases.t#a.err |
|
890 | +++ $TESTTMP/test-cases.t#a.err | |
891 | @@ -1,6 +1,7 @@ |
|
891 | @@ -1,6 +1,7 @@ | |
892 | #testcases a b |
|
892 | #testcases a b | |
893 | #if a |
|
893 | #if a | |
894 | $ echo 1 |
|
894 | $ echo 1 | |
895 | + 1 |
|
895 | + 1 | |
896 | #endif |
|
896 | #endif | |
897 | #if b |
|
897 | #if b | |
898 | $ echo 2 |
|
898 | $ echo 2 | |
899 | Accept this change? [n] . |
|
899 | Accept this change? [n] . | |
900 | --- $TESTTMP/test-cases.t |
|
900 | --- $TESTTMP/test-cases.t | |
901 | +++ $TESTTMP/test-cases.t#b.err |
|
901 | +++ $TESTTMP/test-cases.t#b.err | |
902 | @@ -5,4 +5,5 @@ |
|
902 | @@ -5,4 +5,5 @@ | |
903 | #endif |
|
903 | #endif | |
904 | #if b |
|
904 | #if b | |
905 | $ echo 2 |
|
905 | $ echo 2 | |
906 | + 2 |
|
906 | + 2 | |
907 | #endif |
|
907 | #endif | |
908 | Accept this change? [n] . |
|
908 | Accept this change? [n] . | |
909 | # Ran 2 tests, 0 skipped, 0 failed. |
|
909 | # Ran 2 tests, 0 skipped, 0 failed. | |
910 |
|
910 | |||
911 | $ cat test-cases.t |
|
911 | $ cat test-cases.t | |
912 | #testcases a b |
|
912 | #testcases a b | |
913 | #if a |
|
913 | #if a | |
914 | $ echo 1 |
|
914 | $ echo 1 | |
915 | 1 |
|
915 | 1 | |
916 | #endif |
|
916 | #endif | |
917 | #if b |
|
917 | #if b | |
918 | $ echo 2 |
|
918 | $ echo 2 | |
919 | 2 |
|
919 | 2 | |
920 | #endif |
|
920 | #endif | |
921 |
|
921 | |||
922 | $ cat >> test-cases.t <<'EOF' |
|
922 | $ cat >> test-cases.t <<'EOF' | |
923 | > #if a |
|
923 | > #if a | |
924 | > $ NAME=A |
|
924 | > $ NAME=A | |
925 | > #else |
|
925 | > #else | |
926 | > $ NAME=B |
|
926 | > $ NAME=B | |
927 | > #endif |
|
927 | > #endif | |
928 | > $ echo $NAME |
|
928 | > $ echo $NAME | |
929 | > A (a !) |
|
929 | > A (a !) | |
930 | > B (b !) |
|
930 | > B (b !) | |
931 | > EOF |
|
931 | > EOF | |
932 | $ rt test-cases.t |
|
932 | $ rt test-cases.t | |
933 | running 2 tests using 1 parallel processes |
|
933 | running 2 tests using 1 parallel processes | |
934 | .. |
|
934 | .. | |
935 | # Ran 2 tests, 0 skipped, 0 failed. |
|
935 | # Ran 2 tests, 0 skipped, 0 failed. | |
936 |
|
936 | |||
937 | When using multiple dimensions of "#testcases" in .t files |
|
937 | When using multiple dimensions of "#testcases" in .t files | |
938 |
|
938 | |||
939 | $ cat > test-cases.t <<'EOF' |
|
939 | $ cat > test-cases.t <<'EOF' | |
940 | > #testcases a b |
|
940 | > #testcases a b | |
941 | > #testcases c d |
|
941 | > #testcases c d | |
942 | > #if a d |
|
942 | > #if a d | |
943 | > $ echo $TESTCASE |
|
943 | > $ echo $TESTCASE | |
944 | > a#d |
|
944 | > a#d | |
945 | > #endif |
|
945 | > #endif | |
946 | > #if b c |
|
946 | > #if b c | |
947 | > $ echo yes |
|
947 | > $ echo yes | |
948 | > no |
|
948 | > no | |
949 | > #endif |
|
949 | > #endif | |
950 | > EOF |
|
950 | > EOF | |
951 | $ rt test-cases.t |
|
951 | $ rt test-cases.t | |
952 | running 4 tests using 1 parallel processes |
|
952 | running 4 tests using 1 parallel processes | |
953 | .. |
|
953 | .. | |
954 | --- $TESTTMP/test-cases.t |
|
954 | --- $TESTTMP/test-cases.t | |
955 | +++ $TESTTMP/test-cases.t#b#c.err |
|
955 | +++ $TESTTMP/test-cases.t#b#c.err | |
956 | @@ -6,5 +6,5 @@ |
|
956 | @@ -6,5 +6,5 @@ | |
957 | #endif |
|
957 | #endif | |
958 | #if b c |
|
958 | #if b c | |
959 | $ echo yes |
|
959 | $ echo yes | |
960 | - no |
|
960 | - no | |
961 | + yes |
|
961 | + yes | |
962 | #endif |
|
962 | #endif | |
963 |
|
963 | |||
964 | ERROR: test-cases.t#b#c output changed |
|
964 | ERROR: test-cases.t#b#c output changed | |
965 | !. |
|
965 | !. | |
966 | Failed test-cases.t#b#c: output changed |
|
966 | Failed test-cases.t#b#c: output changed | |
967 | # Ran 4 tests, 0 skipped, 1 failed. |
|
967 | # Ran 4 tests, 0 skipped, 1 failed. | |
968 | python hash seed: * (glob) |
|
968 | python hash seed: * (glob) | |
969 | [1] |
|
969 | [1] | |
970 |
|
970 | |||
971 | $ rm test-cases.t#b#c.err |
|
971 | $ rm test-cases.t#b#c.err | |
972 | $ rm test-cases.t |
|
972 | $ rm test-cases.t | |
973 |
|
973 | |||
974 | (reinstall) |
|
974 | (reinstall) | |
975 | $ mv backup test-failure.t |
|
975 | $ mv backup test-failure.t | |
976 |
|
976 | |||
977 | No Diff |
|
977 | No Diff | |
978 | =============== |
|
978 | =============== | |
979 |
|
979 | |||
980 | $ rt --nodiff |
|
980 | $ rt --nodiff | |
981 | running 2 tests using 1 parallel processes |
|
981 | running 2 tests using 1 parallel processes | |
982 | !. |
|
982 | !. | |
983 | Failed test-failure.t: output changed |
|
983 | Failed test-failure.t: output changed | |
984 | # Ran 2 tests, 0 skipped, 1 failed. |
|
984 | # Ran 2 tests, 0 skipped, 1 failed. | |
985 | python hash seed: * (glob) |
|
985 | python hash seed: * (glob) | |
986 | [1] |
|
986 | [1] | |
987 |
|
987 | |||
988 | test --tmpdir support |
|
988 | test --tmpdir support | |
989 | $ rt --tmpdir=$TESTTMP/keep test-success.t |
|
989 | $ rt --tmpdir=$TESTTMP/keep test-success.t | |
990 | running 1 tests using 1 parallel processes |
|
990 | running 1 tests using 1 parallel processes | |
991 |
|
991 | |||
992 | Keeping testtmp dir: $TESTTMP/keep/child1/test-success.t |
|
992 | Keeping testtmp dir: $TESTTMP/keep/child1/test-success.t | |
993 | Keeping threadtmp dir: $TESTTMP/keep/child1 |
|
993 | Keeping threadtmp dir: $TESTTMP/keep/child1 | |
994 | . |
|
994 | . | |
995 | # Ran 1 tests, 0 skipped, 0 failed. |
|
995 | # Ran 1 tests, 0 skipped, 0 failed. | |
996 |
|
996 | |||
997 | timeouts |
|
997 | timeouts | |
998 | ======== |
|
998 | ======== | |
999 | $ cat > test-timeout.t <<EOF |
|
999 | $ cat > test-timeout.t <<EOF | |
1000 | > $ sleep 2 |
|
1000 | > $ sleep 2 | |
1001 | > $ echo pass |
|
1001 | > $ echo pass | |
1002 | > pass |
|
1002 | > pass | |
1003 | > EOF |
|
1003 | > EOF | |
1004 | > echo '#require slow' > test-slow-timeout.t |
|
1004 | > echo '#require slow' > test-slow-timeout.t | |
1005 | > cat test-timeout.t >> test-slow-timeout.t |
|
1005 | > cat test-timeout.t >> test-slow-timeout.t | |
1006 | $ rt --timeout=1 --slowtimeout=3 test-timeout.t test-slow-timeout.t |
|
1006 | $ rt --timeout=1 --slowtimeout=3 test-timeout.t test-slow-timeout.t | |
1007 | running 2 tests using 1 parallel processes |
|
1007 | running 2 tests using 1 parallel processes | |
1008 | st |
|
1008 | st | |
1009 | Skipped test-slow-timeout.t: missing feature: allow slow tests (use --allow-slow-tests) |
|
1009 | Skipped test-slow-timeout.t: missing feature: allow slow tests (use --allow-slow-tests) | |
1010 | Failed test-timeout.t: timed out |
|
1010 | Failed test-timeout.t: timed out | |
1011 | # Ran 1 tests, 1 skipped, 1 failed. |
|
1011 | # Ran 1 tests, 1 skipped, 1 failed. | |
1012 | python hash seed: * (glob) |
|
1012 | python hash seed: * (glob) | |
1013 | [1] |
|
1013 | [1] | |
1014 | $ rt --timeout=1 --slowtimeout=3 \ |
|
1014 | $ rt --timeout=1 --slowtimeout=3 \ | |
1015 | > test-timeout.t test-slow-timeout.t --allow-slow-tests |
|
1015 | > test-timeout.t test-slow-timeout.t --allow-slow-tests | |
1016 | running 2 tests using 1 parallel processes |
|
1016 | running 2 tests using 1 parallel processes | |
1017 | .t |
|
1017 | .t | |
1018 | Failed test-timeout.t: timed out |
|
1018 | Failed test-timeout.t: timed out | |
1019 | # Ran 2 tests, 0 skipped, 1 failed. |
|
1019 | # Ran 2 tests, 0 skipped, 1 failed. | |
1020 | python hash seed: * (glob) |
|
1020 | python hash seed: * (glob) | |
1021 | [1] |
|
1021 | [1] | |
1022 | $ rm test-timeout.t test-slow-timeout.t |
|
1022 | $ rm test-timeout.t test-slow-timeout.t | |
1023 |
|
1023 | |||
1024 | test for --time |
|
1024 | test for --time | |
1025 | ================== |
|
1025 | ================== | |
1026 |
|
1026 | |||
1027 | $ rt test-success.t --time |
|
1027 | $ rt test-success.t --time | |
1028 | running 1 tests using 1 parallel processes |
|
1028 | running 1 tests using 1 parallel processes | |
1029 | . |
|
1029 | . | |
1030 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1030 | # Ran 1 tests, 0 skipped, 0 failed. | |
1031 | # Producing time report |
|
1031 | # Producing time report | |
1032 | start end cuser csys real Test |
|
1032 | start end cuser csys real Test | |
1033 | \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} test-success.t (re) |
|
1033 | \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} test-success.t (re) | |
1034 |
|
1034 | |||
1035 | test for --time with --job enabled |
|
1035 | test for --time with --job enabled | |
1036 | ==================================== |
|
1036 | ==================================== | |
1037 |
|
1037 | |||
1038 | $ rt test-success.t --time --jobs 2 |
|
1038 | $ rt test-success.t --time --jobs 2 | |
1039 | running 1 tests using 1 parallel processes |
|
1039 | running 1 tests using 1 parallel processes | |
1040 | . |
|
1040 | . | |
1041 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1041 | # Ran 1 tests, 0 skipped, 0 failed. | |
1042 | # Producing time report |
|
1042 | # Producing time report | |
1043 | start end cuser csys real Test |
|
1043 | start end cuser csys real Test | |
1044 | \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} test-success.t (re) |
|
1044 | \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} \s*[\d\.]{5} test-success.t (re) | |
1045 |
|
1045 | |||
1046 | Skips |
|
1046 | Skips | |
1047 | ================ |
|
1047 | ================ | |
1048 | $ cat > test-skip.t <<EOF |
|
1048 | $ cat > test-skip.t <<EOF | |
1049 | > $ echo xyzzy |
|
1049 | > $ echo xyzzy | |
1050 | > #if true |
|
1050 | > #if true | |
1051 | > #require false |
|
1051 | > #require false | |
1052 | > #end |
|
1052 | > #end | |
1053 | > EOF |
|
1053 | > EOF | |
1054 | $ cat > test-noskip.t <<EOF |
|
1054 | $ cat > test-noskip.t <<EOF | |
1055 | > #if false |
|
1055 | > #if false | |
1056 | > #require false |
|
1056 | > #require false | |
1057 | > #endif |
|
1057 | > #endif | |
1058 | > EOF |
|
1058 | > EOF | |
1059 | $ rt --nodiff |
|
1059 | $ rt --nodiff | |
1060 | running 4 tests using 1 parallel processes |
|
1060 | running 4 tests using 1 parallel processes | |
1061 | !.s. |
|
1061 | !.s. | |
1062 | Skipped test-skip.t: missing feature: nail clipper |
|
1062 | Skipped test-skip.t: missing feature: nail clipper | |
1063 | Failed test-failure.t: output changed |
|
1063 | Failed test-failure.t: output changed | |
1064 | # Ran 3 tests, 1 skipped, 1 failed. |
|
1064 | # Ran 3 tests, 1 skipped, 1 failed. | |
1065 | python hash seed: * (glob) |
|
1065 | python hash seed: * (glob) | |
1066 | [1] |
|
1066 | [1] | |
1067 |
|
1067 | |||
1068 | $ rm test-noskip.t |
|
1068 | $ rm test-noskip.t | |
1069 | $ rt --keyword xyzzy |
|
1069 | $ rt --keyword xyzzy | |
1070 | running 3 tests using 1 parallel processes |
|
1070 | running 3 tests using 1 parallel processes | |
1071 | .s |
|
1071 | .s | |
1072 | Skipped test-skip.t: missing feature: nail clipper |
|
1072 | Skipped test-skip.t: missing feature: nail clipper | |
1073 | # Ran 2 tests, 2 skipped, 0 failed. |
|
1073 | # Ran 2 tests, 2 skipped, 0 failed. | |
1074 |
|
1074 | |||
1075 | Skips with xml |
|
1075 | Skips with xml | |
1076 | $ rt --keyword xyzzy \ |
|
1076 | $ rt --keyword xyzzy \ | |
1077 | > --xunit=xunit.xml |
|
1077 | > --xunit=xunit.xml | |
1078 | running 3 tests using 1 parallel processes |
|
1078 | running 3 tests using 1 parallel processes | |
1079 | .s |
|
1079 | .s | |
1080 | Skipped test-skip.t: missing feature: nail clipper |
|
1080 | Skipped test-skip.t: missing feature: nail clipper | |
1081 | # Ran 2 tests, 2 skipped, 0 failed. |
|
1081 | # Ran 2 tests, 2 skipped, 0 failed. | |
1082 | $ cat xunit.xml |
|
1082 | $ cat xunit.xml | |
1083 | <?xml version="1.0" encoding="utf-8"?> |
|
1083 | <?xml version="1.0" encoding="utf-8"?> | |
1084 | <testsuite errors="0" failures="0" name="run-tests" skipped="2" tests="2"> |
|
1084 | <testsuite errors="0" failures="0" name="run-tests" skipped="2" tests="2"> | |
1085 | <testcase name="test-success.t" time="*"/> (glob) |
|
1085 | <testcase name="test-success.t" time="*"/> (glob) | |
1086 | <testcase name="test-skip.t"> |
|
1086 | <testcase name="test-skip.t"> | |
1087 | <skipped> |
|
1087 | <skipped> | |
1088 | <![CDATA[missing feature: nail clipper]]> </skipped> |
|
1088 | <![CDATA[missing feature: nail clipper]]> </skipped> | |
1089 | </testcase> |
|
1089 | </testcase> | |
1090 | </testsuite> |
|
1090 | </testsuite> | |
1091 |
|
1091 | |||
1092 | Missing skips or blacklisted skips don't count as executed: |
|
1092 | Missing skips or blacklisted skips don't count as executed: | |
1093 | $ echo test-failure.t > blacklist |
|
1093 | $ echo test-failure.t > blacklist | |
1094 | $ rt --blacklist=blacklist --json\ |
|
1094 | $ rt --blacklist=blacklist --json\ | |
1095 | > test-failure.t test-bogus.t |
|
1095 | > test-failure.t test-bogus.t | |
1096 | running 2 tests using 1 parallel processes |
|
1096 | running 2 tests using 1 parallel processes | |
1097 | ss |
|
1097 | ss | |
1098 | Skipped test-bogus.t: Doesn't exist |
|
1098 | Skipped test-bogus.t: Doesn't exist | |
1099 | Skipped test-failure.t: blacklisted |
|
1099 | Skipped test-failure.t: blacklisted | |
1100 | # Ran 0 tests, 2 skipped, 0 failed. |
|
1100 | # Ran 0 tests, 2 skipped, 0 failed. | |
1101 | $ cat report.json |
|
1101 | $ cat report.json | |
1102 | testreport ={ |
|
1102 | testreport ={ | |
1103 | "test-bogus.t": { |
|
1103 | "test-bogus.t": { | |
1104 | "result": "skip" |
|
1104 | "result": "skip" | |
1105 | }, |
|
1105 | }, | |
1106 | "test-failure.t": { |
|
1106 | "test-failure.t": { | |
1107 | "result": "skip" |
|
1107 | "result": "skip" | |
1108 | } |
|
1108 | } | |
1109 | } (no-eol) |
|
1109 | } (no-eol) | |
1110 |
|
1110 | |||
1111 | Whitelist trumps blacklist |
|
1111 | Whitelist trumps blacklist | |
1112 | $ echo test-failure.t > whitelist |
|
1112 | $ echo test-failure.t > whitelist | |
1113 | $ rt --blacklist=blacklist --whitelist=whitelist --json\ |
|
1113 | $ rt --blacklist=blacklist --whitelist=whitelist --json\ | |
1114 | > test-failure.t test-bogus.t |
|
1114 | > test-failure.t test-bogus.t | |
1115 | running 2 tests using 1 parallel processes |
|
1115 | running 2 tests using 1 parallel processes | |
1116 | s |
|
1116 | s | |
1117 | --- $TESTTMP/test-failure.t |
|
1117 | --- $TESTTMP/test-failure.t | |
1118 | +++ $TESTTMP/test-failure.t.err |
|
1118 | +++ $TESTTMP/test-failure.t.err | |
1119 | @@ -1,5 +1,5 @@ |
|
1119 | @@ -1,5 +1,5 @@ | |
1120 | $ echo babar |
|
1120 | $ echo babar | |
1121 | - rataxes |
|
1121 | - rataxes | |
1122 | + babar |
|
1122 | + babar | |
1123 | This is a noop statement so that |
|
1123 | This is a noop statement so that | |
1124 | this test is still more bytes than success. |
|
1124 | this test is still more bytes than success. | |
1125 | pad pad pad pad............................................................ |
|
1125 | pad pad pad pad............................................................ | |
1126 |
|
1126 | |||
1127 | ERROR: test-failure.t output changed |
|
1127 | ERROR: test-failure.t output changed | |
1128 | ! |
|
1128 | ! | |
1129 | Skipped test-bogus.t: Doesn't exist |
|
1129 | Skipped test-bogus.t: Doesn't exist | |
1130 | Failed test-failure.t: output changed |
|
1130 | Failed test-failure.t: output changed | |
1131 | # Ran 1 tests, 1 skipped, 1 failed. |
|
1131 | # Ran 1 tests, 1 skipped, 1 failed. | |
1132 | python hash seed: * (glob) |
|
1132 | python hash seed: * (glob) | |
1133 | [1] |
|
1133 | [1] | |
1134 |
|
1134 | |||
1135 | Ensure that --test-list causes only the tests listed in that file to |
|
1135 | Ensure that --test-list causes only the tests listed in that file to | |
1136 | be executed. |
|
1136 | be executed. | |
1137 | $ echo test-success.t >> onlytest |
|
1137 | $ echo test-success.t >> onlytest | |
1138 | $ rt --test-list=onlytest |
|
1138 | $ rt --test-list=onlytest | |
1139 | running 1 tests using 1 parallel processes |
|
1139 | running 1 tests using 1 parallel processes | |
1140 | . |
|
1140 | . | |
1141 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1141 | # Ran 1 tests, 0 skipped, 0 failed. | |
1142 | $ echo test-bogus.t >> anothertest |
|
1142 | $ echo test-bogus.t >> anothertest | |
1143 | $ rt --test-list=onlytest --test-list=anothertest |
|
1143 | $ rt --test-list=onlytest --test-list=anothertest | |
1144 | running 2 tests using 1 parallel processes |
|
1144 | running 2 tests using 1 parallel processes | |
1145 | s. |
|
1145 | s. | |
1146 | Skipped test-bogus.t: Doesn't exist |
|
1146 | Skipped test-bogus.t: Doesn't exist | |
1147 | # Ran 1 tests, 1 skipped, 0 failed. |
|
1147 | # Ran 1 tests, 1 skipped, 0 failed. | |
1148 | $ rm onlytest anothertest |
|
1148 | $ rm onlytest anothertest | |
1149 |
|
1149 | |||
1150 | test for --json |
|
1150 | test for --json | |
1151 | ================== |
|
1151 | ================== | |
1152 |
|
1152 | |||
1153 | $ rt --json |
|
1153 | $ rt --json | |
1154 | running 3 tests using 1 parallel processes |
|
1154 | running 3 tests using 1 parallel processes | |
1155 |
|
1155 | |||
1156 | --- $TESTTMP/test-failure.t |
|
1156 | --- $TESTTMP/test-failure.t | |
1157 | +++ $TESTTMP/test-failure.t.err |
|
1157 | +++ $TESTTMP/test-failure.t.err | |
1158 | @@ -1,5 +1,5 @@ |
|
1158 | @@ -1,5 +1,5 @@ | |
1159 | $ echo babar |
|
1159 | $ echo babar | |
1160 | - rataxes |
|
1160 | - rataxes | |
1161 | + babar |
|
1161 | + babar | |
1162 | This is a noop statement so that |
|
1162 | This is a noop statement so that | |
1163 | this test is still more bytes than success. |
|
1163 | this test is still more bytes than success. | |
1164 | pad pad pad pad............................................................ |
|
1164 | pad pad pad pad............................................................ | |
1165 |
|
1165 | |||
1166 | ERROR: test-failure.t output changed |
|
1166 | ERROR: test-failure.t output changed | |
1167 | !.s |
|
1167 | !.s | |
1168 | Skipped test-skip.t: missing feature: nail clipper |
|
1168 | Skipped test-skip.t: missing feature: nail clipper | |
1169 | Failed test-failure.t: output changed |
|
1169 | Failed test-failure.t: output changed | |
1170 | # Ran 2 tests, 1 skipped, 1 failed. |
|
1170 | # Ran 2 tests, 1 skipped, 1 failed. | |
1171 | python hash seed: * (glob) |
|
1171 | python hash seed: * (glob) | |
1172 | [1] |
|
1172 | [1] | |
1173 |
|
1173 | |||
1174 | $ cat report.json |
|
1174 | $ cat report.json | |
1175 | testreport ={ |
|
1175 | testreport ={ | |
1176 | "test-failure.t": [\{] (re) |
|
1176 | "test-failure.t": [\{] (re) | |
1177 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1177 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1178 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1178 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1179 | "diff": "---.+\+\+\+.+", ? (re) |
|
1179 | "diff": "---.+\+\+\+.+", ? (re) | |
1180 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1180 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1181 | "result": "failure", ? (re) |
|
1181 | "result": "failure", ? (re) | |
1182 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1182 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1183 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1183 | "time": "\s*\d+\.\d{3,4}" (re) | |
1184 | }, ? (re) |
|
1184 | }, ? (re) | |
1185 | "test-skip.t": { |
|
1185 | "test-skip.t": { | |
1186 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1186 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1187 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1187 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1188 | "diff": "", ? (re) |
|
1188 | "diff": "", ? (re) | |
1189 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1189 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1190 | "result": "skip", ? (re) |
|
1190 | "result": "skip", ? (re) | |
1191 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1191 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1192 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1192 | "time": "\s*\d+\.\d{3,4}" (re) | |
1193 | }, ? (re) |
|
1193 | }, ? (re) | |
1194 | "test-success.t": [\{] (re) |
|
1194 | "test-success.t": [\{] (re) | |
1195 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1195 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1196 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1196 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1197 | "diff": "", ? (re) |
|
1197 | "diff": "", ? (re) | |
1198 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1198 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1199 | "result": "success", ? (re) |
|
1199 | "result": "success", ? (re) | |
1200 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1200 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1201 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1201 | "time": "\s*\d+\.\d{3,4}" (re) | |
1202 | } |
|
1202 | } | |
1203 | } (no-eol) |
|
1203 | } (no-eol) | |
1204 | --json with --outputdir |
|
1204 | --json with --outputdir | |
1205 |
|
1205 | |||
1206 | $ rm report.json |
|
1206 | $ rm report.json | |
1207 | $ rm -r output |
|
1207 | $ rm -r output | |
1208 | $ mkdir output |
|
1208 | $ mkdir output | |
1209 | $ rt --json --outputdir output |
|
1209 | $ rt --json --outputdir output | |
1210 | running 3 tests using 1 parallel processes |
|
1210 | running 3 tests using 1 parallel processes | |
1211 |
|
1211 | |||
1212 | --- $TESTTMP/test-failure.t |
|
1212 | --- $TESTTMP/test-failure.t | |
1213 | +++ $TESTTMP/output/test-failure.t.err |
|
1213 | +++ $TESTTMP/output/test-failure.t.err | |
1214 | @@ -1,5 +1,5 @@ |
|
1214 | @@ -1,5 +1,5 @@ | |
1215 | $ echo babar |
|
1215 | $ echo babar | |
1216 | - rataxes |
|
1216 | - rataxes | |
1217 | + babar |
|
1217 | + babar | |
1218 | This is a noop statement so that |
|
1218 | This is a noop statement so that | |
1219 | this test is still more bytes than success. |
|
1219 | this test is still more bytes than success. | |
1220 | pad pad pad pad............................................................ |
|
1220 | pad pad pad pad............................................................ | |
1221 |
|
1221 | |||
1222 | ERROR: test-failure.t output changed |
|
1222 | ERROR: test-failure.t output changed | |
1223 | !.s |
|
1223 | !.s | |
1224 | Skipped test-skip.t: missing feature: nail clipper |
|
1224 | Skipped test-skip.t: missing feature: nail clipper | |
1225 | Failed test-failure.t: output changed |
|
1225 | Failed test-failure.t: output changed | |
1226 | # Ran 2 tests, 1 skipped, 1 failed. |
|
1226 | # Ran 2 tests, 1 skipped, 1 failed. | |
1227 | python hash seed: * (glob) |
|
1227 | python hash seed: * (glob) | |
1228 | [1] |
|
1228 | [1] | |
1229 | $ f report.json |
|
1229 | $ f report.json | |
1230 | report.json: file not found |
|
1230 | report.json: file not found | |
1231 | $ cat output/report.json |
|
1231 | $ cat output/report.json | |
1232 | testreport ={ |
|
1232 | testreport ={ | |
1233 | "test-failure.t": [\{] (re) |
|
1233 | "test-failure.t": [\{] (re) | |
1234 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1234 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1235 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1235 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1236 | "diff": "---.+\+\+\+.+", ? (re) |
|
1236 | "diff": "---.+\+\+\+.+", ? (re) | |
1237 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1237 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1238 | "result": "failure", ? (re) |
|
1238 | "result": "failure", ? (re) | |
1239 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1239 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1240 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1240 | "time": "\s*\d+\.\d{3,4}" (re) | |
1241 | }, ? (re) |
|
1241 | }, ? (re) | |
1242 | "test-skip.t": { |
|
1242 | "test-skip.t": { | |
1243 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1243 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1244 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1244 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1245 | "diff": "", ? (re) |
|
1245 | "diff": "", ? (re) | |
1246 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1246 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1247 | "result": "skip", ? (re) |
|
1247 | "result": "skip", ? (re) | |
1248 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1248 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1249 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1249 | "time": "\s*\d+\.\d{3,4}" (re) | |
1250 | }, ? (re) |
|
1250 | }, ? (re) | |
1251 | "test-success.t": [\{] (re) |
|
1251 | "test-success.t": [\{] (re) | |
1252 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1252 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1253 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1253 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1254 | "diff": "", ? (re) |
|
1254 | "diff": "", ? (re) | |
1255 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1255 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1256 | "result": "success", ? (re) |
|
1256 | "result": "success", ? (re) | |
1257 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1257 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1258 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1258 | "time": "\s*\d+\.\d{3,4}" (re) | |
1259 | } |
|
1259 | } | |
1260 | } (no-eol) |
|
1260 | } (no-eol) | |
1261 | $ ls -a output |
|
1261 | $ ls -a output | |
1262 | . |
|
1262 | . | |
1263 | .. |
|
1263 | .. | |
1264 | .testtimes |
|
1264 | .testtimes | |
1265 | report.json |
|
1265 | report.json | |
1266 | test-failure.t.err |
|
1266 | test-failure.t.err | |
1267 |
|
1267 | |||
1268 | Test that failed test accepted through interactive are properly reported: |
|
1268 | Test that failed test accepted through interactive are properly reported: | |
1269 |
|
1269 | |||
1270 | $ cp test-failure.t backup |
|
1270 | $ cp test-failure.t backup | |
1271 | $ echo y | rt --json -i |
|
1271 | $ echo y | rt --json -i | |
1272 | running 3 tests using 1 parallel processes |
|
1272 | running 3 tests using 1 parallel processes | |
1273 |
|
1273 | |||
1274 | --- $TESTTMP/test-failure.t |
|
1274 | --- $TESTTMP/test-failure.t | |
1275 | +++ $TESTTMP/test-failure.t.err |
|
1275 | +++ $TESTTMP/test-failure.t.err | |
1276 | @@ -1,5 +1,5 @@ |
|
1276 | @@ -1,5 +1,5 @@ | |
1277 | $ echo babar |
|
1277 | $ echo babar | |
1278 | - rataxes |
|
1278 | - rataxes | |
1279 | + babar |
|
1279 | + babar | |
1280 | This is a noop statement so that |
|
1280 | This is a noop statement so that | |
1281 | this test is still more bytes than success. |
|
1281 | this test is still more bytes than success. | |
1282 | pad pad pad pad............................................................ |
|
1282 | pad pad pad pad............................................................ | |
1283 | Accept this change? [n] ..s |
|
1283 | Accept this change? [n] ..s | |
1284 | Skipped test-skip.t: missing feature: nail clipper |
|
1284 | Skipped test-skip.t: missing feature: nail clipper | |
1285 | # Ran 2 tests, 1 skipped, 0 failed. |
|
1285 | # Ran 2 tests, 1 skipped, 0 failed. | |
1286 |
|
1286 | |||
1287 | $ cat report.json |
|
1287 | $ cat report.json | |
1288 | testreport ={ |
|
1288 | testreport ={ | |
1289 | "test-failure.t": [\{] (re) |
|
1289 | "test-failure.t": [\{] (re) | |
1290 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1290 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1291 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1291 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1292 | "diff": "", ? (re) |
|
1292 | "diff": "", ? (re) | |
1293 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1293 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1294 | "result": "success", ? (re) |
|
1294 | "result": "success", ? (re) | |
1295 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1295 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1296 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1296 | "time": "\s*\d+\.\d{3,4}" (re) | |
1297 | }, ? (re) |
|
1297 | }, ? (re) | |
1298 | "test-skip.t": { |
|
1298 | "test-skip.t": { | |
1299 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1299 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1300 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1300 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1301 | "diff": "", ? (re) |
|
1301 | "diff": "", ? (re) | |
1302 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1302 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1303 | "result": "skip", ? (re) |
|
1303 | "result": "skip", ? (re) | |
1304 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1304 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1305 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1305 | "time": "\s*\d+\.\d{3,4}" (re) | |
1306 | }, ? (re) |
|
1306 | }, ? (re) | |
1307 | "test-success.t": [\{] (re) |
|
1307 | "test-success.t": [\{] (re) | |
1308 | "csys": "\s*\d+\.\d{3,4}", ? (re) |
|
1308 | "csys": "\s*\d+\.\d{3,4}", ? (re) | |
1309 | "cuser": "\s*\d+\.\d{3,4}", ? (re) |
|
1309 | "cuser": "\s*\d+\.\d{3,4}", ? (re) | |
1310 | "diff": "", ? (re) |
|
1310 | "diff": "", ? (re) | |
1311 | "end": "\s*\d+\.\d{3,4}", ? (re) |
|
1311 | "end": "\s*\d+\.\d{3,4}", ? (re) | |
1312 | "result": "success", ? (re) |
|
1312 | "result": "success", ? (re) | |
1313 | "start": "\s*\d+\.\d{3,4}", ? (re) |
|
1313 | "start": "\s*\d+\.\d{3,4}", ? (re) | |
1314 | "time": "\s*\d+\.\d{3,4}" (re) |
|
1314 | "time": "\s*\d+\.\d{3,4}" (re) | |
1315 | } |
|
1315 | } | |
1316 | } (no-eol) |
|
1316 | } (no-eol) | |
1317 | $ mv backup test-failure.t |
|
1317 | $ mv backup test-failure.t | |
1318 |
|
1318 | |||
1319 | backslash on end of line with glob matching is handled properly |
|
1319 | backslash on end of line with glob matching is handled properly | |
1320 |
|
1320 | |||
1321 | $ cat > test-glob-backslash.t << EOF |
|
1321 | $ cat > test-glob-backslash.t << EOF | |
1322 | > $ echo 'foo bar \\' |
|
1322 | > $ echo 'foo bar \\' | |
1323 | > foo * \ (glob) |
|
1323 | > foo * \ (glob) | |
1324 | > EOF |
|
1324 | > EOF | |
1325 |
|
1325 | |||
1326 | $ rt test-glob-backslash.t |
|
1326 | $ rt test-glob-backslash.t | |
1327 | running 1 tests using 1 parallel processes |
|
1327 | running 1 tests using 1 parallel processes | |
1328 | . |
|
1328 | . | |
1329 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1329 | # Ran 1 tests, 0 skipped, 0 failed. | |
1330 |
|
1330 | |||
1331 | $ rm -f test-glob-backslash.t |
|
1331 | $ rm -f test-glob-backslash.t | |
1332 |
|
1332 | |||
1333 | Test globbing of local IP addresses |
|
1333 | Test globbing of local IP addresses | |
1334 | $ echo 172.16.18.1 |
|
1334 | $ echo 172.16.18.1 | |
1335 | $LOCALIP (glob) |
|
1335 | $LOCALIP (glob) | |
1336 | $ echo dead:beef::1 |
|
1336 | $ echo dead:beef::1 | |
1337 | $LOCALIP (glob) |
|
1337 | $LOCALIP (glob) | |
1338 |
|
1338 | |||
1339 | Add support for external test formatter |
|
1339 | Add support for external test formatter | |
1340 | ======================================= |
|
1340 | ======================================= | |
1341 |
|
1341 | |||
1342 | $ CUSTOM_TEST_RESULT=basic_test_result "$PYTHON" $TESTDIR/run-tests.py --with-hg=`which hg` -j1 "$@" test-success.t test-failure.t |
|
1342 | $ CUSTOM_TEST_RESULT=basic_test_result "$PYTHON" $TESTDIR/run-tests.py --with-hg=`which hg` -j1 "$@" test-success.t test-failure.t | |
1343 | running 2 tests using 1 parallel processes |
|
1343 | running 2 tests using 1 parallel processes | |
1344 |
|
1344 | |||
1345 | # Ran 2 tests, 0 skipped, 0 failed. |
|
1345 | # Ran 2 tests, 0 skipped, 0 failed. | |
1346 | ON_START! <__main__.TestSuite tests=[<__main__.TTest testMethod=test-failure.t>, <__main__.TTest testMethod=test-success.t>]> |
|
1346 | ON_START! <__main__.TestSuite tests=[<__main__.TTest testMethod=test-failure.t>, <__main__.TTest testMethod=test-success.t>]> | |
1347 | FAILURE! test-failure.t output changed |
|
1347 | FAILURE! test-failure.t output changed | |
1348 | SUCCESS! test-success.t |
|
1348 | SUCCESS! test-success.t | |
1349 | ON_END! |
|
1349 | ON_END! | |
1350 |
|
1350 | |||
1351 | Test reusability for third party tools |
|
1351 | Test reusability for third party tools | |
1352 | ====================================== |
|
1352 | ====================================== | |
1353 |
|
1353 | |||
1354 | $ mkdir "$TESTTMP"/anothertests |
|
1354 | $ mkdir "$TESTTMP"/anothertests | |
1355 | $ cd "$TESTTMP"/anothertests |
|
1355 | $ cd "$TESTTMP"/anothertests | |
1356 |
|
1356 | |||
1357 | test that `run-tests.py` can execute hghave, even if it runs not in |
|
1357 | test that `run-tests.py` can execute hghave, even if it runs not in | |
1358 | Mercurial source tree. |
|
1358 | Mercurial source tree. | |
1359 |
|
1359 | |||
1360 | $ cat > test-hghave.t <<EOF |
|
1360 | $ cat > test-hghave.t <<EOF | |
1361 | > #require true |
|
1361 | > #require true | |
1362 | > $ echo foo |
|
1362 | > $ echo foo | |
1363 | > foo |
|
1363 | > foo | |
1364 | > EOF |
|
1364 | > EOF | |
1365 | $ rt test-hghave.t |
|
1365 | $ rt test-hghave.t | |
1366 | running 1 tests using 1 parallel processes |
|
1366 | running 1 tests using 1 parallel processes | |
1367 | . |
|
1367 | . | |
1368 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1368 | # Ran 1 tests, 0 skipped, 0 failed. | |
1369 |
|
1369 | |||
1370 | test that RUNTESTDIR refers the directory, in which `run-tests.py` now |
|
1370 | test that RUNTESTDIR refers the directory, in which `run-tests.py` now | |
1371 | running is placed. |
|
1371 | running is placed. | |
1372 |
|
1372 | |||
1373 | $ cat > test-runtestdir.t <<EOF |
|
1373 | $ cat > test-runtestdir.t <<EOF | |
1374 | > - $TESTDIR, in which test-run-tests.t is placed |
|
1374 | > - $TESTDIR, in which test-run-tests.t is placed | |
1375 | > - \$TESTDIR, in which test-runtestdir.t is placed (expanded at runtime) |
|
1375 | > - \$TESTDIR, in which test-runtestdir.t is placed (expanded at runtime) | |
1376 | > - \$RUNTESTDIR, in which run-tests.py is placed (expanded at runtime) |
|
1376 | > - \$RUNTESTDIR, in which run-tests.py is placed (expanded at runtime) | |
1377 | > |
|
1377 | > | |
1378 | > #if windows |
|
1378 | > #if windows | |
1379 | > $ test "\$TESTDIR" = "$TESTTMP\anothertests" |
|
1379 | > $ test "\$TESTDIR" = "$TESTTMP\anothertests" | |
1380 | > #else |
|
1380 | > #else | |
1381 | > $ test "\$TESTDIR" = "$TESTTMP"/anothertests |
|
1381 | > $ test "\$TESTDIR" = "$TESTTMP"/anothertests | |
1382 | > #endif |
|
1382 | > #endif | |
1383 | > If this prints a path, that means RUNTESTDIR didn't equal |
|
1383 | > If this prints a path, that means RUNTESTDIR didn't equal | |
1384 | > TESTDIR as it should have. |
|
1384 | > TESTDIR as it should have. | |
1385 | > $ test "\$RUNTESTDIR" = "$TESTDIR" || echo "\$RUNTESTDIR" |
|
1385 | > $ test "\$RUNTESTDIR" = "$TESTDIR" || echo "\$RUNTESTDIR" | |
1386 | > This should print the start of check-code. If this passes but the |
|
1386 | > This should print the start of check-code. If this passes but the | |
1387 | > previous check failed, that means we found a copy of check-code at whatever |
|
1387 | > previous check failed, that means we found a copy of check-code at whatever | |
1388 | > RUNTESTSDIR ended up containing, even though it doesn't match TESTDIR. |
|
1388 | > RUNTESTSDIR ended up containing, even though it doesn't match TESTDIR. | |
1389 | > $ head -n 3 "\$RUNTESTDIR"/../contrib/check-code.py | sed 's@.!.*python@#!USRBINENVPY@' |
|
1389 | > $ head -n 3 "\$RUNTESTDIR"/../contrib/check-code.py | sed 's@.!.*python@#!USRBINENVPY@' | |
1390 | > #!USRBINENVPY |
|
1390 | > #!USRBINENVPY | |
1391 | > # |
|
1391 | > # | |
1392 | > # check-code - a style and portability checker for Mercurial |
|
1392 | > # check-code - a style and portability checker for Mercurial | |
1393 | > EOF |
|
1393 | > EOF | |
1394 | $ rt test-runtestdir.t |
|
1394 | $ rt test-runtestdir.t | |
1395 | running 1 tests using 1 parallel processes |
|
1395 | running 1 tests using 1 parallel processes | |
1396 | . |
|
1396 | . | |
1397 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1397 | # Ran 1 tests, 0 skipped, 0 failed. | |
1398 |
|
1398 | |||
1399 | #if execbit |
|
1399 | #if execbit | |
1400 |
|
1400 | |||
1401 | test that TESTDIR is referred in PATH |
|
1401 | test that TESTDIR is referred in PATH | |
1402 |
|
1402 | |||
1403 | $ cat > custom-command.sh <<EOF |
|
1403 | $ cat > custom-command.sh <<EOF | |
1404 | > #!/bin/sh |
|
1404 | > #!/bin/sh | |
1405 | > echo "hello world" |
|
1405 | > echo "hello world" | |
1406 | > EOF |
|
1406 | > EOF | |
1407 | $ chmod +x custom-command.sh |
|
1407 | $ chmod +x custom-command.sh | |
1408 | $ cat > test-testdir-path.t <<EOF |
|
1408 | $ cat > test-testdir-path.t <<EOF | |
1409 | > $ custom-command.sh |
|
1409 | > $ custom-command.sh | |
1410 | > hello world |
|
1410 | > hello world | |
1411 | > EOF |
|
1411 | > EOF | |
1412 | $ rt test-testdir-path.t |
|
1412 | $ rt test-testdir-path.t | |
1413 | running 1 tests using 1 parallel processes |
|
1413 | running 1 tests using 1 parallel processes | |
1414 | . |
|
1414 | . | |
1415 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1415 | # Ran 1 tests, 0 skipped, 0 failed. | |
1416 |
|
1416 | |||
1417 | #endif |
|
1417 | #endif | |
1418 |
|
1418 | |||
1419 | test support for --allow-slow-tests |
|
1419 | test support for --allow-slow-tests | |
1420 | $ cat > test-very-slow-test.t <<EOF |
|
1420 | $ cat > test-very-slow-test.t <<EOF | |
1421 | > #require slow |
|
1421 | > #require slow | |
1422 | > $ echo pass |
|
1422 | > $ echo pass | |
1423 | > pass |
|
1423 | > pass | |
1424 | > EOF |
|
1424 | > EOF | |
1425 | $ rt test-very-slow-test.t |
|
1425 | $ rt test-very-slow-test.t | |
1426 | running 1 tests using 1 parallel processes |
|
1426 | running 1 tests using 1 parallel processes | |
1427 | s |
|
1427 | s | |
1428 | Skipped test-very-slow-test.t: missing feature: allow slow tests (use --allow-slow-tests) |
|
1428 | Skipped test-very-slow-test.t: missing feature: allow slow tests (use --allow-slow-tests) | |
1429 | # Ran 0 tests, 1 skipped, 0 failed. |
|
1429 | # Ran 0 tests, 1 skipped, 0 failed. | |
1430 | $ rt $HGTEST_RUN_TESTS_PURE --allow-slow-tests test-very-slow-test.t |
|
1430 | $ rt $HGTEST_RUN_TESTS_PURE --allow-slow-tests test-very-slow-test.t | |
1431 | running 1 tests using 1 parallel processes |
|
1431 | running 1 tests using 1 parallel processes | |
1432 | . |
|
1432 | . | |
1433 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1433 | # Ran 1 tests, 0 skipped, 0 failed. | |
1434 |
|
1434 | |||
1435 | support for running a test outside the current directory |
|
1435 | support for running a test outside the current directory | |
1436 | $ mkdir nonlocal |
|
1436 | $ mkdir nonlocal | |
1437 | $ cat > nonlocal/test-is-not-here.t << EOF |
|
1437 | $ cat > nonlocal/test-is-not-here.t << EOF | |
1438 | > $ echo pass |
|
1438 | > $ echo pass | |
1439 | > pass |
|
1439 | > pass | |
1440 | > EOF |
|
1440 | > EOF | |
1441 | $ rt nonlocal/test-is-not-here.t |
|
1441 | $ rt nonlocal/test-is-not-here.t | |
1442 | running 1 tests using 1 parallel processes |
|
1442 | running 1 tests using 1 parallel processes | |
1443 | . |
|
1443 | . | |
1444 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1444 | # Ran 1 tests, 0 skipped, 0 failed. | |
1445 |
|
1445 | |||
1446 | support for automatically discovering test if arg is a folder |
|
1446 | support for automatically discovering test if arg is a folder | |
1447 | $ mkdir tmp && cd tmp |
|
1447 | $ mkdir tmp && cd tmp | |
1448 |
|
1448 | |||
1449 | $ cat > test-uno.t << EOF |
|
1449 | $ cat > test-uno.t << EOF | |
1450 | > $ echo line |
|
1450 | > $ echo line | |
1451 | > line |
|
1451 | > line | |
1452 | > EOF |
|
1452 | > EOF | |
1453 |
|
1453 | |||
1454 | $ cp test-uno.t test-dos.t |
|
1454 | $ cp test-uno.t test-dos.t | |
1455 | $ cd .. |
|
1455 | $ cd .. | |
1456 | $ cp -R tmp tmpp |
|
1456 | $ cp -R tmp tmpp | |
1457 | $ cp tmp/test-uno.t test-solo.t |
|
1457 | $ cp tmp/test-uno.t test-solo.t | |
1458 |
|
1458 | |||
1459 | $ rt tmp/ test-solo.t tmpp |
|
1459 | $ rt tmp/ test-solo.t tmpp | |
1460 | running 5 tests using 1 parallel processes |
|
1460 | running 5 tests using 1 parallel processes | |
1461 | ..... |
|
1461 | ..... | |
1462 | # Ran 5 tests, 0 skipped, 0 failed. |
|
1462 | # Ran 5 tests, 0 skipped, 0 failed. | |
1463 | $ rm -rf tmp tmpp |
|
1463 | $ rm -rf tmp tmpp | |
1464 |
|
1464 | |||
1465 | support for running run-tests.py from another directory |
|
1465 | support for running run-tests.py from another directory | |
1466 | $ mkdir tmp && cd tmp |
|
1466 | $ mkdir tmp && cd tmp | |
1467 |
|
1467 | |||
1468 | $ cat > useful-file.sh << EOF |
|
1468 | $ cat > useful-file.sh << EOF | |
1469 | > important command |
|
1469 | > important command | |
1470 | > EOF |
|
1470 | > EOF | |
1471 |
|
1471 | |||
1472 | $ cat > test-folder.t << EOF |
|
1472 | $ cat > test-folder.t << EOF | |
1473 | > $ cat \$TESTDIR/useful-file.sh |
|
1473 | > $ cat \$TESTDIR/useful-file.sh | |
1474 | > important command |
|
1474 | > important command | |
1475 | > EOF |
|
1475 | > EOF | |
1476 |
|
1476 | |||
1477 | $ cat > test-folder-fail.t << EOF |
|
1477 | $ cat > test-folder-fail.t << EOF | |
1478 | > $ cat \$TESTDIR/useful-file.sh |
|
1478 | > $ cat \$TESTDIR/useful-file.sh | |
1479 | > important commando |
|
1479 | > important commando | |
1480 | > EOF |
|
1480 | > EOF | |
1481 |
|
1481 | |||
1482 | $ cd .. |
|
1482 | $ cd .. | |
1483 | $ rt tmp/test-*.t |
|
1483 | $ rt tmp/test-*.t | |
1484 | running 2 tests using 1 parallel processes |
|
1484 | running 2 tests using 1 parallel processes | |
1485 |
|
1485 | |||
1486 | --- $TESTTMP/anothertests/tmp/test-folder-fail.t |
|
1486 | --- $TESTTMP/anothertests/tmp/test-folder-fail.t | |
1487 | +++ $TESTTMP/anothertests/tmp/test-folder-fail.t.err |
|
1487 | +++ $TESTTMP/anothertests/tmp/test-folder-fail.t.err | |
1488 | @@ -1,2 +1,2 @@ |
|
1488 | @@ -1,2 +1,2 @@ | |
1489 | $ cat $TESTDIR/useful-file.sh |
|
1489 | $ cat $TESTDIR/useful-file.sh | |
1490 | - important commando |
|
1490 | - important commando | |
1491 | + important command |
|
1491 | + important command | |
1492 |
|
1492 | |||
1493 | ERROR: test-folder-fail.t output changed |
|
1493 | ERROR: test-folder-fail.t output changed | |
1494 | !. |
|
1494 | !. | |
1495 | Failed test-folder-fail.t: output changed |
|
1495 | Failed test-folder-fail.t: output changed | |
1496 | # Ran 2 tests, 0 skipped, 1 failed. |
|
1496 | # Ran 2 tests, 0 skipped, 1 failed. | |
1497 | python hash seed: * (glob) |
|
1497 | python hash seed: * (glob) | |
1498 | [1] |
|
1498 | [1] | |
1499 |
|
1499 | |||
1500 | support for bisecting failed tests automatically |
|
1500 | support for bisecting failed tests automatically | |
1501 | $ hg init bisect |
|
1501 | $ hg init bisect | |
1502 | $ cd bisect |
|
1502 | $ cd bisect | |
1503 | $ cat >> test-bisect.t <<EOF |
|
1503 | $ cat >> test-bisect.t <<EOF | |
1504 | > $ echo pass |
|
1504 | > $ echo pass | |
1505 | > pass |
|
1505 | > pass | |
1506 | > EOF |
|
1506 | > EOF | |
1507 | $ hg add test-bisect.t |
|
1507 | $ hg add test-bisect.t | |
1508 | $ hg ci -m 'good' |
|
1508 | $ hg ci -m 'good' | |
1509 | $ cat >> test-bisect.t <<EOF |
|
1509 | $ cat >> test-bisect.t <<EOF | |
1510 | > $ echo pass |
|
1510 | > $ echo pass | |
1511 | > fail |
|
1511 | > fail | |
1512 | > EOF |
|
1512 | > EOF | |
1513 | $ hg ci -m 'bad' |
|
1513 | $ hg ci -m 'bad' | |
1514 | $ rt --known-good-rev=0 test-bisect.t |
|
1514 | $ rt --known-good-rev=0 test-bisect.t | |
1515 | running 1 tests using 1 parallel processes |
|
1515 | running 1 tests using 1 parallel processes | |
1516 |
|
1516 | |||
1517 | --- $TESTTMP/anothertests/bisect/test-bisect.t |
|
1517 | --- $TESTTMP/anothertests/bisect/test-bisect.t | |
1518 | +++ $TESTTMP/anothertests/bisect/test-bisect.t.err |
|
1518 | +++ $TESTTMP/anothertests/bisect/test-bisect.t.err | |
1519 | @@ -1,4 +1,4 @@ |
|
1519 | @@ -1,4 +1,4 @@ | |
1520 | $ echo pass |
|
1520 | $ echo pass | |
1521 | pass |
|
1521 | pass | |
1522 | $ echo pass |
|
1522 | $ echo pass | |
1523 | - fail |
|
1523 | - fail | |
1524 | + pass |
|
1524 | + pass | |
1525 |
|
1525 | |||
1526 | ERROR: test-bisect.t output changed |
|
1526 | ERROR: test-bisect.t output changed | |
1527 | ! |
|
1527 | ! | |
1528 | Failed test-bisect.t: output changed |
|
1528 | Failed test-bisect.t: output changed | |
1529 | test-bisect.t broken by 72cbf122d116 (bad) |
|
1529 | test-bisect.t broken by 72cbf122d116 (bad) | |
1530 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1530 | # Ran 1 tests, 0 skipped, 1 failed. | |
1531 | python hash seed: * (glob) |
|
1531 | python hash seed: * (glob) | |
1532 | [1] |
|
1532 | [1] | |
1533 |
|
1533 | |||
1534 | $ cd .. |
|
1534 | $ cd .. | |
1535 |
|
1535 | |||
1536 | support bisecting a separate repo |
|
1536 | support bisecting a separate repo | |
1537 |
|
1537 | |||
1538 | $ hg init bisect-dependent |
|
1538 | $ hg init bisect-dependent | |
1539 | $ cd bisect-dependent |
|
1539 | $ cd bisect-dependent | |
1540 | $ cat > test-bisect-dependent.t <<EOF |
|
1540 | $ cat > test-bisect-dependent.t <<EOF | |
1541 | > $ tail -1 \$TESTDIR/../bisect/test-bisect.t |
|
1541 | > $ tail -1 \$TESTDIR/../bisect/test-bisect.t | |
1542 | > pass |
|
1542 | > pass | |
1543 | > EOF |
|
1543 | > EOF | |
1544 | $ hg commit -Am dependent test-bisect-dependent.t |
|
1544 | $ hg commit -Am dependent test-bisect-dependent.t | |
1545 |
|
1545 | |||
1546 | $ rt --known-good-rev=0 test-bisect-dependent.t |
|
1546 | $ rt --known-good-rev=0 test-bisect-dependent.t | |
1547 | running 1 tests using 1 parallel processes |
|
1547 | running 1 tests using 1 parallel processes | |
1548 |
|
1548 | |||
1549 | --- $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t |
|
1549 | --- $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t | |
1550 | +++ $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t.err |
|
1550 | +++ $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t.err | |
1551 | @@ -1,2 +1,2 @@ |
|
1551 | @@ -1,2 +1,2 @@ | |
1552 | $ tail -1 $TESTDIR/../bisect/test-bisect.t |
|
1552 | $ tail -1 $TESTDIR/../bisect/test-bisect.t | |
1553 | - pass |
|
1553 | - pass | |
1554 | + fail |
|
1554 | + fail | |
1555 |
|
1555 | |||
1556 | ERROR: test-bisect-dependent.t output changed |
|
1556 | ERROR: test-bisect-dependent.t output changed | |
1557 | ! |
|
1557 | ! | |
1558 | Failed test-bisect-dependent.t: output changed |
|
1558 | Failed test-bisect-dependent.t: output changed | |
1559 | Failed to identify failure point for test-bisect-dependent.t |
|
1559 | Failed to identify failure point for test-bisect-dependent.t | |
1560 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1560 | # Ran 1 tests, 0 skipped, 1 failed. | |
1561 | python hash seed: * (glob) |
|
1561 | python hash seed: * (glob) | |
1562 | [1] |
|
1562 | [1] | |
1563 |
|
1563 | |||
1564 | $ rt --bisect-repo=../test-bisect test-bisect-dependent.t |
|
1564 | $ rt --bisect-repo=../test-bisect test-bisect-dependent.t | |
1565 | usage: run-tests.py [options] [tests] |
|
1565 | usage: run-tests.py [options] [tests] | |
1566 | run-tests.py: error: --bisect-repo cannot be used without --known-good-rev |
|
1566 | run-tests.py: error: --bisect-repo cannot be used without --known-good-rev | |
1567 | [2] |
|
1567 | [2] | |
1568 |
|
1568 | |||
1569 | $ rt --known-good-rev=0 --bisect-repo=../bisect test-bisect-dependent.t |
|
1569 | $ rt --known-good-rev=0 --bisect-repo=../bisect test-bisect-dependent.t | |
1570 | running 1 tests using 1 parallel processes |
|
1570 | running 1 tests using 1 parallel processes | |
1571 |
|
1571 | |||
1572 | --- $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t |
|
1572 | --- $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t | |
1573 | +++ $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t.err |
|
1573 | +++ $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t.err | |
1574 | @@ -1,2 +1,2 @@ |
|
1574 | @@ -1,2 +1,2 @@ | |
1575 | $ tail -1 $TESTDIR/../bisect/test-bisect.t |
|
1575 | $ tail -1 $TESTDIR/../bisect/test-bisect.t | |
1576 | - pass |
|
1576 | - pass | |
1577 | + fail |
|
1577 | + fail | |
1578 |
|
1578 | |||
1579 | ERROR: test-bisect-dependent.t output changed |
|
1579 | ERROR: test-bisect-dependent.t output changed | |
1580 | ! |
|
1580 | ! | |
1581 | Failed test-bisect-dependent.t: output changed |
|
1581 | Failed test-bisect-dependent.t: output changed | |
1582 | test-bisect-dependent.t broken by 72cbf122d116 (bad) |
|
1582 | test-bisect-dependent.t broken by 72cbf122d116 (bad) | |
1583 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1583 | # Ran 1 tests, 0 skipped, 1 failed. | |
1584 | python hash seed: * (glob) |
|
1584 | python hash seed: * (glob) | |
1585 | [1] |
|
1585 | [1] | |
1586 |
|
1586 | |||
1587 | $ cd .. |
|
1587 | $ cd .. | |
1588 |
|
1588 | |||
1589 | Test a broken #if statement doesn't break run-tests threading. |
|
1589 | Test a broken #if statement doesn't break run-tests threading. | |
1590 | ============================================================== |
|
1590 | ============================================================== | |
1591 | $ mkdir broken |
|
1591 | $ mkdir broken | |
1592 | $ cd broken |
|
1592 | $ cd broken | |
1593 | $ cat > test-broken.t <<EOF |
|
1593 | $ cat > test-broken.t <<EOF | |
1594 | > true |
|
1594 | > true | |
1595 | > #if notarealhghavefeature |
|
1595 | > #if notarealhghavefeature | |
1596 | > $ false |
|
1596 | > $ false | |
1597 | > #endif |
|
1597 | > #endif | |
1598 | > EOF |
|
1598 | > EOF | |
1599 | $ for f in 1 2 3 4 ; do |
|
1599 | $ for f in 1 2 3 4 ; do | |
1600 | > cat > test-works-$f.t <<EOF |
|
1600 | > cat > test-works-$f.t <<EOF | |
1601 | > This is test case $f |
|
1601 | > This is test case $f | |
1602 | > $ sleep 1 |
|
1602 | > $ sleep 1 | |
1603 | > EOF |
|
1603 | > EOF | |
1604 | > done |
|
1604 | > done | |
1605 | $ rt -j 2 |
|
1605 | $ rt -j 2 | |
1606 | running 5 tests using 2 parallel processes |
|
1606 | running 5 tests using 2 parallel processes | |
1607 | .... |
|
1607 | .... | |
1608 | # Ran 5 tests, 0 skipped, 0 failed. |
|
1608 | # Ran 5 tests, 0 skipped, 0 failed. | |
1609 | skipped: unknown feature: notarealhghavefeature |
|
1609 | skipped: unknown feature: notarealhghavefeature | |
1610 |
|
1610 | |||
1611 | $ cd .. |
|
1611 | $ cd .. | |
1612 | $ rm -rf broken |
|
1612 | $ rm -rf broken | |
1613 |
|
1613 | |||
1614 | Test cases in .t files |
|
1614 | Test cases in .t files | |
1615 | ====================== |
|
1615 | ====================== | |
1616 | $ mkdir cases |
|
1616 | $ mkdir cases | |
1617 | $ cd cases |
|
1617 | $ cd cases | |
1618 | $ cat > test-cases-abc.t <<'EOF' |
|
1618 | $ cat > test-cases-abc.t <<'EOF' | |
1619 | > #testcases A B C |
|
1619 | > #testcases A B C | |
1620 | > $ V=B |
|
1620 | > $ V=B | |
1621 | > #if A |
|
1621 | > #if A | |
1622 | > $ V=A |
|
1622 | > $ V=A | |
1623 | > #endif |
|
1623 | > #endif | |
1624 | > #if C |
|
1624 | > #if C | |
1625 | > $ V=C |
|
1625 | > $ V=C | |
1626 | > #endif |
|
1626 | > #endif | |
1627 | > $ echo $V | sed 's/A/C/' |
|
1627 | > $ echo $V | sed 's/A/C/' | |
1628 | > C |
|
1628 | > C | |
1629 | > #if C |
|
1629 | > #if C | |
1630 | > $ [ $V = C ] |
|
1630 | > $ [ $V = C ] | |
1631 | > #endif |
|
1631 | > #endif | |
1632 | > #if A |
|
1632 | > #if A | |
1633 | > $ [ $V = C ] |
|
1633 | > $ [ $V = C ] | |
1634 | > [1] |
|
1634 | > [1] | |
1635 | > #endif |
|
1635 | > #endif | |
1636 | > #if no-C |
|
1636 | > #if no-C | |
1637 | > $ [ $V = C ] |
|
1637 | > $ [ $V = C ] | |
1638 | > [1] |
|
1638 | > [1] | |
1639 | > #endif |
|
1639 | > #endif | |
1640 | > $ [ $V = D ] |
|
1640 | > $ [ $V = D ] | |
1641 | > [1] |
|
1641 | > [1] | |
1642 | > EOF |
|
1642 | > EOF | |
1643 | $ rt |
|
1643 | $ rt | |
1644 | running 3 tests using 1 parallel processes |
|
1644 | running 3 tests using 1 parallel processes | |
1645 | . |
|
1645 | . | |
1646 | --- $TESTTMP/anothertests/cases/test-cases-abc.t |
|
1646 | --- $TESTTMP/anothertests/cases/test-cases-abc.t | |
1647 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err |
|
1647 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err | |
1648 | @@ -7,7 +7,7 @@ |
|
1648 | @@ -7,7 +7,7 @@ | |
1649 | $ V=C |
|
1649 | $ V=C | |
1650 | #endif |
|
1650 | #endif | |
1651 | $ echo $V | sed 's/A/C/' |
|
1651 | $ echo $V | sed 's/A/C/' | |
1652 | - C |
|
1652 | - C | |
1653 | + B |
|
1653 | + B | |
1654 | #if C |
|
1654 | #if C | |
1655 | $ [ $V = C ] |
|
1655 | $ [ $V = C ] | |
1656 | #endif |
|
1656 | #endif | |
1657 |
|
1657 | |||
1658 | ERROR: test-cases-abc.t#B output changed |
|
1658 | ERROR: test-cases-abc.t#B output changed | |
1659 | !. |
|
1659 | !. | |
1660 | Failed test-cases-abc.t#B: output changed |
|
1660 | Failed test-cases-abc.t#B: output changed | |
1661 | # Ran 3 tests, 0 skipped, 1 failed. |
|
1661 | # Ran 3 tests, 0 skipped, 1 failed. | |
1662 | python hash seed: * (glob) |
|
1662 | python hash seed: * (glob) | |
1663 | [1] |
|
1663 | [1] | |
1664 |
|
1664 | |||
1665 | --restart works |
|
1665 | --restart works | |
1666 |
|
1666 | |||
1667 | $ rt --restart |
|
1667 | $ rt --restart | |
1668 | running 2 tests using 1 parallel processes |
|
1668 | running 2 tests using 1 parallel processes | |
1669 |
|
1669 | |||
1670 | --- $TESTTMP/anothertests/cases/test-cases-abc.t |
|
1670 | --- $TESTTMP/anothertests/cases/test-cases-abc.t | |
1671 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err |
|
1671 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err | |
1672 | @@ -7,7 +7,7 @@ |
|
1672 | @@ -7,7 +7,7 @@ | |
1673 | $ V=C |
|
1673 | $ V=C | |
1674 | #endif |
|
1674 | #endif | |
1675 | $ echo $V | sed 's/A/C/' |
|
1675 | $ echo $V | sed 's/A/C/' | |
1676 | - C |
|
1676 | - C | |
1677 | + B |
|
1677 | + B | |
1678 | #if C |
|
1678 | #if C | |
1679 | $ [ $V = C ] |
|
1679 | $ [ $V = C ] | |
1680 | #endif |
|
1680 | #endif | |
1681 |
|
1681 | |||
1682 | ERROR: test-cases-abc.t#B output changed |
|
1682 | ERROR: test-cases-abc.t#B output changed | |
1683 | !. |
|
1683 | !. | |
1684 | Failed test-cases-abc.t#B: output changed |
|
1684 | Failed test-cases-abc.t#B: output changed | |
1685 | # Ran 2 tests, 0 skipped, 1 failed. |
|
1685 | # Ran 2 tests, 0 skipped, 1 failed. | |
1686 | python hash seed: * (glob) |
|
1686 | python hash seed: * (glob) | |
1687 | [1] |
|
1687 | [1] | |
1688 |
|
1688 | |||
1689 | --restart works with outputdir |
|
1689 | --restart works with outputdir | |
1690 |
|
1690 | |||
1691 | $ mkdir output |
|
1691 | $ mkdir output | |
1692 | $ mv test-cases-abc.t#B.err output |
|
1692 | $ mv test-cases-abc.t#B.err output | |
1693 | $ rt --restart --outputdir output |
|
1693 | $ rt --restart --outputdir output | |
1694 | running 2 tests using 1 parallel processes |
|
1694 | running 2 tests using 1 parallel processes | |
1695 |
|
1695 | |||
1696 | --- $TESTTMP/anothertests/cases/test-cases-abc.t |
|
1696 | --- $TESTTMP/anothertests/cases/test-cases-abc.t | |
1697 | +++ $TESTTMP/anothertests/cases/output/test-cases-abc.t#B.err |
|
1697 | +++ $TESTTMP/anothertests/cases/output/test-cases-abc.t#B.err | |
1698 | @@ -7,7 +7,7 @@ |
|
1698 | @@ -7,7 +7,7 @@ | |
1699 | $ V=C |
|
1699 | $ V=C | |
1700 | #endif |
|
1700 | #endif | |
1701 | $ echo $V | sed 's/A/C/' |
|
1701 | $ echo $V | sed 's/A/C/' | |
1702 | - C |
|
1702 | - C | |
1703 | + B |
|
1703 | + B | |
1704 | #if C |
|
1704 | #if C | |
1705 | $ [ $V = C ] |
|
1705 | $ [ $V = C ] | |
1706 | #endif |
|
1706 | #endif | |
1707 |
|
1707 | |||
1708 | ERROR: test-cases-abc.t#B output changed |
|
1708 | ERROR: test-cases-abc.t#B output changed | |
1709 | !. |
|
1709 | !. | |
1710 | Failed test-cases-abc.t#B: output changed |
|
1710 | Failed test-cases-abc.t#B: output changed | |
1711 | # Ran 2 tests, 0 skipped, 1 failed. |
|
1711 | # Ran 2 tests, 0 skipped, 1 failed. | |
1712 | python hash seed: * (glob) |
|
1712 | python hash seed: * (glob) | |
1713 | [1] |
|
1713 | [1] | |
1714 |
|
1714 | |||
1715 | Test TESTCASE variable |
|
1715 | Test TESTCASE variable | |
1716 |
|
1716 | |||
1717 | $ cat > test-cases-ab.t <<'EOF' |
|
1717 | $ cat > test-cases-ab.t <<'EOF' | |
1718 | > $ dostuff() { |
|
1718 | > $ dostuff() { | |
1719 | > > echo "In case $TESTCASE" |
|
1719 | > > echo "In case $TESTCASE" | |
1720 | > > } |
|
1720 | > > } | |
1721 | > #testcases A B |
|
1721 | > #testcases A B | |
1722 | > #if A |
|
1722 | > #if A | |
1723 | > $ dostuff |
|
1723 | > $ dostuff | |
1724 | > In case A |
|
1724 | > In case A | |
1725 | > #endif |
|
1725 | > #endif | |
1726 | > #if B |
|
1726 | > #if B | |
1727 | > $ dostuff |
|
1727 | > $ dostuff | |
1728 | > In case B |
|
1728 | > In case B | |
1729 | > #endif |
|
1729 | > #endif | |
1730 | > EOF |
|
1730 | > EOF | |
1731 | $ rt test-cases-ab.t |
|
1731 | $ rt test-cases-ab.t | |
1732 | running 2 tests using 1 parallel processes |
|
1732 | running 2 tests using 1 parallel processes | |
1733 | .. |
|
1733 | .. | |
1734 | # Ran 2 tests, 0 skipped, 0 failed. |
|
1734 | # Ran 2 tests, 0 skipped, 0 failed. | |
1735 |
|
1735 | |||
1736 | Support running a specific test case |
|
1736 | Support running a specific test case | |
1737 |
|
1737 | |||
1738 | $ rt "test-cases-abc.t#B" |
|
1738 | $ rt "test-cases-abc.t#B" | |
1739 | running 1 tests using 1 parallel processes |
|
1739 | running 1 tests using 1 parallel processes | |
1740 |
|
1740 | |||
1741 | --- $TESTTMP/anothertests/cases/test-cases-abc.t |
|
1741 | --- $TESTTMP/anothertests/cases/test-cases-abc.t | |
1742 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err |
|
1742 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err | |
1743 | @@ -7,7 +7,7 @@ |
|
1743 | @@ -7,7 +7,7 @@ | |
1744 | $ V=C |
|
1744 | $ V=C | |
1745 | #endif |
|
1745 | #endif | |
1746 | $ echo $V | sed 's/A/C/' |
|
1746 | $ echo $V | sed 's/A/C/' | |
1747 | - C |
|
1747 | - C | |
1748 | + B |
|
1748 | + B | |
1749 | #if C |
|
1749 | #if C | |
1750 | $ [ $V = C ] |
|
1750 | $ [ $V = C ] | |
1751 | #endif |
|
1751 | #endif | |
1752 |
|
1752 | |||
1753 | ERROR: test-cases-abc.t#B output changed |
|
1753 | ERROR: test-cases-abc.t#B output changed | |
1754 | ! |
|
1754 | ! | |
1755 | Failed test-cases-abc.t#B: output changed |
|
1755 | Failed test-cases-abc.t#B: output changed | |
1756 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1756 | # Ran 1 tests, 0 skipped, 1 failed. | |
1757 | python hash seed: * (glob) |
|
1757 | python hash seed: * (glob) | |
1758 | [1] |
|
1758 | [1] | |
1759 |
|
1759 | |||
1760 | Support running multiple test cases in the same file |
|
1760 | Support running multiple test cases in the same file | |
1761 |
|
1761 | |||
1762 | $ rt test-cases-abc.t#B test-cases-abc.t#C |
|
1762 | $ rt test-cases-abc.t#B test-cases-abc.t#C | |
1763 | running 2 tests using 1 parallel processes |
|
1763 | running 2 tests using 1 parallel processes | |
1764 |
|
1764 | |||
1765 | --- $TESTTMP/anothertests/cases/test-cases-abc.t |
|
1765 | --- $TESTTMP/anothertests/cases/test-cases-abc.t | |
1766 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err |
|
1766 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err | |
1767 | @@ -7,7 +7,7 @@ |
|
1767 | @@ -7,7 +7,7 @@ | |
1768 | $ V=C |
|
1768 | $ V=C | |
1769 | #endif |
|
1769 | #endif | |
1770 | $ echo $V | sed 's/A/C/' |
|
1770 | $ echo $V | sed 's/A/C/' | |
1771 | - C |
|
1771 | - C | |
1772 | + B |
|
1772 | + B | |
1773 | #if C |
|
1773 | #if C | |
1774 | $ [ $V = C ] |
|
1774 | $ [ $V = C ] | |
1775 | #endif |
|
1775 | #endif | |
1776 |
|
1776 | |||
1777 | ERROR: test-cases-abc.t#B output changed |
|
1777 | ERROR: test-cases-abc.t#B output changed | |
1778 | !. |
|
1778 | !. | |
1779 | Failed test-cases-abc.t#B: output changed |
|
1779 | Failed test-cases-abc.t#B: output changed | |
1780 | # Ran 2 tests, 0 skipped, 1 failed. |
|
1780 | # Ran 2 tests, 0 skipped, 1 failed. | |
1781 | python hash seed: * (glob) |
|
1781 | python hash seed: * (glob) | |
1782 | [1] |
|
1782 | [1] | |
1783 |
|
1783 | |||
1784 | Support ignoring invalid test cases |
|
1784 | Support ignoring invalid test cases | |
1785 |
|
1785 | |||
1786 | $ rt test-cases-abc.t#B test-cases-abc.t#D |
|
1786 | $ rt test-cases-abc.t#B test-cases-abc.t#D | |
1787 | running 1 tests using 1 parallel processes |
|
1787 | running 1 tests using 1 parallel processes | |
1788 |
|
1788 | |||
1789 | --- $TESTTMP/anothertests/cases/test-cases-abc.t |
|
1789 | --- $TESTTMP/anothertests/cases/test-cases-abc.t | |
1790 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err |
|
1790 | +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err | |
1791 | @@ -7,7 +7,7 @@ |
|
1791 | @@ -7,7 +7,7 @@ | |
1792 | $ V=C |
|
1792 | $ V=C | |
1793 | #endif |
|
1793 | #endif | |
1794 | $ echo $V | sed 's/A/C/' |
|
1794 | $ echo $V | sed 's/A/C/' | |
1795 | - C |
|
1795 | - C | |
1796 | + B |
|
1796 | + B | |
1797 | #if C |
|
1797 | #if C | |
1798 | $ [ $V = C ] |
|
1798 | $ [ $V = C ] | |
1799 | #endif |
|
1799 | #endif | |
1800 |
|
1800 | |||
1801 | ERROR: test-cases-abc.t#B output changed |
|
1801 | ERROR: test-cases-abc.t#B output changed | |
1802 | ! |
|
1802 | ! | |
1803 | Failed test-cases-abc.t#B: output changed |
|
1803 | Failed test-cases-abc.t#B: output changed | |
1804 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1804 | # Ran 1 tests, 0 skipped, 1 failed. | |
1805 | python hash seed: * (glob) |
|
1805 | python hash seed: * (glob) | |
1806 | [1] |
|
1806 | [1] | |
1807 |
|
1807 | |||
1808 | Support running complex test cases names |
|
1808 | Support running complex test cases names | |
1809 |
|
1809 | |||
1810 | $ cat > test-cases-advanced-cases.t <<'EOF' |
|
1810 | $ cat > test-cases-advanced-cases.t <<'EOF' | |
1811 | > #testcases simple case-with-dashes casewith_-.chars |
|
1811 | > #testcases simple case-with-dashes casewith_-.chars | |
1812 | > $ echo $TESTCASE |
|
1812 | > $ echo $TESTCASE | |
1813 | > simple |
|
1813 | > simple | |
1814 | > EOF |
|
1814 | > EOF | |
1815 |
|
1815 | |||
1816 | $ cat test-cases-advanced-cases.t |
|
1816 | $ cat test-cases-advanced-cases.t | |
1817 | #testcases simple case-with-dashes casewith_-.chars |
|
1817 | #testcases simple case-with-dashes casewith_-.chars | |
1818 | $ echo $TESTCASE |
|
1818 | $ echo $TESTCASE | |
1819 | simple |
|
1819 | simple | |
1820 |
|
1820 | |||
1821 | $ rt test-cases-advanced-cases.t |
|
1821 | $ rt test-cases-advanced-cases.t | |
1822 | running 3 tests using 1 parallel processes |
|
1822 | running 3 tests using 1 parallel processes | |
1823 |
|
1823 | |||
1824 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t |
|
1824 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t | |
1825 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#case-with-dashes.err |
|
1825 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#case-with-dashes.err | |
1826 | @@ -1,3 +1,3 @@ |
|
1826 | @@ -1,3 +1,3 @@ | |
1827 | #testcases simple case-with-dashes casewith_-.chars |
|
1827 | #testcases simple case-with-dashes casewith_-.chars | |
1828 | $ echo $TESTCASE |
|
1828 | $ echo $TESTCASE | |
1829 | - simple |
|
1829 | - simple | |
1830 | + case-with-dashes |
|
1830 | + case-with-dashes | |
1831 |
|
1831 | |||
1832 | ERROR: test-cases-advanced-cases.t#case-with-dashes output changed |
|
1832 | ERROR: test-cases-advanced-cases.t#case-with-dashes output changed | |
1833 | ! |
|
1833 | ! | |
1834 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t |
|
1834 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t | |
1835 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#casewith_-.chars.err |
|
1835 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#casewith_-.chars.err | |
1836 | @@ -1,3 +1,3 @@ |
|
1836 | @@ -1,3 +1,3 @@ | |
1837 | #testcases simple case-with-dashes casewith_-.chars |
|
1837 | #testcases simple case-with-dashes casewith_-.chars | |
1838 | $ echo $TESTCASE |
|
1838 | $ echo $TESTCASE | |
1839 | - simple |
|
1839 | - simple | |
1840 | + casewith_-.chars |
|
1840 | + casewith_-.chars | |
1841 |
|
1841 | |||
1842 | ERROR: test-cases-advanced-cases.t#casewith_-.chars output changed |
|
1842 | ERROR: test-cases-advanced-cases.t#casewith_-.chars output changed | |
1843 | !. |
|
1843 | !. | |
1844 | Failed test-cases-advanced-cases.t#case-with-dashes: output changed |
|
1844 | Failed test-cases-advanced-cases.t#case-with-dashes: output changed | |
1845 | Failed test-cases-advanced-cases.t#casewith_-.chars: output changed |
|
1845 | Failed test-cases-advanced-cases.t#casewith_-.chars: output changed | |
1846 | # Ran 3 tests, 0 skipped, 2 failed. |
|
1846 | # Ran 3 tests, 0 skipped, 2 failed. | |
1847 | python hash seed: * (glob) |
|
1847 | python hash seed: * (glob) | |
1848 | [1] |
|
1848 | [1] | |
1849 |
|
1849 | |||
1850 | $ rt "test-cases-advanced-cases.t#case-with-dashes" |
|
1850 | $ rt "test-cases-advanced-cases.t#case-with-dashes" | |
1851 | running 1 tests using 1 parallel processes |
|
1851 | running 1 tests using 1 parallel processes | |
1852 |
|
1852 | |||
1853 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t |
|
1853 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t | |
1854 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#case-with-dashes.err |
|
1854 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#case-with-dashes.err | |
1855 | @@ -1,3 +1,3 @@ |
|
1855 | @@ -1,3 +1,3 @@ | |
1856 | #testcases simple case-with-dashes casewith_-.chars |
|
1856 | #testcases simple case-with-dashes casewith_-.chars | |
1857 | $ echo $TESTCASE |
|
1857 | $ echo $TESTCASE | |
1858 | - simple |
|
1858 | - simple | |
1859 | + case-with-dashes |
|
1859 | + case-with-dashes | |
1860 |
|
1860 | |||
1861 | ERROR: test-cases-advanced-cases.t#case-with-dashes output changed |
|
1861 | ERROR: test-cases-advanced-cases.t#case-with-dashes output changed | |
1862 | ! |
|
1862 | ! | |
1863 | Failed test-cases-advanced-cases.t#case-with-dashes: output changed |
|
1863 | Failed test-cases-advanced-cases.t#case-with-dashes: output changed | |
1864 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1864 | # Ran 1 tests, 0 skipped, 1 failed. | |
1865 | python hash seed: * (glob) |
|
1865 | python hash seed: * (glob) | |
1866 | [1] |
|
1866 | [1] | |
1867 |
|
1867 | |||
1868 | $ rt "test-cases-advanced-cases.t#casewith_-.chars" |
|
1868 | $ rt "test-cases-advanced-cases.t#casewith_-.chars" | |
1869 | running 1 tests using 1 parallel processes |
|
1869 | running 1 tests using 1 parallel processes | |
1870 |
|
1870 | |||
1871 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t |
|
1871 | --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t | |
1872 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#casewith_-.chars.err |
|
1872 | +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#casewith_-.chars.err | |
1873 | @@ -1,3 +1,3 @@ |
|
1873 | @@ -1,3 +1,3 @@ | |
1874 | #testcases simple case-with-dashes casewith_-.chars |
|
1874 | #testcases simple case-with-dashes casewith_-.chars | |
1875 | $ echo $TESTCASE |
|
1875 | $ echo $TESTCASE | |
1876 | - simple |
|
1876 | - simple | |
1877 | + casewith_-.chars |
|
1877 | + casewith_-.chars | |
1878 |
|
1878 | |||
1879 | ERROR: test-cases-advanced-cases.t#casewith_-.chars output changed |
|
1879 | ERROR: test-cases-advanced-cases.t#casewith_-.chars output changed | |
1880 | ! |
|
1880 | ! | |
1881 | Failed test-cases-advanced-cases.t#casewith_-.chars: output changed |
|
1881 | Failed test-cases-advanced-cases.t#casewith_-.chars: output changed | |
1882 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1882 | # Ran 1 tests, 0 skipped, 1 failed. | |
1883 | python hash seed: * (glob) |
|
1883 | python hash seed: * (glob) | |
1884 | [1] |
|
1884 | [1] | |
1885 |
|
1885 | |||
1886 | Test automatic pattern replacement |
|
1886 | Test automatic pattern replacement | |
1887 | ================================== |
|
1887 | ================================== | |
1888 |
|
1888 | |||
1889 | $ cat << EOF >> common-pattern.py |
|
1889 | $ cat << EOF >> common-pattern.py | |
1890 | > substitutions = [ |
|
1890 | > substitutions = [ | |
1891 | > (br'foo-(.*)\\b', |
|
1891 | > (br'foo-(.*)\\b', | |
1892 | > br'\$XXX=\\1\$'), |
|
1892 | > br'\$XXX=\\1\$'), | |
1893 | > (br'bar\\n', |
|
1893 | > (br'bar\\n', | |
1894 | > br'\$YYY$\\n'), |
|
1894 | > br'\$YYY$\\n'), | |
1895 | > ] |
|
1895 | > ] | |
1896 | > EOF |
|
1896 | > EOF | |
1897 |
|
1897 | |||
1898 | $ cat << EOF >> test-substitution.t |
|
1898 | $ cat << EOF >> test-substitution.t | |
1899 | > $ echo foo-12 |
|
1899 | > $ echo foo-12 | |
1900 | > \$XXX=12$ |
|
1900 | > \$XXX=12$ | |
1901 | > $ echo foo-42 |
|
1901 | > $ echo foo-42 | |
1902 | > \$XXX=42$ |
|
1902 | > \$XXX=42$ | |
1903 | > $ echo bar prior |
|
1903 | > $ echo bar prior | |
1904 | > bar prior |
|
1904 | > bar prior | |
1905 | > $ echo lastbar |
|
1905 | > $ echo lastbar | |
1906 | > last\$YYY$ |
|
1906 | > last\$YYY$ | |
1907 | > $ echo foo-bar foo-baz |
|
1907 | > $ echo foo-bar foo-baz | |
1908 | > EOF |
|
1908 | > EOF | |
1909 |
|
1909 | |||
1910 | $ rt test-substitution.t |
|
1910 | $ rt test-substitution.t | |
1911 | running 1 tests using 1 parallel processes |
|
1911 | running 1 tests using 1 parallel processes | |
1912 |
|
1912 | |||
1913 | --- $TESTTMP/anothertests/cases/test-substitution.t |
|
1913 | --- $TESTTMP/anothertests/cases/test-substitution.t | |
1914 | +++ $TESTTMP/anothertests/cases/test-substitution.t.err |
|
1914 | +++ $TESTTMP/anothertests/cases/test-substitution.t.err | |
1915 | @@ -7,3 +7,4 @@ |
|
1915 | @@ -7,3 +7,4 @@ | |
1916 | $ echo lastbar |
|
1916 | $ echo lastbar | |
1917 | last$YYY$ |
|
1917 | last$YYY$ | |
1918 | $ echo foo-bar foo-baz |
|
1918 | $ echo foo-bar foo-baz | |
1919 | + $XXX=bar foo-baz$ |
|
1919 | + $XXX=bar foo-baz$ | |
1920 |
|
1920 | |||
1921 | ERROR: test-substitution.t output changed |
|
1921 | ERROR: test-substitution.t output changed | |
1922 | ! |
|
1922 | ! | |
1923 | Failed test-substitution.t: output changed |
|
1923 | Failed test-substitution.t: output changed | |
1924 | # Ran 1 tests, 0 skipped, 1 failed. |
|
1924 | # Ran 1 tests, 0 skipped, 1 failed. | |
1925 | python hash seed: * (glob) |
|
1925 | python hash seed: * (glob) | |
1926 | [1] |
|
1926 | [1] | |
1927 |
|
1927 | |||
1928 | --extra-config-opt works |
|
1928 | --extra-config-opt works | |
1929 |
|
1929 | |||
1930 | $ cat << EOF >> test-config-opt.t |
|
1930 | $ cat << EOF >> test-config-opt.t | |
1931 | > $ hg init test-config-opt |
|
1931 | > $ hg init test-config-opt | |
1932 | > $ hg -R test-config-opt purge |
|
1932 | > $ hg -R test-config-opt purge | |
1933 | > EOF |
|
1933 | > EOF | |
1934 |
|
1934 | |||
1935 | $ rt --extra-config-opt extensions.purge= test-config-opt.t |
|
1935 | $ rt --extra-config-opt extensions.purge= test-config-opt.t | |
1936 | running 1 tests using 1 parallel processes |
|
1936 | running 1 tests using 1 parallel processes | |
1937 | . |
|
1937 | . | |
1938 | # Ran 1 tests, 0 skipped, 0 failed. |
|
1938 | # Ran 1 tests, 0 skipped, 0 failed. | |
|
1939 | ||||
|
1940 | Test conditional output matching | |||
|
1941 | ================================ | |||
|
1942 | ||||
|
1943 | $ cat << EOF >> test-conditional-matching.t | |||
|
1944 | > #testcases foo bar | |||
|
1945 | > $ echo richtig | |||
|
1946 | > richtig (true !) | |||
|
1947 | > $ echo falsch | |||
|
1948 | > falsch (false !) | |||
|
1949 | > #if foo | |||
|
1950 | > $ echo arthur | |||
|
1951 | > arthur (bar !) | |||
|
1952 | > #endif | |||
|
1953 | > $ echo celeste | |||
|
1954 | > celeste (foo !) | |||
|
1955 | > $ echo zephir | |||
|
1956 | > zephir (bar !) | |||
|
1957 | > EOF | |||
|
1958 | ||||
|
1959 | $ rt test-conditional-matching.t | |||
|
1960 | running 2 tests using 1 parallel processes | |||
|
1961 | ||||
|
1962 | --- $TESTTMP/anothertests/cases/test-conditional-matching.t | |||
|
1963 | +++ $TESTTMP/anothertests/cases/test-conditional-matching.t#bar.err | |||
|
1964 | @@ -3,11 +3,13 @@ | |||
|
1965 | richtig (true !) | |||
|
1966 | $ echo falsch | |||
|
1967 | falsch (false !) | |||
|
1968 | + falsch | |||
|
1969 | #if foo | |||
|
1970 | $ echo arthur | |||
|
1971 | arthur \(bar !\) (re) | |||
|
1972 | #endif | |||
|
1973 | $ echo celeste | |||
|
1974 | celeste \(foo !\) (re) | |||
|
1975 | + celeste | |||
|
1976 | $ echo zephir | |||
|
1977 | zephir \(bar !\) (re) | |||
|
1978 | ||||
|
1979 | ERROR: test-conditional-matching.t#bar output changed | |||
|
1980 | ! | |||
|
1981 | --- $TESTTMP/anothertests/cases/test-conditional-matching.t | |||
|
1982 | +++ $TESTTMP/anothertests/cases/test-conditional-matching.t#foo.err | |||
|
1983 | @@ -3,11 +3,14 @@ | |||
|
1984 | richtig (true !) | |||
|
1985 | $ echo falsch | |||
|
1986 | falsch (false !) | |||
|
1987 | + falsch | |||
|
1988 | #if foo | |||
|
1989 | $ echo arthur | |||
|
1990 | arthur \(bar !\) (re) | |||
|
1991 | + arthur | |||
|
1992 | #endif | |||
|
1993 | $ echo celeste | |||
|
1994 | celeste \(foo !\) (re) | |||
|
1995 | $ echo zephir | |||
|
1996 | zephir \(bar !\) (re) | |||
|
1997 | + zephir | |||
|
1998 | ||||
|
1999 | ERROR: test-conditional-matching.t#foo output changed | |||
|
2000 | ! | |||
|
2001 | Failed test-conditional-matching.t#bar: output changed | |||
|
2002 | Failed test-conditional-matching.t#foo: output changed | |||
|
2003 | # Ran 2 tests, 0 skipped, 2 failed. | |||
|
2004 | python hash seed: * (glob) | |||
|
2005 | [1] |
General Comments 0
You need to be logged in to leave comments.
Login now