##// END OF EJS Templates
tests: add a --retest test to demonstrate a fix in next patch...
Sushil khanchi -
r45966:fa1a5527 default
parent child Browse files
Show More
@@ -1,2012 +1,2031
1 1 This file tests the behavior of run-tests.py itself.
2 2
3 3 Avoid interference from actual test env:
4 4
5 5 $ . "$TESTDIR/helper-runtests.sh"
6 6
7 7 Smoke test with install
8 8 ============
9 9 $ "$PYTHON" $TESTDIR/run-tests.py $HGTEST_RUN_TESTS_PURE -l
10 10 running 0 tests using 0 parallel processes
11 11
12 12 # Ran 0 tests, 0 skipped, 0 failed.
13 13
14 14 Define a helper to avoid the install step
15 15 =============
16 16 $ rt()
17 17 > {
18 18 > "$PYTHON" $TESTDIR/run-tests.py --with-hg=`which hg` -j1 "$@"
19 19 > }
20 20
21 21 error paths
22 22
23 23 #if symlink
24 24 $ ln -s `which true` hg
25 25 $ "$PYTHON" $TESTDIR/run-tests.py --with-hg=./hg
26 26 warning: --with-hg should specify an hg script
27 27 running 0 tests using 0 parallel processes
28 28
29 29 # Ran 0 tests, 0 skipped, 0 failed.
30 30 $ rm hg
31 31 #endif
32 32
33 33 #if execbit
34 34 $ touch hg
35 35 $ "$PYTHON" $TESTDIR/run-tests.py --with-hg=./hg
36 36 usage: run-tests.py [options] [tests]
37 37 run-tests.py: error: --with-hg must specify an executable hg script
38 38 [2]
39 39 $ rm hg
40 40 #endif
41 41
42 42 Features for testing optional lines
43 43 ===================================
44 44
45 45 $ cat > hghaveaddon.py <<EOF
46 46 > import hghave
47 47 > @hghave.check("custom", "custom hghave feature")
48 48 > def has_custom():
49 49 > return True
50 50 > @hghave.check("missing", "missing hghave feature")
51 51 > def has_missing():
52 52 > return False
53 53 > EOF
54 54
55 55 an empty test
56 56 =======================
57 57
58 58 $ touch test-empty.t
59 59 $ rt
60 60 running 1 tests using 1 parallel processes
61 61 .
62 62 # Ran 1 tests, 0 skipped, 0 failed.
63 63 $ rm test-empty.t
64 64
65 65 a succesful test
66 66 =======================
67 67
68 68 $ cat > test-success.t << EOF
69 69 > $ echo babar
70 70 > babar
71 71 > $ echo xyzzy
72 72 > dont_print (?)
73 73 > nothing[42]line (re) (?)
74 74 > never*happens (glob) (?)
75 75 > more_nothing (?)
76 76 > xyzzy
77 77 > nor this (?)
78 78 > $ printf 'abc\ndef\nxyz\n'
79 79 > 123 (?)
80 80 > abc
81 81 > def (?)
82 82 > 456 (?)
83 83 > xyz
84 84 > $ printf 'zyx\nwvu\ntsr\n'
85 85 > abc (?)
86 86 > zyx (custom !)
87 87 > wvu
88 88 > no_print (no-custom !)
89 89 > tsr (no-missing !)
90 90 > missing (missing !)
91 91 > EOF
92 92
93 93 $ rt
94 94 running 1 tests using 1 parallel processes
95 95 .
96 96 # Ran 1 tests, 0 skipped, 0 failed.
97 97
98 98 failing test
99 99 ==================
100 100
101 101 test churn with globs
102 102 $ cat > test-failure.t <<EOF
103 103 > $ echo "bar-baz"; echo "bar-bad"; echo foo
104 104 > bar*bad (glob)
105 105 > bar*baz (glob)
106 106 > | fo (re)
107 107 > EOF
108 108 $ rt test-failure.t
109 109 running 1 tests using 1 parallel processes
110 110
111 111 --- $TESTTMP/test-failure.t
112 112 +++ $TESTTMP/test-failure.t.err
113 113 @@ -1,4 +1,4 @@
114 114 $ echo "bar-baz"; echo "bar-bad"; echo foo
115 115 + bar*baz (glob)
116 116 bar*bad (glob)
117 117 - bar*baz (glob)
118 118 - | fo (re)
119 119 + foo
120 120
121 121 ERROR: test-failure.t output changed
122 122 !
123 123 Failed test-failure.t: output changed
124 124 # Ran 1 tests, 0 skipped, 1 failed.
125 125 python hash seed: * (glob)
126 126 [1]
127 127
128 128 test how multiple globs gets matched with lines in output
129 129 $ cat > test-failure-globs.t <<EOF
130 130 > $ echo "context"; echo "context"; \
131 131 > echo "key: 1"; echo "value: not a"; \
132 132 > echo "key: 2"; echo "value: not b"; \
133 133 > echo "key: 3"; echo "value: c"; \
134 134 > echo "key: 4"; echo "value: d"
135 135 > context
136 136 > context
137 137 > key: 1
138 138 > value: a
139 139 > key: 2
140 140 > value: b
141 141 > key: 3
142 142 > value: * (glob)
143 143 > key: 4
144 144 > value: * (glob)
145 145 > EOF
146 146 $ rt test-failure-globs.t
147 147 running 1 tests using 1 parallel processes
148 148
149 149 --- $TESTTMP/test-failure-globs.t
150 150 +++ $TESTTMP/test-failure-globs.t.err
151 151 @@ -2,9 +2,9 @@
152 152 context
153 153 context
154 154 key: 1
155 155 - value: a
156 156 + value: not a
157 157 key: 2
158 158 - value: b
159 159 + value: not b
160 160 key: 3
161 161 value: * (glob)
162 162 key: 4
163 163
164 164 ERROR: test-failure-globs.t output changed
165 165 !
166 166 Failed test-failure-globs.t: output changed
167 167 # Ran 1 tests, 0 skipped, 1 failed.
168 168 python hash seed: * (glob)
169 169 [1]
170 170 $ rm test-failure-globs.t
171 171
172 172 test diff colorisation
173 173
174 174 #if no-windows pygments
175 175 $ rt test-failure.t --color always
176 176 running 1 tests using 1 parallel processes
177 177
178 178 \x1b[38;5;124m--- $TESTTMP/test-failure.t\x1b[39m (esc)
179 179 \x1b[38;5;34m+++ $TESTTMP/test-failure.t.err\x1b[39m (esc)
180 180 \x1b[38;5;90;01m@@ -1,4 +1,4 @@\x1b[39;00m (esc)
181 181 $ echo "bar-baz"; echo "bar-bad"; echo foo
182 182 \x1b[38;5;34m+ bar*baz (glob)\x1b[39m (esc)
183 183 bar*bad (glob)
184 184 \x1b[38;5;124m- bar*baz (glob)\x1b[39m (esc)
185 185 \x1b[38;5;124m- | fo (re)\x1b[39m (esc)
186 186 \x1b[38;5;34m+ foo\x1b[39m (esc)
187 187
188 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 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 191 # Ran 1 tests, 0 skipped, 1 failed.
192 192 python hash seed: * (glob)
193 193 [1]
194 194
195 195 $ rt test-failure.t 2> tmp.log
196 196 running 1 tests using 1 parallel processes
197 197 [1]
198 198 $ cat tmp.log
199 199
200 200 --- $TESTTMP/test-failure.t
201 201 +++ $TESTTMP/test-failure.t.err
202 202 @@ -1,4 +1,4 @@
203 203 $ echo "bar-baz"; echo "bar-bad"; echo foo
204 204 + bar*baz (glob)
205 205 bar*bad (glob)
206 206 - bar*baz (glob)
207 207 - | fo (re)
208 208 + foo
209 209
210 210 ERROR: test-failure.t output changed
211 211 !
212 212 Failed test-failure.t: output changed
213 213 # Ran 1 tests, 0 skipped, 1 failed.
214 214 python hash seed: * (glob)
215 215 #endif
216 216
217 217 $ cat > test-failure.t << EOF
218 218 > $ true
219 219 > should go away (true !)
220 220 > $ true
221 221 > should stay (false !)
222 222 >
223 223 > Should remove first line, not second or third
224 224 > $ echo 'testing'
225 225 > baz*foo (glob) (true !)
226 226 > foobar*foo (glob) (false !)
227 227 > te*ting (glob) (true !)
228 228 >
229 229 > Should keep first two lines, remove third and last
230 230 > $ echo 'testing'
231 231 > test.ng (re) (true !)
232 232 > foo.ar (re) (false !)
233 233 > b.r (re) (true !)
234 234 > missing (?)
235 235 > awol (true !)
236 236 >
237 237 > The "missing" line should stay, even though awol is dropped
238 238 > $ echo 'testing'
239 239 > test.ng (re) (true !)
240 240 > foo.ar (?)
241 241 > awol
242 242 > missing (?)
243 243 > EOF
244 244 $ rt test-failure.t
245 245 running 1 tests using 1 parallel processes
246 246
247 247 --- $TESTTMP/test-failure.t
248 248 +++ $TESTTMP/test-failure.t.err
249 249 @@ -1,11 +1,9 @@
250 250 $ true
251 251 - should go away (true !)
252 252 $ true
253 253 should stay (false !)
254 254
255 255 Should remove first line, not second or third
256 256 $ echo 'testing'
257 257 - baz*foo (glob) (true !)
258 258 foobar*foo (glob) (false !)
259 259 te*ting (glob) (true !)
260 260
261 261 foo.ar (re) (false !)
262 262 missing (?)
263 263 @@ -13,13 +11,10 @@
264 264 $ echo 'testing'
265 265 test.ng (re) (true !)
266 266 foo.ar (re) (false !)
267 267 - b.r (re) (true !)
268 268 missing (?)
269 269 - awol (true !)
270 270
271 271 The "missing" line should stay, even though awol is dropped
272 272 $ echo 'testing'
273 273 test.ng (re) (true !)
274 274 foo.ar (?)
275 275 - awol
276 276 missing (?)
277 277
278 278 ERROR: test-failure.t output changed
279 279 !
280 280 Failed test-failure.t: output changed
281 281 # Ran 1 tests, 0 skipped, 1 failed.
282 282 python hash seed: * (glob)
283 283 [1]
284 284
285 285 basic failing test
286 286 $ cat > test-failure.t << EOF
287 287 > $ echo babar
288 288 > rataxes
289 289 > This is a noop statement so that
290 290 > this test is still more bytes than success.
291 291 > pad pad pad pad............................................................
292 292 > pad pad pad pad............................................................
293 293 > pad pad pad pad............................................................
294 294 > pad pad pad pad............................................................
295 295 > pad pad pad pad............................................................
296 296 > pad pad pad pad............................................................
297 297 > EOF
298 298
299 299 >>> fh = open('test-failure-unicode.t', 'wb')
300 300 >>> fh.write(u' $ echo babar\u03b1\n'.encode('utf-8')) and None
301 301 >>> fh.write(u' l\u03b5\u03b5t\n'.encode('utf-8')) and None
302 302
303 303 $ rt
304 304 running 3 tests using 1 parallel processes
305 305
306 306 --- $TESTTMP/test-failure.t
307 307 +++ $TESTTMP/test-failure.t.err
308 308 @@ -1,5 +1,5 @@
309 309 $ echo babar
310 310 - rataxes
311 311 + babar
312 312 This is a noop statement so that
313 313 this test is still more bytes than success.
314 314 pad pad pad pad............................................................
315 315
316 316 ERROR: test-failure.t output changed
317 317 !.
318 318 --- $TESTTMP/test-failure-unicode.t
319 319 +++ $TESTTMP/test-failure-unicode.t.err
320 320 @@ -1,2 +1,2 @@
321 321 $ echo babar\xce\xb1 (esc)
322 322 - l\xce\xb5\xce\xb5t (esc)
323 323 + babar\xce\xb1 (esc)
324 324
325 325 ERROR: test-failure-unicode.t output changed
326 326 !
327 327 Failed test-failure-unicode.t: output changed
328 328 Failed test-failure.t: output changed
329 329 # Ran 3 tests, 0 skipped, 2 failed.
330 330 python hash seed: * (glob)
331 331 [1]
332 332
333 333 test --outputdir
334 334 $ mkdir output
335 335 $ rt --outputdir output
336 336 running 3 tests using 1 parallel processes
337 337
338 338 --- $TESTTMP/test-failure.t
339 339 +++ $TESTTMP/output/test-failure.t.err
340 340 @@ -1,5 +1,5 @@
341 341 $ echo babar
342 342 - rataxes
343 343 + babar
344 344 This is a noop statement so that
345 345 this test is still more bytes than success.
346 346 pad pad pad pad............................................................
347 347
348 348 ERROR: test-failure.t output changed
349 349 !.
350 350 --- $TESTTMP/test-failure-unicode.t
351 351 +++ $TESTTMP/output/test-failure-unicode.t.err
352 352 @@ -1,2 +1,2 @@
353 353 $ echo babar\xce\xb1 (esc)
354 354 - l\xce\xb5\xce\xb5t (esc)
355 355 + babar\xce\xb1 (esc)
356 356
357 357 ERROR: test-failure-unicode.t output changed
358 358 !
359 359 Failed test-failure-unicode.t: output changed
360 360 Failed test-failure.t: output changed
361 361 # Ran 3 tests, 0 skipped, 2 failed.
362 362 python hash seed: * (glob)
363 363 [1]
364 364 $ ls -a output
365 365 .
366 366 ..
367 367 .testtimes
368 368 test-failure-unicode.t.err
369 369 test-failure.t.err
370 370
371 371 test --xunit support
372 372 $ rt --xunit=xunit.xml
373 373 running 3 tests using 1 parallel processes
374 374
375 375 --- $TESTTMP/test-failure.t
376 376 +++ $TESTTMP/test-failure.t.err
377 377 @@ -1,5 +1,5 @@
378 378 $ echo babar
379 379 - rataxes
380 380 + babar
381 381 This is a noop statement so that
382 382 this test is still more bytes than success.
383 383 pad pad pad pad............................................................
384 384
385 385 ERROR: test-failure.t output changed
386 386 !.
387 387 --- $TESTTMP/test-failure-unicode.t
388 388 +++ $TESTTMP/test-failure-unicode.t.err
389 389 @@ -1,2 +1,2 @@
390 390 $ echo babar\xce\xb1 (esc)
391 391 - l\xce\xb5\xce\xb5t (esc)
392 392 + babar\xce\xb1 (esc)
393 393
394 394 ERROR: test-failure-unicode.t output changed
395 395 !
396 396 Failed test-failure-unicode.t: output changed
397 397 Failed test-failure.t: output changed
398 398 # Ran 3 tests, 0 skipped, 2 failed.
399 399 python hash seed: * (glob)
400 400 [1]
401 401 $ cat xunit.xml
402 402 <?xml version="1.0" encoding="utf-8"?>
403 403 <testsuite errors="0" failures="2" name="run-tests" skipped="0" tests="3">
404 404 <testcase name="test-success.t" time="*"/> (glob)
405 405 <testcase name="test-failure-unicode.t" time="*"> (glob)
406 406 <failure message="output changed" type="output-mismatch"><![CDATA[--- $TESTTMP/test-failure-unicode.t (py38 !)
407 407 <failure message="output changed" type="output-mismatch"> (no-py38 !)
408 408 <![CDATA[--- $TESTTMP/test-failure-unicode.t (no-py38 !)
409 409 +++ $TESTTMP/test-failure-unicode.t.err
410 410 @@ -1,2 +1,2 @@
411 411 $ echo babar\xce\xb1 (esc)
412 412 - l\xce\xb5\xce\xb5t (esc)
413 413 + babar\xce\xb1 (esc)
414 414 ]]></failure> (py38 !)
415 415 ]]> </failure> (no-py38 !)
416 416 </testcase>
417 417 <testcase name="test-failure.t" time="*"> (glob)
418 418 <failure message="output changed" type="output-mismatch"><![CDATA[--- $TESTTMP/test-failure.t (py38 !)
419 419 <failure message="output changed" type="output-mismatch"> (no-py38 !)
420 420 <![CDATA[--- $TESTTMP/test-failure.t (no-py38 !)
421 421 +++ $TESTTMP/test-failure.t.err
422 422 @@ -1,5 +1,5 @@
423 423 $ echo babar
424 424 - rataxes
425 425 + babar
426 426 This is a noop statement so that
427 427 this test is still more bytes than success.
428 428 pad pad pad pad............................................................
429 429 ]]></failure> (py38 !)
430 430 ]]> </failure> (no-py38 !)
431 431 </testcase>
432 432 </testsuite>
433 433
434 434 $ cat .testtimes
435 435 test-empty.t * (glob)
436 436 test-failure-globs.t * (glob)
437 437 test-failure-unicode.t * (glob)
438 438 test-failure.t * (glob)
439 439 test-success.t * (glob)
440 440
441 441 $ rt --list-tests
442 442 test-failure-unicode.t
443 443 test-failure.t
444 444 test-success.t
445 445
446 446 $ rt --list-tests --json
447 447 test-failure-unicode.t
448 448 test-failure.t
449 449 test-success.t
450 450 $ cat report.json
451 451 testreport ={
452 452 "test-failure-unicode.t": {
453 453 "result": "success"
454 454 },
455 455 "test-failure.t": {
456 456 "result": "success"
457 457 },
458 458 "test-success.t": {
459 459 "result": "success"
460 460 }
461 461 } (no-eol)
462 462
463 463 $ rt --list-tests --xunit=xunit.xml
464 464 test-failure-unicode.t
465 465 test-failure.t
466 466 test-success.t
467 467 $ cat xunit.xml
468 468 <?xml version="1.0" encoding="utf-8"?>
469 469 <testsuite errors="0" failures="0" name="run-tests" skipped="0" tests="0">
470 470 <testcase name="test-failure-unicode.t"/>
471 471 <testcase name="test-failure.t"/>
472 472 <testcase name="test-success.t"/>
473 473 </testsuite>
474 474
475 475 $ rt --list-tests test-failure* --json --xunit=xunit.xml --outputdir output
476 476 test-failure-unicode.t
477 477 test-failure.t
478 478 $ cat output/report.json
479 479 testreport ={
480 480 "test-failure-unicode.t": {
481 481 "result": "success"
482 482 },
483 483 "test-failure.t": {
484 484 "result": "success"
485 485 }
486 486 } (no-eol)
487 487 $ cat xunit.xml
488 488 <?xml version="1.0" encoding="utf-8"?>
489 489 <testsuite errors="0" failures="0" name="run-tests" skipped="0" tests="0">
490 490 <testcase name="test-failure-unicode.t"/>
491 491 <testcase name="test-failure.t"/>
492 492 </testsuite>
493 493
494 494 $ rm test-failure-unicode.t
495 495
496 496 test for --retest
497 497 ====================
498 498
499 499 $ rt --retest
500 500 running 2 tests using 1 parallel processes
501 501
502 502 --- $TESTTMP/test-failure.t
503 503 +++ $TESTTMP/test-failure.t.err
504 504 @@ -1,5 +1,5 @@
505 505 $ echo babar
506 506 - rataxes
507 507 + babar
508 508 This is a noop statement so that
509 509 this test is still more bytes than success.
510 510 pad pad pad pad............................................................
511 511
512 512 ERROR: test-failure.t output changed
513 513 !
514 514 Failed test-failure.t: output changed
515 515 # Ran 2 tests, 1 skipped, 1 failed.
516 516 python hash seed: * (glob)
517 517 [1]
518 518
519 519 --retest works with --outputdir
520 520 $ rm -r output
521 521 $ mkdir output
522 522 $ mv test-failure.t.err output
523 523 $ rt --retest --outputdir output
524 524 running 2 tests using 1 parallel processes
525 525
526 526 --- $TESTTMP/test-failure.t
527 527 +++ $TESTTMP/output/test-failure.t.err
528 528 @@ -1,5 +1,5 @@
529 529 $ echo babar
530 530 - rataxes
531 531 + babar
532 532 This is a noop statement so that
533 533 this test is still more bytes than success.
534 534 pad pad pad pad............................................................
535 535
536 536 ERROR: test-failure.t output changed
537 537 !
538 538 Failed test-failure.t: output changed
539 539 # Ran 2 tests, 1 skipped, 1 failed.
540 540 python hash seed: * (glob)
541 541 [1]
542 542
543 543 Selecting Tests To Run
544 544 ======================
545 545
546 546 successful
547 547
548 548 $ rt test-success.t
549 549 running 1 tests using 1 parallel processes
550 550 .
551 551 # Ran 1 tests, 0 skipped, 0 failed.
552 552
553 553 success w/ keyword
554 554 $ rt -k xyzzy
555 555 running 2 tests using 1 parallel processes
556 556 .
557 557 # Ran 2 tests, 1 skipped, 0 failed.
558 558
559 559 failed
560 560
561 561 $ rt test-failure.t
562 562 running 1 tests using 1 parallel processes
563 563
564 564 --- $TESTTMP/test-failure.t
565 565 +++ $TESTTMP/test-failure.t.err
566 566 @@ -1,5 +1,5 @@
567 567 $ echo babar
568 568 - rataxes
569 569 + babar
570 570 This is a noop statement so that
571 571 this test is still more bytes than success.
572 572 pad pad pad pad............................................................
573 573
574 574 ERROR: test-failure.t output changed
575 575 !
576 576 Failed test-failure.t: output changed
577 577 # Ran 1 tests, 0 skipped, 1 failed.
578 578 python hash seed: * (glob)
579 579 [1]
580 580
581 581 failure w/ keyword
582 582 $ rt -k rataxes
583 583 running 2 tests using 1 parallel processes
584 584
585 585 --- $TESTTMP/test-failure.t
586 586 +++ $TESTTMP/test-failure.t.err
587 587 @@ -1,5 +1,5 @@
588 588 $ echo babar
589 589 - rataxes
590 590 + babar
591 591 This is a noop statement so that
592 592 this test is still more bytes than success.
593 593 pad pad pad pad............................................................
594 594
595 595 ERROR: test-failure.t output changed
596 596 !
597 597 Failed test-failure.t: output changed
598 598 # Ran 2 tests, 1 skipped, 1 failed.
599 599 python hash seed: * (glob)
600 600 [1]
601 601
602 602 Verify that when a process fails to start we show a useful message
603 603 ==================================================================
604 604
605 605 $ cat > test-serve-fail.t <<EOF
606 606 > $ echo 'abort: child process failed to start blah'
607 607 > EOF
608 608 $ rt test-serve-fail.t
609 609 running 1 tests using 1 parallel processes
610 610
611 611 --- $TESTTMP/test-serve-fail.t
612 612 +++ $TESTTMP/test-serve-fail.t.err
613 613 @@ -1* +1,2 @@ (glob)
614 614 $ echo 'abort: child process failed to start blah'
615 615 + abort: child process failed to start blah
616 616
617 617 ERROR: test-serve-fail.t output changed
618 618 !
619 619 Failed test-serve-fail.t: server failed to start (HGPORT=*) (glob)
620 620 # Ran 1 tests, 0 skipped, 1 failed.
621 621 python hash seed: * (glob)
622 622 [1]
623 623 $ rm test-serve-fail.t
624 624
625 625 Verify that we can try other ports
626 626 ===================================
627 627
628 628 Extensions aren't inherited by the invoked run-tests.py. An extension
629 629 introducing a repository requirement could cause this to fail. So we force
630 630 HGRCPATH to get a clean environment.
631 631
632 632 $ HGRCPATH= hg init inuse
633 633 $ hg serve -R inuse -p $HGPORT -d --pid-file=blocks.pid
634 634 $ cat blocks.pid >> $DAEMON_PIDS
635 635 $ cat > test-serve-inuse.t <<EOF
636 636 > $ hg serve -R `pwd`/inuse -p \$HGPORT -d --pid-file=hg.pid
637 637 > $ cat hg.pid >> \$DAEMON_PIDS
638 638 > EOF
639 639 $ rt test-serve-inuse.t
640 640 running 1 tests using 1 parallel processes
641 641 .
642 642 # Ran 1 tests, 0 skipped, 0 failed.
643 643 $ rm test-serve-inuse.t
644 644 $ killdaemons.py $DAEMON_PIDS
645 645
646 646 Running In Debug Mode
647 647 ======================
648 648
649 649 $ rt --debug 2>&1 | grep -v pwd
650 650 running 2 tests using 1 parallel processes
651 651 + alias hg=hg.exe (windows !)
652 652 + echo *SALT* 0 0 (glob)
653 653 *SALT* 0 0 (glob)
654 654 + echo babar
655 655 babar
656 656 + echo *SALT* 10 0 (glob)
657 657 *SALT* 10 0 (glob)
658 658 .+ alias hg=hg.exe (windows !)
659 659 *+ echo *SALT* 0 0 (glob)
660 660 *SALT* 0 0 (glob)
661 661 + echo babar
662 662 babar
663 663 + echo *SALT* 2 0 (glob)
664 664 *SALT* 2 0 (glob)
665 665 + echo xyzzy
666 666 xyzzy
667 667 + echo *SALT* 9 0 (glob)
668 668 *SALT* 9 0 (glob)
669 669 + printf *abc\ndef\nxyz\n* (glob)
670 670 abc
671 671 def
672 672 xyz
673 673 + echo *SALT* 15 0 (glob)
674 674 *SALT* 15 0 (glob)
675 675 + printf *zyx\nwvu\ntsr\n* (glob)
676 676 zyx
677 677 wvu
678 678 tsr
679 679 + echo *SALT* 22 0 (glob)
680 680 *SALT* 22 0 (glob)
681 681 .
682 682 # Ran 2 tests, 0 skipped, 0 failed.
683 683
684 684 Parallel runs
685 685 ==============
686 686
687 687 (duplicate the failing test to get predictable output)
688 688 $ cp test-failure.t test-failure-copy.t
689 689
690 690 $ rt --jobs 2 test-failure*.t -n
691 691 running 2 tests using 2 parallel processes
692 692 !!
693 693 Failed test-failure*.t: output changed (glob)
694 694 Failed test-failure*.t: output changed (glob)
695 695 # Ran 2 tests, 0 skipped, 2 failed.
696 696 python hash seed: * (glob)
697 697 [1]
698 698
699 699 failures in parallel with --first should only print one failure
700 700 $ rt --jobs 2 --first test-failure*.t
701 701 running 2 tests using 2 parallel processes
702 702
703 703 --- $TESTTMP/test-failure*.t (glob)
704 704 +++ $TESTTMP/test-failure*.t.err (glob)
705 705 @@ -1,5 +1,5 @@
706 706 $ echo babar
707 707 - rataxes
708 708 + babar
709 709 This is a noop statement so that
710 710 this test is still more bytes than success.
711 711 pad pad pad pad............................................................
712 712
713 713 Failed test-failure*.t: output changed (glob)
714 714 Failed test-failure*.t: output changed (glob)
715 715 # Ran 2 tests, 0 skipped, 2 failed.
716 716 python hash seed: * (glob)
717 717 [1]
718 718
719 719
720 720 (delete the duplicated test file)
721 721 $ rm test-failure-copy.t
722 722
723 723 multiple runs per test should be parallelized
724 724
725 725 $ rt --jobs 2 --runs-per-test 2 test-success.t
726 726 running 2 tests using 2 parallel processes
727 727 ..
728 728 # Ran 2 tests, 0 skipped, 0 failed.
729 729
730 730 Interactive run
731 731 ===============
732 732
733 733 (backup the failing test)
734 734 $ cp test-failure.t backup
735 735
736 736 Refuse the fix
737 737
738 738 $ echo 'n' | rt -i
739 739 running 2 tests using 1 parallel processes
740 740
741 741 --- $TESTTMP/test-failure.t
742 742 +++ $TESTTMP/test-failure.t.err
743 743 @@ -1,5 +1,5 @@
744 744 $ echo babar
745 745 - rataxes
746 746 + babar
747 747 This is a noop statement so that
748 748 this test is still more bytes than success.
749 749 pad pad pad pad............................................................
750 750 Accept this change? [y/N]
751 751 ERROR: test-failure.t output changed
752 752 !.
753 753 Failed test-failure.t: output changed
754 754 # Ran 2 tests, 0 skipped, 1 failed.
755 755 python hash seed: * (glob)
756 756 [1]
757 757
758 758 $ cat test-failure.t
759 759 $ echo babar
760 760 rataxes
761 761 This is a noop statement so that
762 762 this test is still more bytes than success.
763 763 pad pad pad pad............................................................
764 764 pad pad pad pad............................................................
765 765 pad pad pad pad............................................................
766 766 pad pad pad pad............................................................
767 767 pad pad pad pad............................................................
768 768 pad pad pad pad............................................................
769 769
770 770 Interactive with custom view
771 771
772 772 $ echo 'n' | rt -i --view echo
773 773 running 2 tests using 1 parallel processes
774 774 $TESTTMP/test-failure.t $TESTTMP/test-failure.t.err
775 775 Accept this change? [y/N]* (glob)
776 776 ERROR: test-failure.t output changed
777 777 !.
778 778 Failed test-failure.t: output changed
779 779 # Ran 2 tests, 0 skipped, 1 failed.
780 780 python hash seed: * (glob)
781 781 [1]
782 782
783 783 View the fix
784 784
785 785 $ echo 'y' | rt --view echo
786 786 running 2 tests using 1 parallel processes
787 787 $TESTTMP/test-failure.t $TESTTMP/test-failure.t.err
788 788
789 789 ERROR: test-failure.t output changed
790 790 !.
791 791 Failed test-failure.t: output changed
792 792 # Ran 2 tests, 0 skipped, 1 failed.
793 793 python hash seed: * (glob)
794 794 [1]
795 795
796 796 Accept the fix
797 797
798 798 $ cat >> test-failure.t <<EOF
799 799 > $ echo 'saved backup bundle to \$TESTTMP/foo.hg'
800 800 > saved backup bundle to \$TESTTMP/foo.hg
801 801 > $ echo 'saved backup bundle to \$TESTTMP/foo.hg'
802 802 > saved backup bundle to $TESTTMP\\foo.hg
803 803 > $ echo 'saved backup bundle to \$TESTTMP/foo.hg'
804 804 > saved backup bundle to \$TESTTMP/*.hg (glob)
805 805 > EOF
806 806 $ echo 'y' | rt -i 2>&1
807 807 running 2 tests using 1 parallel processes
808 808
809 809 --- $TESTTMP/test-failure.t
810 810 +++ $TESTTMP/test-failure.t.err
811 811 @@ -1,5 +1,5 @@
812 812 $ echo babar
813 813 - rataxes
814 814 + babar
815 815 This is a noop statement so that
816 816 this test is still more bytes than success.
817 817 pad pad pad pad............................................................
818 818 @@ -11,6 +11,6 @@
819 819 $ echo 'saved backup bundle to $TESTTMP/foo.hg'
820 820 saved backup bundle to $TESTTMP/foo.hg
821 821 $ echo 'saved backup bundle to $TESTTMP/foo.hg'
822 822 - saved backup bundle to $TESTTMP\foo.hg
823 823 + saved backup bundle to $TESTTMP/foo.hg
824 824 $ echo 'saved backup bundle to $TESTTMP/foo.hg'
825 825 saved backup bundle to $TESTTMP/*.hg (glob)
826 826 Accept this change? [y/N] ..
827 827 # Ran 2 tests, 0 skipped, 0 failed.
828 828
829 829 $ sed -e 's,(glob)$,&<,g' test-failure.t
830 830 $ echo babar
831 831 babar
832 832 This is a noop statement so that
833 833 this test is still more bytes than success.
834 834 pad pad pad pad............................................................
835 835 pad pad pad pad............................................................
836 836 pad pad pad pad............................................................
837 837 pad pad pad pad............................................................
838 838 pad pad pad pad............................................................
839 839 pad pad pad pad............................................................
840 840 $ echo 'saved backup bundle to $TESTTMP/foo.hg'
841 841 saved backup bundle to $TESTTMP/foo.hg
842 842 $ echo 'saved backup bundle to $TESTTMP/foo.hg'
843 843 saved backup bundle to $TESTTMP/foo.hg
844 844 $ echo 'saved backup bundle to $TESTTMP/foo.hg'
845 845 saved backup bundle to $TESTTMP/*.hg (glob)<
846 846
847 847 $ rm test-failure.t
848 848
849 849 Race condition - test file was modified when test is running
850 850
851 851 $ TESTRACEDIR=`pwd`
852 852 $ export TESTRACEDIR
853 853 $ cat > test-race.t <<EOF
854 854 > $ echo 1
855 855 > $ echo "# a new line" >> $TESTRACEDIR/test-race.t
856 856 > EOF
857 857
858 858 $ rt -i test-race.t
859 859 running 1 tests using 1 parallel processes
860 860
861 861 --- $TESTTMP/test-race.t
862 862 +++ $TESTTMP/test-race.t.err
863 863 @@ -1,2 +1,3 @@
864 864 $ echo 1
865 865 + 1
866 866 $ echo "# a new line" >> $TESTTMP/test-race.t
867 867 Reference output has changed (run again to prompt changes)
868 868 ERROR: test-race.t output changed
869 869 !
870 870 Failed test-race.t: output changed
871 871 # Ran 1 tests, 0 skipped, 1 failed.
872 872 python hash seed: * (glob)
873 873 [1]
874 874
875 875 $ rm test-race.t
876 876
877 877 When "#testcases" is used in .t files
878 878
879 879 $ cat >> test-cases.t <<EOF
880 880 > #testcases a b
881 881 > #if a
882 882 > $ echo 1
883 883 > #endif
884 884 > #if b
885 885 > $ echo 2
886 886 > #endif
887 887 > EOF
888 888
889 889 $ cat <<EOF | rt -i test-cases.t 2>&1
890 890 > y
891 891 > y
892 892 > EOF
893 893 running 2 tests using 1 parallel processes
894 894
895 895 --- $TESTTMP/test-cases.t
896 896 +++ $TESTTMP/test-cases.t#a.err
897 897 @@ -1,6 +1,7 @@
898 898 #testcases a b
899 899 #if a
900 900 $ echo 1
901 901 + 1
902 902 #endif
903 903 #if b
904 904 $ echo 2
905 905 Accept this change? [y/N] .
906 906 --- $TESTTMP/test-cases.t
907 907 +++ $TESTTMP/test-cases.t#b.err
908 908 @@ -5,4 +5,5 @@
909 909 #endif
910 910 #if b
911 911 $ echo 2
912 912 + 2
913 913 #endif
914 914 Accept this change? [y/N] .
915 915 # Ran 2 tests, 0 skipped, 0 failed.
916 916
917 917 $ cat test-cases.t
918 918 #testcases a b
919 919 #if a
920 920 $ echo 1
921 921 1
922 922 #endif
923 923 #if b
924 924 $ echo 2
925 925 2
926 926 #endif
927 927
928 928 $ cat >> test-cases.t <<'EOF'
929 929 > #if a
930 930 > $ NAME=A
931 931 > #else
932 932 > $ NAME=B
933 933 > #endif
934 934 > $ echo $NAME
935 935 > A (a !)
936 936 > B (b !)
937 937 > EOF
938 938 $ rt test-cases.t
939 939 running 2 tests using 1 parallel processes
940 940 ..
941 941 # Ran 2 tests, 0 skipped, 0 failed.
942 942
943 943 When using multiple dimensions of "#testcases" in .t files
944 944
945 945 $ cat > test-cases.t <<'EOF'
946 946 > #testcases a b
947 947 > #testcases c d
948 948 > #if a d
949 949 > $ echo $TESTCASE
950 950 > a#d
951 951 > #endif
952 952 > #if b c
953 953 > $ echo yes
954 954 > no
955 955 > #endif
956 956 > EOF
957 957 $ rt test-cases.t
958 958 running 4 tests using 1 parallel processes
959 959 ..
960 960 --- $TESTTMP/test-cases.t
961 961 +++ $TESTTMP/test-cases.t#b#c.err
962 962 @@ -6,5 +6,5 @@
963 963 #endif
964 964 #if b c
965 965 $ echo yes
966 966 - no
967 967 + yes
968 968 #endif
969 969
970 970 ERROR: test-cases.t#b#c output changed
971 971 !.
972 972 Failed test-cases.t#b#c: output changed
973 973 # Ran 4 tests, 0 skipped, 1 failed.
974 974 python hash seed: * (glob)
975 975 [1]
976 976
977 $ rt --retest
978 running 5 tests using 1 parallel processes
979
980 --- $TESTTMP/test-cases.t
981 +++ $TESTTMP/test-cases.t#b#c.err
982 @@ -6,5 +6,5 @@
983 #endif
984 #if b c
985 $ echo yes
986 - no
987 + yes
988 #endif
989
990 ERROR: test-cases.t#b#c output changed
991 !
992 Failed test-cases.t#b#c: output changed
993 # Ran 5 tests, 4 skipped, 1 failed.
994 python hash seed: * (glob)
995 [1]
977 996 $ rm test-cases.t#b#c.err
978 997 $ rm test-cases.t
979 998
980 999 (reinstall)
981 1000 $ mv backup test-failure.t
982 1001
983 1002 No Diff
984 1003 ===============
985 1004
986 1005 $ rt --nodiff
987 1006 running 2 tests using 1 parallel processes
988 1007 !.
989 1008 Failed test-failure.t: output changed
990 1009 # Ran 2 tests, 0 skipped, 1 failed.
991 1010 python hash seed: * (glob)
992 1011 [1]
993 1012
994 1013 test --tmpdir support
995 1014 $ rt --tmpdir=$TESTTMP/keep test-success.t
996 1015 running 1 tests using 1 parallel processes
997 1016
998 1017 Keeping testtmp dir: $TESTTMP/keep/child1/test-success.t
999 1018 Keeping threadtmp dir: $TESTTMP/keep/child1
1000 1019 .
1001 1020 # Ran 1 tests, 0 skipped, 0 failed.
1002 1021
1003 1022 timeouts
1004 1023 ========
1005 1024 $ cat > test-timeout.t <<EOF
1006 1025 > $ sleep 2
1007 1026 > $ echo pass
1008 1027 > pass
1009 1028 > EOF
1010 1029 > echo '#require slow' > test-slow-timeout.t
1011 1030 > cat test-timeout.t >> test-slow-timeout.t
1012 1031 $ rt --timeout=1 --slowtimeout=3 test-timeout.t test-slow-timeout.t
1013 1032 running 2 tests using 1 parallel processes
1014 1033 st
1015 1034 Skipped test-slow-timeout.t: missing feature: allow slow tests (use --allow-slow-tests)
1016 1035 Failed test-timeout.t: timed out
1017 1036 # Ran 1 tests, 1 skipped, 1 failed.
1018 1037 python hash seed: * (glob)
1019 1038 [1]
1020 1039 $ rt --timeout=1 --slowtimeout=3 \
1021 1040 > test-timeout.t test-slow-timeout.t --allow-slow-tests
1022 1041 running 2 tests using 1 parallel processes
1023 1042 .t
1024 1043 Failed test-timeout.t: timed out
1025 1044 # Ran 2 tests, 0 skipped, 1 failed.
1026 1045 python hash seed: * (glob)
1027 1046 [1]
1028 1047 $ rm test-timeout.t test-slow-timeout.t
1029 1048
1030 1049 test for --time
1031 1050 ==================
1032 1051
1033 1052 $ rt test-success.t --time
1034 1053 running 1 tests using 1 parallel processes
1035 1054 .
1036 1055 # Ran 1 tests, 0 skipped, 0 failed.
1037 1056 # Producing time report
1038 1057 start end cuser csys real Test
1039 1058 \s*[\d\.]{5,8} \s*[\d\.]{5,8} \s*[\d\.]{5,8} \s*[\d\.]{5,8} \s*[\d\.]{5,8} test-success.t (re)
1040 1059
1041 1060 test for --time with --job enabled
1042 1061 ====================================
1043 1062
1044 1063 $ rt test-success.t --time --jobs 2
1045 1064 running 1 tests using 1 parallel processes
1046 1065 .
1047 1066 # Ran 1 tests, 0 skipped, 0 failed.
1048 1067 # Producing time report
1049 1068 start end cuser csys real Test
1050 1069 \s*[\d\.]{5,8} \s*[\d\.]{5,8} \s*[\d\.]{5,8} \s*[\d\.]{5,8} \s*[\d\.]{5,8} test-success.t (re)
1051 1070
1052 1071 Skips
1053 1072 ================
1054 1073 $ cat > test-skip.t <<EOF
1055 1074 > $ echo xyzzy
1056 1075 > #if true
1057 1076 > #require false
1058 1077 > #end
1059 1078 > EOF
1060 1079 $ cat > test-noskip.t <<EOF
1061 1080 > #if false
1062 1081 > #require false
1063 1082 > #endif
1064 1083 > EOF
1065 1084 $ rt --nodiff
1066 1085 running 4 tests using 1 parallel processes
1067 1086 !.s.
1068 1087 Skipped test-skip.t: missing feature: nail clipper
1069 1088 Failed test-failure.t: output changed
1070 1089 # Ran 3 tests, 1 skipped, 1 failed.
1071 1090 python hash seed: * (glob)
1072 1091 [1]
1073 1092
1074 1093 $ rm test-noskip.t
1075 1094 $ rt --keyword xyzzy
1076 1095 running 3 tests using 1 parallel processes
1077 1096 .s
1078 1097 Skipped test-skip.t: missing feature: nail clipper
1079 1098 # Ran 2 tests, 2 skipped, 0 failed.
1080 1099
1081 1100 Skips with xml
1082 1101 $ rt --keyword xyzzy \
1083 1102 > --xunit=xunit.xml
1084 1103 running 3 tests using 1 parallel processes
1085 1104 .s
1086 1105 Skipped test-skip.t: missing feature: nail clipper
1087 1106 # Ran 2 tests, 2 skipped, 0 failed.
1088 1107 $ cat xunit.xml
1089 1108 <?xml version="1.0" encoding="utf-8"?>
1090 1109 <testsuite errors="0" failures="0" name="run-tests" skipped="2" tests="2">
1091 1110 <testcase name="test-success.t" time="*"/> (glob)
1092 1111 <testcase name="test-skip.t">
1093 1112 <skipped><![CDATA[missing feature: nail clipper]]></skipped> (py38 !)
1094 1113 <skipped> (no-py38 !)
1095 1114 <![CDATA[missing feature: nail clipper]]> </skipped> (no-py38 !)
1096 1115 </testcase>
1097 1116 </testsuite>
1098 1117
1099 1118 Missing skips or blacklisted skips don't count as executed:
1100 1119 $ echo test-failure.t > blacklist
1101 1120 $ rt --blacklist=blacklist --json\
1102 1121 > test-failure.t test-bogus.t
1103 1122 running 2 tests using 1 parallel processes
1104 1123 ss
1105 1124 Skipped test-bogus.t: Doesn't exist
1106 1125 Skipped test-failure.t: blacklisted
1107 1126 # Ran 0 tests, 2 skipped, 0 failed.
1108 1127 $ cat report.json
1109 1128 testreport ={
1110 1129 "test-bogus.t": {
1111 1130 "result": "skip"
1112 1131 },
1113 1132 "test-failure.t": {
1114 1133 "result": "skip"
1115 1134 }
1116 1135 } (no-eol)
1117 1136
1118 1137 Whitelist trumps blacklist
1119 1138 $ echo test-failure.t > whitelist
1120 1139 $ rt --blacklist=blacklist --whitelist=whitelist --json\
1121 1140 > test-failure.t test-bogus.t
1122 1141 running 2 tests using 1 parallel processes
1123 1142 s
1124 1143 --- $TESTTMP/test-failure.t
1125 1144 +++ $TESTTMP/test-failure.t.err
1126 1145 @@ -1,5 +1,5 @@
1127 1146 $ echo babar
1128 1147 - rataxes
1129 1148 + babar
1130 1149 This is a noop statement so that
1131 1150 this test is still more bytes than success.
1132 1151 pad pad pad pad............................................................
1133 1152
1134 1153 ERROR: test-failure.t output changed
1135 1154 !
1136 1155 Skipped test-bogus.t: Doesn't exist
1137 1156 Failed test-failure.t: output changed
1138 1157 # Ran 1 tests, 1 skipped, 1 failed.
1139 1158 python hash seed: * (glob)
1140 1159 [1]
1141 1160
1142 1161 Ensure that --test-list causes only the tests listed in that file to
1143 1162 be executed.
1144 1163 $ echo test-success.t >> onlytest
1145 1164 $ rt --test-list=onlytest
1146 1165 running 1 tests using 1 parallel processes
1147 1166 .
1148 1167 # Ran 1 tests, 0 skipped, 0 failed.
1149 1168 $ echo test-bogus.t >> anothertest
1150 1169 $ rt --test-list=onlytest --test-list=anothertest
1151 1170 running 2 tests using 1 parallel processes
1152 1171 s.
1153 1172 Skipped test-bogus.t: Doesn't exist
1154 1173 # Ran 1 tests, 1 skipped, 0 failed.
1155 1174 $ rm onlytest anothertest
1156 1175
1157 1176 test for --json
1158 1177 ==================
1159 1178
1160 1179 $ rt --json
1161 1180 running 3 tests using 1 parallel processes
1162 1181
1163 1182 --- $TESTTMP/test-failure.t
1164 1183 +++ $TESTTMP/test-failure.t.err
1165 1184 @@ -1,5 +1,5 @@
1166 1185 $ echo babar
1167 1186 - rataxes
1168 1187 + babar
1169 1188 This is a noop statement so that
1170 1189 this test is still more bytes than success.
1171 1190 pad pad pad pad............................................................
1172 1191
1173 1192 ERROR: test-failure.t output changed
1174 1193 !.s
1175 1194 Skipped test-skip.t: missing feature: nail clipper
1176 1195 Failed test-failure.t: output changed
1177 1196 # Ran 2 tests, 1 skipped, 1 failed.
1178 1197 python hash seed: * (glob)
1179 1198 [1]
1180 1199
1181 1200 $ cat report.json
1182 1201 testreport ={
1183 1202 "test-failure.t": [\{] (re)
1184 1203 "csys": "\s*\d+\.\d{3,4}", ? (re)
1185 1204 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1186 1205 "diff": "---.+\+\+\+.+", ? (re)
1187 1206 "end": "\s*\d+\.\d{3,4}", ? (re)
1188 1207 "result": "failure", ? (re)
1189 1208 "start": "\s*\d+\.\d{3,4}", ? (re)
1190 1209 "time": "\s*\d+\.\d{3,4}" (re)
1191 1210 }, ? (re)
1192 1211 "test-skip.t": {
1193 1212 "csys": "\s*\d+\.\d{3,4}", ? (re)
1194 1213 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1195 1214 "diff": "", ? (re)
1196 1215 "end": "\s*\d+\.\d{3,4}", ? (re)
1197 1216 "result": "skip", ? (re)
1198 1217 "start": "\s*\d+\.\d{3,4}", ? (re)
1199 1218 "time": "\s*\d+\.\d{3,4}" (re)
1200 1219 }, ? (re)
1201 1220 "test-success.t": [\{] (re)
1202 1221 "csys": "\s*\d+\.\d{3,4}", ? (re)
1203 1222 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1204 1223 "diff": "", ? (re)
1205 1224 "end": "\s*\d+\.\d{3,4}", ? (re)
1206 1225 "result": "success", ? (re)
1207 1226 "start": "\s*\d+\.\d{3,4}", ? (re)
1208 1227 "time": "\s*\d+\.\d{3,4}" (re)
1209 1228 }
1210 1229 } (no-eol)
1211 1230 --json with --outputdir
1212 1231
1213 1232 $ rm report.json
1214 1233 $ rm -r output
1215 1234 $ mkdir output
1216 1235 $ rt --json --outputdir output
1217 1236 running 3 tests using 1 parallel processes
1218 1237
1219 1238 --- $TESTTMP/test-failure.t
1220 1239 +++ $TESTTMP/output/test-failure.t.err
1221 1240 @@ -1,5 +1,5 @@
1222 1241 $ echo babar
1223 1242 - rataxes
1224 1243 + babar
1225 1244 This is a noop statement so that
1226 1245 this test is still more bytes than success.
1227 1246 pad pad pad pad............................................................
1228 1247
1229 1248 ERROR: test-failure.t output changed
1230 1249 !.s
1231 1250 Skipped test-skip.t: missing feature: nail clipper
1232 1251 Failed test-failure.t: output changed
1233 1252 # Ran 2 tests, 1 skipped, 1 failed.
1234 1253 python hash seed: * (glob)
1235 1254 [1]
1236 1255 $ f report.json
1237 1256 report.json: file not found
1238 1257 $ cat output/report.json
1239 1258 testreport ={
1240 1259 "test-failure.t": [\{] (re)
1241 1260 "csys": "\s*\d+\.\d{3,4}", ? (re)
1242 1261 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1243 1262 "diff": "---.+\+\+\+.+", ? (re)
1244 1263 "end": "\s*\d+\.\d{3,4}", ? (re)
1245 1264 "result": "failure", ? (re)
1246 1265 "start": "\s*\d+\.\d{3,4}", ? (re)
1247 1266 "time": "\s*\d+\.\d{3,4}" (re)
1248 1267 }, ? (re)
1249 1268 "test-skip.t": {
1250 1269 "csys": "\s*\d+\.\d{3,4}", ? (re)
1251 1270 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1252 1271 "diff": "", ? (re)
1253 1272 "end": "\s*\d+\.\d{3,4}", ? (re)
1254 1273 "result": "skip", ? (re)
1255 1274 "start": "\s*\d+\.\d{3,4}", ? (re)
1256 1275 "time": "\s*\d+\.\d{3,4}" (re)
1257 1276 }, ? (re)
1258 1277 "test-success.t": [\{] (re)
1259 1278 "csys": "\s*\d+\.\d{3,4}", ? (re)
1260 1279 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1261 1280 "diff": "", ? (re)
1262 1281 "end": "\s*\d+\.\d{3,4}", ? (re)
1263 1282 "result": "success", ? (re)
1264 1283 "start": "\s*\d+\.\d{3,4}", ? (re)
1265 1284 "time": "\s*\d+\.\d{3,4}" (re)
1266 1285 }
1267 1286 } (no-eol)
1268 1287 $ ls -a output
1269 1288 .
1270 1289 ..
1271 1290 .testtimes
1272 1291 report.json
1273 1292 test-failure.t.err
1274 1293
1275 1294 Test that failed test accepted through interactive are properly reported:
1276 1295
1277 1296 $ cp test-failure.t backup
1278 1297 $ echo y | rt --json -i
1279 1298 running 3 tests using 1 parallel processes
1280 1299
1281 1300 --- $TESTTMP/test-failure.t
1282 1301 +++ $TESTTMP/test-failure.t.err
1283 1302 @@ -1,5 +1,5 @@
1284 1303 $ echo babar
1285 1304 - rataxes
1286 1305 + babar
1287 1306 This is a noop statement so that
1288 1307 this test is still more bytes than success.
1289 1308 pad pad pad pad............................................................
1290 1309 Accept this change? [y/N] ..s
1291 1310 Skipped test-skip.t: missing feature: nail clipper
1292 1311 # Ran 2 tests, 1 skipped, 0 failed.
1293 1312
1294 1313 $ cat report.json
1295 1314 testreport ={
1296 1315 "test-failure.t": [\{] (re)
1297 1316 "csys": "\s*\d+\.\d{3,4}", ? (re)
1298 1317 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1299 1318 "diff": "", ? (re)
1300 1319 "end": "\s*\d+\.\d{3,4}", ? (re)
1301 1320 "result": "success", ? (re)
1302 1321 "start": "\s*\d+\.\d{3,4}", ? (re)
1303 1322 "time": "\s*\d+\.\d{3,4}" (re)
1304 1323 }, ? (re)
1305 1324 "test-skip.t": {
1306 1325 "csys": "\s*\d+\.\d{3,4}", ? (re)
1307 1326 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1308 1327 "diff": "", ? (re)
1309 1328 "end": "\s*\d+\.\d{3,4}", ? (re)
1310 1329 "result": "skip", ? (re)
1311 1330 "start": "\s*\d+\.\d{3,4}", ? (re)
1312 1331 "time": "\s*\d+\.\d{3,4}" (re)
1313 1332 }, ? (re)
1314 1333 "test-success.t": [\{] (re)
1315 1334 "csys": "\s*\d+\.\d{3,4}", ? (re)
1316 1335 "cuser": "\s*\d+\.\d{3,4}", ? (re)
1317 1336 "diff": "", ? (re)
1318 1337 "end": "\s*\d+\.\d{3,4}", ? (re)
1319 1338 "result": "success", ? (re)
1320 1339 "start": "\s*\d+\.\d{3,4}", ? (re)
1321 1340 "time": "\s*\d+\.\d{3,4}" (re)
1322 1341 }
1323 1342 } (no-eol)
1324 1343 $ mv backup test-failure.t
1325 1344
1326 1345 backslash on end of line with glob matching is handled properly
1327 1346
1328 1347 $ cat > test-glob-backslash.t << EOF
1329 1348 > $ echo 'foo bar \\'
1330 1349 > foo * \ (glob)
1331 1350 > EOF
1332 1351
1333 1352 $ rt test-glob-backslash.t
1334 1353 running 1 tests using 1 parallel processes
1335 1354 .
1336 1355 # Ran 1 tests, 0 skipped, 0 failed.
1337 1356
1338 1357 $ rm -f test-glob-backslash.t
1339 1358
1340 1359 Test globbing of local IP addresses
1341 1360 $ echo 172.16.18.1
1342 1361 $LOCALIP (glob)
1343 1362 $ echo dead:beef::1
1344 1363 $LOCALIP (glob)
1345 1364
1346 1365 Add support for external test formatter
1347 1366 =======================================
1348 1367
1349 1368 $ CUSTOM_TEST_RESULT=basic_test_result "$PYTHON" $TESTDIR/run-tests.py --with-hg=`which hg` -j1 "$@" test-success.t test-failure.t
1350 1369 running 2 tests using 1 parallel processes
1351 1370
1352 1371 # Ran 2 tests, 0 skipped, 0 failed.
1353 1372 ON_START! <__main__.TestSuite tests=[<__main__.TTest testMethod=test-failure.t>, <__main__.TTest testMethod=test-success.t>]>
1354 1373 FAILURE! test-failure.t output changed
1355 1374 SUCCESS! test-success.t
1356 1375 ON_END!
1357 1376
1358 1377 Test reusability for third party tools
1359 1378 ======================================
1360 1379
1361 1380 $ mkdir "$TESTTMP"/anothertests
1362 1381 $ cd "$TESTTMP"/anothertests
1363 1382
1364 1383 test that `run-tests.py` can execute hghave, even if it runs not in
1365 1384 Mercurial source tree.
1366 1385
1367 1386 $ cat > test-hghave.t <<EOF
1368 1387 > #require true
1369 1388 > $ echo foo
1370 1389 > foo
1371 1390 > EOF
1372 1391 $ rt test-hghave.t
1373 1392 running 1 tests using 1 parallel processes
1374 1393 .
1375 1394 # Ran 1 tests, 0 skipped, 0 failed.
1376 1395
1377 1396 test that RUNTESTDIR refers the directory, in which `run-tests.py` now
1378 1397 running is placed.
1379 1398
1380 1399 $ cat > test-runtestdir.t <<EOF
1381 1400 > - $TESTDIR, in which test-run-tests.t is placed
1382 1401 > - \$TESTDIR, in which test-runtestdir.t is placed (expanded at runtime)
1383 1402 > - \$RUNTESTDIR, in which run-tests.py is placed (expanded at runtime)
1384 1403 >
1385 1404 > #if windows
1386 1405 > $ test "\$TESTDIR" = "$TESTTMP\anothertests"
1387 1406 > #else
1388 1407 > $ test "\$TESTDIR" = "$TESTTMP"/anothertests
1389 1408 > #endif
1390 1409 > If this prints a path, that means RUNTESTDIR didn't equal
1391 1410 > TESTDIR as it should have.
1392 1411 > $ test "\$RUNTESTDIR" = "$TESTDIR" || echo "\$RUNTESTDIR"
1393 1412 > This should print the start of check-code. If this passes but the
1394 1413 > previous check failed, that means we found a copy of check-code at whatever
1395 1414 > RUNTESTSDIR ended up containing, even though it doesn't match TESTDIR.
1396 1415 > $ head -n 3 "\$RUNTESTDIR"/../contrib/check-code.py | sed 's@.!.*python@#!USRBINENVPY@'
1397 1416 > #!USRBINENVPY
1398 1417 > #
1399 1418 > # check-code - a style and portability checker for Mercurial
1400 1419 > EOF
1401 1420 $ rt test-runtestdir.t
1402 1421 running 1 tests using 1 parallel processes
1403 1422 .
1404 1423 # Ran 1 tests, 0 skipped, 0 failed.
1405 1424
1406 1425 #if execbit
1407 1426
1408 1427 test that TESTDIR is referred in PATH
1409 1428
1410 1429 $ cat > custom-command.sh <<EOF
1411 1430 > #!/bin/sh
1412 1431 > echo "hello world"
1413 1432 > EOF
1414 1433 $ chmod +x custom-command.sh
1415 1434 $ cat > test-testdir-path.t <<EOF
1416 1435 > $ custom-command.sh
1417 1436 > hello world
1418 1437 > EOF
1419 1438 $ rt test-testdir-path.t
1420 1439 running 1 tests using 1 parallel processes
1421 1440 .
1422 1441 # Ran 1 tests, 0 skipped, 0 failed.
1423 1442
1424 1443 #endif
1425 1444
1426 1445 test support for --allow-slow-tests
1427 1446 $ cat > test-very-slow-test.t <<EOF
1428 1447 > #require slow
1429 1448 > $ echo pass
1430 1449 > pass
1431 1450 > EOF
1432 1451 $ rt test-very-slow-test.t
1433 1452 running 1 tests using 1 parallel processes
1434 1453 s
1435 1454 Skipped test-very-slow-test.t: missing feature: allow slow tests (use --allow-slow-tests)
1436 1455 # Ran 0 tests, 1 skipped, 0 failed.
1437 1456 $ rt $HGTEST_RUN_TESTS_PURE --allow-slow-tests test-very-slow-test.t
1438 1457 running 1 tests using 1 parallel processes
1439 1458 .
1440 1459 # Ran 1 tests, 0 skipped, 0 failed.
1441 1460
1442 1461 support for running a test outside the current directory
1443 1462 $ mkdir nonlocal
1444 1463 $ cat > nonlocal/test-is-not-here.t << EOF
1445 1464 > $ echo pass
1446 1465 > pass
1447 1466 > EOF
1448 1467 $ rt nonlocal/test-is-not-here.t
1449 1468 running 1 tests using 1 parallel processes
1450 1469 .
1451 1470 # Ran 1 tests, 0 skipped, 0 failed.
1452 1471
1453 1472 support for automatically discovering test if arg is a folder
1454 1473 $ mkdir tmp && cd tmp
1455 1474
1456 1475 $ cat > test-uno.t << EOF
1457 1476 > $ echo line
1458 1477 > line
1459 1478 > EOF
1460 1479
1461 1480 $ cp test-uno.t test-dos.t
1462 1481 $ cd ..
1463 1482 $ cp -R tmp tmpp
1464 1483 $ cp tmp/test-uno.t test-solo.t
1465 1484
1466 1485 $ rt tmp/ test-solo.t tmpp
1467 1486 running 5 tests using 1 parallel processes
1468 1487 .....
1469 1488 # Ran 5 tests, 0 skipped, 0 failed.
1470 1489 $ rm -rf tmp tmpp
1471 1490
1472 1491 support for running run-tests.py from another directory
1473 1492 $ mkdir tmp && cd tmp
1474 1493
1475 1494 $ cat > useful-file.sh << EOF
1476 1495 > important command
1477 1496 > EOF
1478 1497
1479 1498 $ cat > test-folder.t << EOF
1480 1499 > $ cat \$TESTDIR/useful-file.sh
1481 1500 > important command
1482 1501 > EOF
1483 1502
1484 1503 $ cat > test-folder-fail.t << EOF
1485 1504 > $ cat \$TESTDIR/useful-file.sh
1486 1505 > important commando
1487 1506 > EOF
1488 1507
1489 1508 $ cd ..
1490 1509 $ rt tmp/test-*.t
1491 1510 running 2 tests using 1 parallel processes
1492 1511
1493 1512 --- $TESTTMP/anothertests/tmp/test-folder-fail.t
1494 1513 +++ $TESTTMP/anothertests/tmp/test-folder-fail.t.err
1495 1514 @@ -1,2 +1,2 @@
1496 1515 $ cat $TESTDIR/useful-file.sh
1497 1516 - important commando
1498 1517 + important command
1499 1518
1500 1519 ERROR: test-folder-fail.t output changed
1501 1520 !.
1502 1521 Failed test-folder-fail.t: output changed
1503 1522 # Ran 2 tests, 0 skipped, 1 failed.
1504 1523 python hash seed: * (glob)
1505 1524 [1]
1506 1525
1507 1526 support for bisecting failed tests automatically
1508 1527 $ hg init bisect
1509 1528 $ cd bisect
1510 1529 $ cat >> test-bisect.t <<EOF
1511 1530 > $ echo pass
1512 1531 > pass
1513 1532 > EOF
1514 1533 $ hg add test-bisect.t
1515 1534 $ hg ci -m 'good'
1516 1535 $ cat >> test-bisect.t <<EOF
1517 1536 > $ echo pass
1518 1537 > fail
1519 1538 > EOF
1520 1539 $ hg ci -m 'bad'
1521 1540 $ rt --known-good-rev=0 test-bisect.t
1522 1541 running 1 tests using 1 parallel processes
1523 1542
1524 1543 --- $TESTTMP/anothertests/bisect/test-bisect.t
1525 1544 +++ $TESTTMP/anothertests/bisect/test-bisect.t.err
1526 1545 @@ -1,4 +1,4 @@
1527 1546 $ echo pass
1528 1547 pass
1529 1548 $ echo pass
1530 1549 - fail
1531 1550 + pass
1532 1551
1533 1552 ERROR: test-bisect.t output changed
1534 1553 !
1535 1554 Failed test-bisect.t: output changed
1536 1555 test-bisect.t broken by 72cbf122d116 (bad)
1537 1556 # Ran 1 tests, 0 skipped, 1 failed.
1538 1557 python hash seed: * (glob)
1539 1558 [1]
1540 1559
1541 1560 $ cd ..
1542 1561
1543 1562 support bisecting a separate repo
1544 1563
1545 1564 $ hg init bisect-dependent
1546 1565 $ cd bisect-dependent
1547 1566 $ cat > test-bisect-dependent.t <<EOF
1548 1567 > $ tail -1 \$TESTDIR/../bisect/test-bisect.t
1549 1568 > pass
1550 1569 > EOF
1551 1570 $ hg commit -Am dependent test-bisect-dependent.t
1552 1571
1553 1572 $ rt --known-good-rev=0 test-bisect-dependent.t
1554 1573 running 1 tests using 1 parallel processes
1555 1574
1556 1575 --- $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t
1557 1576 +++ $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t.err
1558 1577 @@ -1,2 +1,2 @@
1559 1578 $ tail -1 $TESTDIR/../bisect/test-bisect.t
1560 1579 - pass
1561 1580 + fail
1562 1581
1563 1582 ERROR: test-bisect-dependent.t output changed
1564 1583 !
1565 1584 Failed test-bisect-dependent.t: output changed
1566 1585 Failed to identify failure point for test-bisect-dependent.t
1567 1586 # Ran 1 tests, 0 skipped, 1 failed.
1568 1587 python hash seed: * (glob)
1569 1588 [1]
1570 1589
1571 1590 $ rt --bisect-repo=../test-bisect test-bisect-dependent.t
1572 1591 usage: run-tests.py [options] [tests]
1573 1592 run-tests.py: error: --bisect-repo cannot be used without --known-good-rev
1574 1593 [2]
1575 1594
1576 1595 $ rt --known-good-rev=0 --bisect-repo=../bisect test-bisect-dependent.t
1577 1596 running 1 tests using 1 parallel processes
1578 1597
1579 1598 --- $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t
1580 1599 +++ $TESTTMP/anothertests/bisect-dependent/test-bisect-dependent.t.err
1581 1600 @@ -1,2 +1,2 @@
1582 1601 $ tail -1 $TESTDIR/../bisect/test-bisect.t
1583 1602 - pass
1584 1603 + fail
1585 1604
1586 1605 ERROR: test-bisect-dependent.t output changed
1587 1606 !
1588 1607 Failed test-bisect-dependent.t: output changed
1589 1608 test-bisect-dependent.t broken by 72cbf122d116 (bad)
1590 1609 # Ran 1 tests, 0 skipped, 1 failed.
1591 1610 python hash seed: * (glob)
1592 1611 [1]
1593 1612
1594 1613 $ cd ..
1595 1614
1596 1615 Test a broken #if statement doesn't break run-tests threading.
1597 1616 ==============================================================
1598 1617 $ mkdir broken
1599 1618 $ cd broken
1600 1619 $ cat > test-broken.t <<EOF
1601 1620 > true
1602 1621 > #if notarealhghavefeature
1603 1622 > $ false
1604 1623 > #endif
1605 1624 > EOF
1606 1625 $ for f in 1 2 3 4 ; do
1607 1626 > cat > test-works-$f.t <<EOF
1608 1627 > This is test case $f
1609 1628 > $ sleep 1
1610 1629 > EOF
1611 1630 > done
1612 1631 $ rt -j 2
1613 1632 running 5 tests using 2 parallel processes
1614 1633 ....
1615 1634 # Ran 5 tests, 0 skipped, 0 failed.
1616 1635 skipped: unknown feature: notarealhghavefeature
1617 1636
1618 1637 $ cd ..
1619 1638 $ rm -rf broken
1620 1639
1621 1640 Test cases in .t files
1622 1641 ======================
1623 1642 $ mkdir cases
1624 1643 $ cd cases
1625 1644 $ cat > test-cases-abc.t <<'EOF'
1626 1645 > #testcases A B C
1627 1646 > $ V=B
1628 1647 > #if A
1629 1648 > $ V=A
1630 1649 > #endif
1631 1650 > #if C
1632 1651 > $ V=C
1633 1652 > #endif
1634 1653 > $ echo $V | sed 's/A/C/'
1635 1654 > C
1636 1655 > #if C
1637 1656 > $ [ $V = C ]
1638 1657 > #endif
1639 1658 > #if A
1640 1659 > $ [ $V = C ]
1641 1660 > [1]
1642 1661 > #endif
1643 1662 > #if no-C
1644 1663 > $ [ $V = C ]
1645 1664 > [1]
1646 1665 > #endif
1647 1666 > $ [ $V = D ]
1648 1667 > [1]
1649 1668 > EOF
1650 1669 $ rt
1651 1670 running 3 tests using 1 parallel processes
1652 1671 .
1653 1672 --- $TESTTMP/anothertests/cases/test-cases-abc.t
1654 1673 +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err
1655 1674 @@ -7,7 +7,7 @@
1656 1675 $ V=C
1657 1676 #endif
1658 1677 $ echo $V | sed 's/A/C/'
1659 1678 - C
1660 1679 + B
1661 1680 #if C
1662 1681 $ [ $V = C ]
1663 1682 #endif
1664 1683
1665 1684 ERROR: test-cases-abc.t#B output changed
1666 1685 !.
1667 1686 Failed test-cases-abc.t#B: output changed
1668 1687 # Ran 3 tests, 0 skipped, 1 failed.
1669 1688 python hash seed: * (glob)
1670 1689 [1]
1671 1690
1672 1691 --restart works
1673 1692
1674 1693 $ rt --restart
1675 1694 running 2 tests using 1 parallel processes
1676 1695
1677 1696 --- $TESTTMP/anothertests/cases/test-cases-abc.t
1678 1697 +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err
1679 1698 @@ -7,7 +7,7 @@
1680 1699 $ V=C
1681 1700 #endif
1682 1701 $ echo $V | sed 's/A/C/'
1683 1702 - C
1684 1703 + B
1685 1704 #if C
1686 1705 $ [ $V = C ]
1687 1706 #endif
1688 1707
1689 1708 ERROR: test-cases-abc.t#B output changed
1690 1709 !.
1691 1710 Failed test-cases-abc.t#B: output changed
1692 1711 # Ran 2 tests, 0 skipped, 1 failed.
1693 1712 python hash seed: * (glob)
1694 1713 [1]
1695 1714
1696 1715 --restart works with outputdir
1697 1716
1698 1717 $ mkdir output
1699 1718 $ mv test-cases-abc.t#B.err output
1700 1719 $ rt --restart --outputdir output
1701 1720 running 2 tests using 1 parallel processes
1702 1721
1703 1722 --- $TESTTMP/anothertests/cases/test-cases-abc.t
1704 1723 +++ $TESTTMP/anothertests/cases/output/test-cases-abc.t#B.err
1705 1724 @@ -7,7 +7,7 @@
1706 1725 $ V=C
1707 1726 #endif
1708 1727 $ echo $V | sed 's/A/C/'
1709 1728 - C
1710 1729 + B
1711 1730 #if C
1712 1731 $ [ $V = C ]
1713 1732 #endif
1714 1733
1715 1734 ERROR: test-cases-abc.t#B output changed
1716 1735 !.
1717 1736 Failed test-cases-abc.t#B: output changed
1718 1737 # Ran 2 tests, 0 skipped, 1 failed.
1719 1738 python hash seed: * (glob)
1720 1739 [1]
1721 1740
1722 1741 Test TESTCASE variable
1723 1742
1724 1743 $ cat > test-cases-ab.t <<'EOF'
1725 1744 > $ dostuff() {
1726 1745 > > echo "In case $TESTCASE"
1727 1746 > > }
1728 1747 > #testcases A B
1729 1748 > #if A
1730 1749 > $ dostuff
1731 1750 > In case A
1732 1751 > #endif
1733 1752 > #if B
1734 1753 > $ dostuff
1735 1754 > In case B
1736 1755 > #endif
1737 1756 > EOF
1738 1757 $ rt test-cases-ab.t
1739 1758 running 2 tests using 1 parallel processes
1740 1759 ..
1741 1760 # Ran 2 tests, 0 skipped, 0 failed.
1742 1761
1743 1762 Support running a specific test case
1744 1763
1745 1764 $ rt "test-cases-abc.t#B"
1746 1765 running 1 tests using 1 parallel processes
1747 1766
1748 1767 --- $TESTTMP/anothertests/cases/test-cases-abc.t
1749 1768 +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err
1750 1769 @@ -7,7 +7,7 @@
1751 1770 $ V=C
1752 1771 #endif
1753 1772 $ echo $V | sed 's/A/C/'
1754 1773 - C
1755 1774 + B
1756 1775 #if C
1757 1776 $ [ $V = C ]
1758 1777 #endif
1759 1778
1760 1779 ERROR: test-cases-abc.t#B output changed
1761 1780 !
1762 1781 Failed test-cases-abc.t#B: output changed
1763 1782 # Ran 1 tests, 0 skipped, 1 failed.
1764 1783 python hash seed: * (glob)
1765 1784 [1]
1766 1785
1767 1786 Support running multiple test cases in the same file
1768 1787
1769 1788 $ rt test-cases-abc.t#B test-cases-abc.t#C
1770 1789 running 2 tests using 1 parallel processes
1771 1790
1772 1791 --- $TESTTMP/anothertests/cases/test-cases-abc.t
1773 1792 +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err
1774 1793 @@ -7,7 +7,7 @@
1775 1794 $ V=C
1776 1795 #endif
1777 1796 $ echo $V | sed 's/A/C/'
1778 1797 - C
1779 1798 + B
1780 1799 #if C
1781 1800 $ [ $V = C ]
1782 1801 #endif
1783 1802
1784 1803 ERROR: test-cases-abc.t#B output changed
1785 1804 !.
1786 1805 Failed test-cases-abc.t#B: output changed
1787 1806 # Ran 2 tests, 0 skipped, 1 failed.
1788 1807 python hash seed: * (glob)
1789 1808 [1]
1790 1809
1791 1810 Support ignoring invalid test cases
1792 1811
1793 1812 $ rt test-cases-abc.t#B test-cases-abc.t#D
1794 1813 running 1 tests using 1 parallel processes
1795 1814
1796 1815 --- $TESTTMP/anothertests/cases/test-cases-abc.t
1797 1816 +++ $TESTTMP/anothertests/cases/test-cases-abc.t#B.err
1798 1817 @@ -7,7 +7,7 @@
1799 1818 $ V=C
1800 1819 #endif
1801 1820 $ echo $V | sed 's/A/C/'
1802 1821 - C
1803 1822 + B
1804 1823 #if C
1805 1824 $ [ $V = C ]
1806 1825 #endif
1807 1826
1808 1827 ERROR: test-cases-abc.t#B output changed
1809 1828 !
1810 1829 Failed test-cases-abc.t#B: output changed
1811 1830 # Ran 1 tests, 0 skipped, 1 failed.
1812 1831 python hash seed: * (glob)
1813 1832 [1]
1814 1833
1815 1834 Support running complex test cases names
1816 1835
1817 1836 $ cat > test-cases-advanced-cases.t <<'EOF'
1818 1837 > #testcases simple case-with-dashes casewith_-.chars
1819 1838 > $ echo $TESTCASE
1820 1839 > simple
1821 1840 > EOF
1822 1841
1823 1842 $ cat test-cases-advanced-cases.t
1824 1843 #testcases simple case-with-dashes casewith_-.chars
1825 1844 $ echo $TESTCASE
1826 1845 simple
1827 1846
1828 1847 $ rt test-cases-advanced-cases.t
1829 1848 running 3 tests using 1 parallel processes
1830 1849
1831 1850 --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t
1832 1851 +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#case-with-dashes.err
1833 1852 @@ -1,3 +1,3 @@
1834 1853 #testcases simple case-with-dashes casewith_-.chars
1835 1854 $ echo $TESTCASE
1836 1855 - simple
1837 1856 + case-with-dashes
1838 1857
1839 1858 ERROR: test-cases-advanced-cases.t#case-with-dashes output changed
1840 1859 !
1841 1860 --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t
1842 1861 +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#casewith_-.chars.err
1843 1862 @@ -1,3 +1,3 @@
1844 1863 #testcases simple case-with-dashes casewith_-.chars
1845 1864 $ echo $TESTCASE
1846 1865 - simple
1847 1866 + casewith_-.chars
1848 1867
1849 1868 ERROR: test-cases-advanced-cases.t#casewith_-.chars output changed
1850 1869 !.
1851 1870 Failed test-cases-advanced-cases.t#case-with-dashes: output changed
1852 1871 Failed test-cases-advanced-cases.t#casewith_-.chars: output changed
1853 1872 # Ran 3 tests, 0 skipped, 2 failed.
1854 1873 python hash seed: * (glob)
1855 1874 [1]
1856 1875
1857 1876 $ rt "test-cases-advanced-cases.t#case-with-dashes"
1858 1877 running 1 tests using 1 parallel processes
1859 1878
1860 1879 --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t
1861 1880 +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#case-with-dashes.err
1862 1881 @@ -1,3 +1,3 @@
1863 1882 #testcases simple case-with-dashes casewith_-.chars
1864 1883 $ echo $TESTCASE
1865 1884 - simple
1866 1885 + case-with-dashes
1867 1886
1868 1887 ERROR: test-cases-advanced-cases.t#case-with-dashes output changed
1869 1888 !
1870 1889 Failed test-cases-advanced-cases.t#case-with-dashes: output changed
1871 1890 # Ran 1 tests, 0 skipped, 1 failed.
1872 1891 python hash seed: * (glob)
1873 1892 [1]
1874 1893
1875 1894 $ rt "test-cases-advanced-cases.t#casewith_-.chars"
1876 1895 running 1 tests using 1 parallel processes
1877 1896
1878 1897 --- $TESTTMP/anothertests/cases/test-cases-advanced-cases.t
1879 1898 +++ $TESTTMP/anothertests/cases/test-cases-advanced-cases.t#casewith_-.chars.err
1880 1899 @@ -1,3 +1,3 @@
1881 1900 #testcases simple case-with-dashes casewith_-.chars
1882 1901 $ echo $TESTCASE
1883 1902 - simple
1884 1903 + casewith_-.chars
1885 1904
1886 1905 ERROR: test-cases-advanced-cases.t#casewith_-.chars output changed
1887 1906 !
1888 1907 Failed test-cases-advanced-cases.t#casewith_-.chars: output changed
1889 1908 # Ran 1 tests, 0 skipped, 1 failed.
1890 1909 python hash seed: * (glob)
1891 1910 [1]
1892 1911
1893 1912 Test automatic pattern replacement
1894 1913 ==================================
1895 1914
1896 1915 $ cat << EOF >> common-pattern.py
1897 1916 > substitutions = [
1898 1917 > (br'foo-(.*)\\b',
1899 1918 > br'\$XXX=\\1\$'),
1900 1919 > (br'bar\\n',
1901 1920 > br'\$YYY$\\n'),
1902 1921 > ]
1903 1922 > EOF
1904 1923
1905 1924 $ cat << EOF >> test-substitution.t
1906 1925 > $ echo foo-12
1907 1926 > \$XXX=12$
1908 1927 > $ echo foo-42
1909 1928 > \$XXX=42$
1910 1929 > $ echo bar prior
1911 1930 > bar prior
1912 1931 > $ echo lastbar
1913 1932 > last\$YYY$
1914 1933 > $ echo foo-bar foo-baz
1915 1934 > EOF
1916 1935
1917 1936 $ rt test-substitution.t
1918 1937 running 1 tests using 1 parallel processes
1919 1938
1920 1939 --- $TESTTMP/anothertests/cases/test-substitution.t
1921 1940 +++ $TESTTMP/anothertests/cases/test-substitution.t.err
1922 1941 @@ -7,3 +7,4 @@
1923 1942 $ echo lastbar
1924 1943 last$YYY$
1925 1944 $ echo foo-bar foo-baz
1926 1945 + $XXX=bar foo-baz$
1927 1946
1928 1947 ERROR: test-substitution.t output changed
1929 1948 !
1930 1949 Failed test-substitution.t: output changed
1931 1950 # Ran 1 tests, 0 skipped, 1 failed.
1932 1951 python hash seed: * (glob)
1933 1952 [1]
1934 1953
1935 1954 --extra-config-opt works
1936 1955
1937 1956 $ cat << EOF >> test-config-opt.t
1938 1957 > $ hg init test-config-opt
1939 1958 > $ hg -R test-config-opt purge
1940 1959 > EOF
1941 1960
1942 1961 $ rt --extra-config-opt extensions.purge= test-config-opt.t
1943 1962 running 1 tests using 1 parallel processes
1944 1963 .
1945 1964 # Ran 1 tests, 0 skipped, 0 failed.
1946 1965
1947 1966 Test conditional output matching
1948 1967 ================================
1949 1968
1950 1969 $ cat << EOF >> test-conditional-matching.t
1951 1970 > #testcases foo bar
1952 1971 > $ echo richtig
1953 1972 > richtig (true !)
1954 1973 > $ echo falsch
1955 1974 > falsch (false !)
1956 1975 > #if foo
1957 1976 > $ echo arthur
1958 1977 > arthur (bar !)
1959 1978 > #endif
1960 1979 > $ echo celeste
1961 1980 > celeste (foo !)
1962 1981 > $ echo zephir
1963 1982 > zephir (bar !)
1964 1983 > EOF
1965 1984
1966 1985 $ rt test-conditional-matching.t
1967 1986 running 2 tests using 1 parallel processes
1968 1987
1969 1988 --- $TESTTMP/anothertests/cases/test-conditional-matching.t
1970 1989 +++ $TESTTMP/anothertests/cases/test-conditional-matching.t#bar.err
1971 1990 @@ -3,11 +3,13 @@
1972 1991 richtig (true !)
1973 1992 $ echo falsch
1974 1993 falsch (false !)
1975 1994 + falsch
1976 1995 #if foo
1977 1996 $ echo arthur
1978 1997 arthur \(bar !\) (re)
1979 1998 #endif
1980 1999 $ echo celeste
1981 2000 celeste \(foo !\) (re)
1982 2001 + celeste
1983 2002 $ echo zephir
1984 2003 zephir \(bar !\) (re)
1985 2004
1986 2005 ERROR: test-conditional-matching.t#bar output changed
1987 2006 !
1988 2007 --- $TESTTMP/anothertests/cases/test-conditional-matching.t
1989 2008 +++ $TESTTMP/anothertests/cases/test-conditional-matching.t#foo.err
1990 2009 @@ -3,11 +3,14 @@
1991 2010 richtig (true !)
1992 2011 $ echo falsch
1993 2012 falsch (false !)
1994 2013 + falsch
1995 2014 #if foo
1996 2015 $ echo arthur
1997 2016 arthur \(bar !\) (re)
1998 2017 + arthur
1999 2018 #endif
2000 2019 $ echo celeste
2001 2020 celeste \(foo !\) (re)
2002 2021 $ echo zephir
2003 2022 zephir \(bar !\) (re)
2004 2023 + zephir
2005 2024
2006 2025 ERROR: test-conditional-matching.t#foo output changed
2007 2026 !
2008 2027 Failed test-conditional-matching.t#bar: output changed
2009 2028 Failed test-conditional-matching.t#foo: output changed
2010 2029 # Ran 2 tests, 0 skipped, 2 failed.
2011 2030 python hash seed: * (glob)
2012 2031 [1]
General Comments 0
You need to be logged in to leave comments. Login now