Merge branch 'jc/ignore-epipe-in-filter'
[git] / t / t0000-basic.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2005 Junio C Hamano
4 #
5
6 test_description='Test the very basics part #1.
7
8 The rest of the test suite does not check the basic operation of git
9 plumbing commands to work very carefully.  Their job is to concentrate
10 on tricky features that caused bugs in the past to detect regression.
11
12 This test runs very basic features, like registering things in cache,
13 writing tree, etc.
14
15 Note that this test *deliberately* hard-codes many expected object
16 IDs.  When object ID computation changes, like in the previous case of
17 swapping compression and hashing order, the person who is making the
18 modification *should* take notice and update the test vectors here.
19 '
20
21 . ./test-lib.sh
22
23 ################################################################
24 # git init has been done in an empty repository.
25 # make sure it is empty.
26
27 test_expect_success '.git/objects should be empty after git init in an empty repo' '
28         find .git/objects -type f -print >should-be-empty &&
29         test_line_count = 0 should-be-empty
30 '
31
32 # also it should have 2 subdirectories; no fan-out anymore, pack, and info.
33 # 3 is counting "objects" itself
34 test_expect_success '.git/objects should have 3 subdirectories' '
35         find .git/objects -type d -print >full-of-directories &&
36         test_line_count = 3 full-of-directories
37 '
38
39 ################################################################
40 # Test harness
41 test_expect_success 'success is reported like this' '
42         :
43 '
44
45 _run_sub_test_lib_test_common () {
46         neg="$1" name="$2" descr="$3" # stdin is the body of the test code
47         shift 3
48         mkdir "$name" &&
49         (
50                 # Pretend we're not running under a test harness, whether we
51                 # are or not. The test-lib output depends on the setting of
52                 # this variable, so we need a stable setting under which to run
53                 # the sub-test.
54                 sane_unset HARNESS_ACTIVE &&
55                 cd "$name" &&
56                 cat >"$name.sh" <<-EOF &&
57                 #!$SHELL_PATH
58
59                 test_description='$descr (run in sub test-lib)
60
61                 This is run in a sub test-lib so that we do not get incorrect
62                 passing metrics
63                 '
64
65                 # Point to the t/test-lib.sh, which isn't in ../ as usual
66                 . "\$TEST_DIRECTORY"/test-lib.sh
67                 EOF
68                 cat >>"$name.sh" &&
69                 chmod +x "$name.sh" &&
70                 export TEST_DIRECTORY &&
71                 TEST_OUTPUT_DIRECTORY=$(pwd) &&
72                 export TEST_OUTPUT_DIRECTORY &&
73                 if test -z "$neg"
74                 then
75                         ./"$name.sh" "$@" >out 2>err
76                 else
77                         !  ./"$name.sh" "$@" >out 2>err
78                 fi
79         )
80 }
81
82 run_sub_test_lib_test () {
83         _run_sub_test_lib_test_common '' "$@"
84 }
85
86 run_sub_test_lib_test_err () {
87         _run_sub_test_lib_test_common '!' "$@"
88 }
89
90 check_sub_test_lib_test () {
91         name="$1" # stdin is the expected output from the test
92         (
93                 cd "$name" &&
94                 ! test -s err &&
95                 sed -e 's/^> //' -e 's/Z$//' >expect &&
96                 test_cmp expect out
97         )
98 }
99
100 check_sub_test_lib_test_err () {
101         name="$1" # stdin is the expected output output from the test
102         # expected error output is in descriptior 3
103         (
104                 cd "$name" &&
105                 sed -e 's/^> //' -e 's/Z$//' >expect.out &&
106                 test_cmp expect.out out &&
107                 sed -e 's/^> //' -e 's/Z$//' <&3 >expect.err &&
108                 test_cmp expect.err err
109         )
110 }
111
112 test_expect_success 'pretend we have a fully passing test suite' "
113         run_sub_test_lib_test full-pass '3 passing tests' <<-\\EOF &&
114         for i in 1 2 3
115         do
116                 test_expect_success \"passing test #\$i\" 'true'
117         done
118         test_done
119         EOF
120         check_sub_test_lib_test full-pass <<-\\EOF
121         > ok 1 - passing test #1
122         > ok 2 - passing test #2
123         > ok 3 - passing test #3
124         > # passed all 3 test(s)
125         > 1..3
126         EOF
127 "
128
129 test_expect_success 'pretend we have a partially passing test suite' "
130         test_must_fail run_sub_test_lib_test \
131                 partial-pass '2/3 tests passing' <<-\\EOF &&
132         test_expect_success 'passing test #1' 'true'
133         test_expect_success 'failing test #2' 'false'
134         test_expect_success 'passing test #3' 'true'
135         test_done
136         EOF
137         check_sub_test_lib_test partial-pass <<-\\EOF
138         > ok 1 - passing test #1
139         > not ok 2 - failing test #2
140         #       false
141         > ok 3 - passing test #3
142         > # failed 1 among 3 test(s)
143         > 1..3
144         EOF
145 "
146
147 test_expect_success 'pretend we have a known breakage' "
148         run_sub_test_lib_test failing-todo 'A failing TODO test' <<-\\EOF &&
149         test_expect_success 'passing test' 'true'
150         test_expect_failure 'pretend we have a known breakage' 'false'
151         test_done
152         EOF
153         check_sub_test_lib_test failing-todo <<-\\EOF
154         > ok 1 - passing test
155         > not ok 2 - pretend we have a known breakage # TODO known breakage
156         > # still have 1 known breakage(s)
157         > # passed all remaining 1 test(s)
158         > 1..2
159         EOF
160 "
161
162 test_expect_success 'pretend we have fixed a known breakage' "
163         run_sub_test_lib_test passing-todo 'A passing TODO test' <<-\\EOF &&
164         test_expect_failure 'pretend we have fixed a known breakage' 'true'
165         test_done
166         EOF
167         check_sub_test_lib_test passing-todo <<-\\EOF
168         > ok 1 - pretend we have fixed a known breakage # TODO known breakage vanished
169         > # 1 known breakage(s) vanished; please update test(s)
170         > 1..1
171         EOF
172 "
173
174 test_expect_success 'pretend we have fixed one of two known breakages (run in sub test-lib)' "
175         run_sub_test_lib_test partially-passing-todos \
176                 '2 TODO tests, one passing' <<-\\EOF &&
177         test_expect_failure 'pretend we have a known breakage' 'false'
178         test_expect_success 'pretend we have a passing test' 'true'
179         test_expect_failure 'pretend we have fixed another known breakage' 'true'
180         test_done
181         EOF
182         check_sub_test_lib_test partially-passing-todos <<-\\EOF
183         > not ok 1 - pretend we have a known breakage # TODO known breakage
184         > ok 2 - pretend we have a passing test
185         > ok 3 - pretend we have fixed another known breakage # TODO known breakage vanished
186         > # 1 known breakage(s) vanished; please update test(s)
187         > # still have 1 known breakage(s)
188         > # passed all remaining 1 test(s)
189         > 1..3
190         EOF
191 "
192
193 test_expect_success 'pretend we have a pass, fail, and known breakage' "
194         test_must_fail run_sub_test_lib_test \
195                 mixed-results1 'mixed results #1' <<-\\EOF &&
196         test_expect_success 'passing test' 'true'
197         test_expect_success 'failing test' 'false'
198         test_expect_failure 'pretend we have a known breakage' 'false'
199         test_done
200         EOF
201         check_sub_test_lib_test mixed-results1 <<-\\EOF
202         > ok 1 - passing test
203         > not ok 2 - failing test
204         > #     false
205         > not ok 3 - pretend we have a known breakage # TODO known breakage
206         > # still have 1 known breakage(s)
207         > # failed 1 among remaining 2 test(s)
208         > 1..3
209         EOF
210 "
211
212 test_expect_success 'pretend we have a mix of all possible results' "
213         test_must_fail run_sub_test_lib_test \
214                 mixed-results2 'mixed results #2' <<-\\EOF &&
215         test_expect_success 'passing test' 'true'
216         test_expect_success 'passing test' 'true'
217         test_expect_success 'passing test' 'true'
218         test_expect_success 'passing test' 'true'
219         test_expect_success 'failing test' 'false'
220         test_expect_success 'failing test' 'false'
221         test_expect_success 'failing test' 'false'
222         test_expect_failure 'pretend we have a known breakage' 'false'
223         test_expect_failure 'pretend we have a known breakage' 'false'
224         test_expect_failure 'pretend we have fixed a known breakage' 'true'
225         test_done
226         EOF
227         check_sub_test_lib_test mixed-results2 <<-\\EOF
228         > ok 1 - passing test
229         > ok 2 - passing test
230         > ok 3 - passing test
231         > ok 4 - passing test
232         > not ok 5 - failing test
233         > #     false
234         > not ok 6 - failing test
235         > #     false
236         > not ok 7 - failing test
237         > #     false
238         > not ok 8 - pretend we have a known breakage # TODO known breakage
239         > not ok 9 - pretend we have a known breakage # TODO known breakage
240         > ok 10 - pretend we have fixed a known breakage # TODO known breakage vanished
241         > # 1 known breakage(s) vanished; please update test(s)
242         > # still have 2 known breakage(s)
243         > # failed 3 among remaining 7 test(s)
244         > 1..10
245         EOF
246 "
247
248 test_expect_success 'test --verbose' '
249         test_must_fail run_sub_test_lib_test \
250                 test-verbose "test verbose" --verbose <<-\EOF &&
251         test_expect_success "passing test" true
252         test_expect_success "test with output" "echo foo"
253         test_expect_success "failing test" false
254         test_done
255         EOF
256         mv test-verbose/out test-verbose/out+ &&
257         grep -v "^Initialized empty" test-verbose/out+ >test-verbose/out &&
258         check_sub_test_lib_test test-verbose <<-\EOF
259         > expecting success: true
260         > ok 1 - passing test
261         > Z
262         > expecting success: echo foo
263         > foo
264         > ok 2 - test with output
265         > Z
266         > expecting success: false
267         > not ok 3 - failing test
268         > #     false
269         > Z
270         > # failed 1 among 3 test(s)
271         > 1..3
272         EOF
273 '
274
275 test_expect_success 'test --verbose-only' '
276         test_must_fail run_sub_test_lib_test \
277                 test-verbose-only-2 "test verbose-only=2" \
278                 --verbose-only=2 <<-\EOF &&
279         test_expect_success "passing test" true
280         test_expect_success "test with output" "echo foo"
281         test_expect_success "failing test" false
282         test_done
283         EOF
284         check_sub_test_lib_test test-verbose-only-2 <<-\EOF
285         > ok 1 - passing test
286         > Z
287         > expecting success: echo foo
288         > foo
289         > ok 2 - test with output
290         > Z
291         > not ok 3 - failing test
292         > #     false
293         > # failed 1 among 3 test(s)
294         > 1..3
295         EOF
296 '
297
298 test_expect_success 'GIT_SKIP_TESTS' "
299         (
300                 GIT_SKIP_TESTS='git.2' && export GIT_SKIP_TESTS &&
301                 run_sub_test_lib_test git-skip-tests-basic \
302                         'GIT_SKIP_TESTS' <<-\\EOF &&
303                 for i in 1 2 3
304                 do
305                         test_expect_success \"passing test #\$i\" 'true'
306                 done
307                 test_done
308                 EOF
309                 check_sub_test_lib_test git-skip-tests-basic <<-\\EOF
310                 > ok 1 - passing test #1
311                 > ok 2 # skip passing test #2 (GIT_SKIP_TESTS)
312                 > ok 3 - passing test #3
313                 > # passed all 3 test(s)
314                 > 1..3
315                 EOF
316         )
317 "
318
319 test_expect_success 'GIT_SKIP_TESTS several tests' "
320         (
321                 GIT_SKIP_TESTS='git.2 git.5' && export GIT_SKIP_TESTS &&
322                 run_sub_test_lib_test git-skip-tests-several \
323                         'GIT_SKIP_TESTS several tests' <<-\\EOF &&
324                 for i in 1 2 3 4 5 6
325                 do
326                         test_expect_success \"passing test #\$i\" 'true'
327                 done
328                 test_done
329                 EOF
330                 check_sub_test_lib_test git-skip-tests-several <<-\\EOF
331                 > ok 1 - passing test #1
332                 > ok 2 # skip passing test #2 (GIT_SKIP_TESTS)
333                 > ok 3 - passing test #3
334                 > ok 4 - passing test #4
335                 > ok 5 # skip passing test #5 (GIT_SKIP_TESTS)
336                 > ok 6 - passing test #6
337                 > # passed all 6 test(s)
338                 > 1..6
339                 EOF
340         )
341 "
342
343 test_expect_success 'GIT_SKIP_TESTS sh pattern' "
344         (
345                 GIT_SKIP_TESTS='git.[2-5]' && export GIT_SKIP_TESTS &&
346                 run_sub_test_lib_test git-skip-tests-sh-pattern \
347                         'GIT_SKIP_TESTS sh pattern' <<-\\EOF &&
348                 for i in 1 2 3 4 5 6
349                 do
350                         test_expect_success \"passing test #\$i\" 'true'
351                 done
352                 test_done
353                 EOF
354                 check_sub_test_lib_test git-skip-tests-sh-pattern <<-\\EOF
355                 > ok 1 - passing test #1
356                 > ok 2 # skip passing test #2 (GIT_SKIP_TESTS)
357                 > ok 3 # skip passing test #3 (GIT_SKIP_TESTS)
358                 > ok 4 # skip passing test #4 (GIT_SKIP_TESTS)
359                 > ok 5 # skip passing test #5 (GIT_SKIP_TESTS)
360                 > ok 6 - passing test #6
361                 > # passed all 6 test(s)
362                 > 1..6
363                 EOF
364         )
365 "
366
367 test_expect_success '--run basic' "
368         run_sub_test_lib_test run-basic \
369                 '--run basic' --run='1 3 5' <<-\\EOF &&
370         for i in 1 2 3 4 5 6
371         do
372                 test_expect_success \"passing test #\$i\" 'true'
373         done
374         test_done
375         EOF
376         check_sub_test_lib_test run-basic <<-\\EOF
377         > ok 1 - passing test #1
378         > ok 2 # skip passing test #2 (--run)
379         > ok 3 - passing test #3
380         > ok 4 # skip passing test #4 (--run)
381         > ok 5 - passing test #5
382         > ok 6 # skip passing test #6 (--run)
383         > # passed all 6 test(s)
384         > 1..6
385         EOF
386 "
387
388 test_expect_success '--run with a range' "
389         run_sub_test_lib_test run-range \
390                 '--run with a range' --run='1-3' <<-\\EOF &&
391         for i in 1 2 3 4 5 6
392         do
393                 test_expect_success \"passing test #\$i\" 'true'
394         done
395         test_done
396         EOF
397         check_sub_test_lib_test run-range <<-\\EOF
398         > ok 1 - passing test #1
399         > ok 2 - passing test #2
400         > ok 3 - passing test #3
401         > ok 4 # skip passing test #4 (--run)
402         > ok 5 # skip passing test #5 (--run)
403         > ok 6 # skip passing test #6 (--run)
404         > # passed all 6 test(s)
405         > 1..6
406         EOF
407 "
408
409 test_expect_success '--run with two ranges' "
410         run_sub_test_lib_test run-two-ranges \
411                 '--run with two ranges' --run='1-2 5-6' <<-\\EOF &&
412         for i in 1 2 3 4 5 6
413         do
414                 test_expect_success \"passing test #\$i\" 'true'
415         done
416         test_done
417         EOF
418         check_sub_test_lib_test run-two-ranges <<-\\EOF
419         > ok 1 - passing test #1
420         > ok 2 - passing test #2
421         > ok 3 # skip passing test #3 (--run)
422         > ok 4 # skip passing test #4 (--run)
423         > ok 5 - passing test #5
424         > ok 6 - passing test #6
425         > # passed all 6 test(s)
426         > 1..6
427         EOF
428 "
429
430 test_expect_success '--run with a left open range' "
431         run_sub_test_lib_test run-left-open-range \
432                 '--run with a left open range' --run='-3' <<-\\EOF &&
433         for i in 1 2 3 4 5 6
434         do
435                 test_expect_success \"passing test #\$i\" 'true'
436         done
437         test_done
438         EOF
439         check_sub_test_lib_test run-left-open-range <<-\\EOF
440         > ok 1 - passing test #1
441         > ok 2 - passing test #2
442         > ok 3 - passing test #3
443         > ok 4 # skip passing test #4 (--run)
444         > ok 5 # skip passing test #5 (--run)
445         > ok 6 # skip passing test #6 (--run)
446         > # passed all 6 test(s)
447         > 1..6
448         EOF
449 "
450
451 test_expect_success '--run with a right open range' "
452         run_sub_test_lib_test run-right-open-range \
453                 '--run with a right open range' --run='4-' <<-\\EOF &&
454         for i in 1 2 3 4 5 6
455         do
456                 test_expect_success \"passing test #\$i\" 'true'
457         done
458         test_done
459         EOF
460         check_sub_test_lib_test run-right-open-range <<-\\EOF
461         > ok 1 # skip passing test #1 (--run)
462         > ok 2 # skip passing test #2 (--run)
463         > ok 3 # skip passing test #3 (--run)
464         > ok 4 - passing test #4
465         > ok 5 - passing test #5
466         > ok 6 - passing test #6
467         > # passed all 6 test(s)
468         > 1..6
469         EOF
470 "
471
472 test_expect_success '--run with basic negation' "
473         run_sub_test_lib_test run-basic-neg \
474                 '--run with basic negation' --run='"'!3'"' <<-\\EOF &&
475         for i in 1 2 3 4 5 6
476         do
477                 test_expect_success \"passing test #\$i\" 'true'
478         done
479         test_done
480         EOF
481         check_sub_test_lib_test run-basic-neg <<-\\EOF
482         > ok 1 - passing test #1
483         > ok 2 - passing test #2
484         > ok 3 # skip passing test #3 (--run)
485         > ok 4 - passing test #4
486         > ok 5 - passing test #5
487         > ok 6 - passing test #6
488         > # passed all 6 test(s)
489         > 1..6
490         EOF
491 "
492
493 test_expect_success '--run with two negations' "
494         run_sub_test_lib_test run-two-neg \
495                 '--run with two negations' --run='"'!3 !6'"' <<-\\EOF &&
496         for i in 1 2 3 4 5 6
497         do
498                 test_expect_success \"passing test #\$i\" 'true'
499         done
500         test_done
501         EOF
502         check_sub_test_lib_test run-two-neg <<-\\EOF
503         > ok 1 - passing test #1
504         > ok 2 - passing test #2
505         > ok 3 # skip passing test #3 (--run)
506         > ok 4 - passing test #4
507         > ok 5 - passing test #5
508         > ok 6 # skip passing test #6 (--run)
509         > # passed all 6 test(s)
510         > 1..6
511         EOF
512 "
513
514 test_expect_success '--run a range and negation' "
515         run_sub_test_lib_test run-range-and-neg \
516                 '--run a range and negation' --run='"'-4 !2'"' <<-\\EOF &&
517         for i in 1 2 3 4 5 6
518         do
519                 test_expect_success \"passing test #\$i\" 'true'
520         done
521         test_done
522         EOF
523         check_sub_test_lib_test run-range-and-neg <<-\\EOF
524         > ok 1 - passing test #1
525         > ok 2 # skip passing test #2 (--run)
526         > ok 3 - passing test #3
527         > ok 4 - passing test #4
528         > ok 5 # skip passing test #5 (--run)
529         > ok 6 # skip passing test #6 (--run)
530         > # passed all 6 test(s)
531         > 1..6
532         EOF
533 "
534
535 test_expect_success '--run range negation' "
536         run_sub_test_lib_test run-range-neg \
537                 '--run range negation' --run='"'!1-3'"' <<-\\EOF &&
538         for i in 1 2 3 4 5 6
539         do
540                 test_expect_success \"passing test #\$i\" 'true'
541         done
542         test_done
543         EOF
544         check_sub_test_lib_test run-range-neg <<-\\EOF
545         > ok 1 # skip passing test #1 (--run)
546         > ok 2 # skip passing test #2 (--run)
547         > ok 3 # skip passing test #3 (--run)
548         > ok 4 - passing test #4
549         > ok 5 - passing test #5
550         > ok 6 - passing test #6
551         > # passed all 6 test(s)
552         > 1..6
553         EOF
554 "
555
556 test_expect_success '--run include, exclude and include' "
557         run_sub_test_lib_test run-inc-neg-inc \
558                 '--run include, exclude and include' \
559                 --run='"'1-5 !1-3 2'"' <<-\\EOF &&
560         for i in 1 2 3 4 5 6
561         do
562                 test_expect_success \"passing test #\$i\" 'true'
563         done
564         test_done
565         EOF
566         check_sub_test_lib_test run-inc-neg-inc <<-\\EOF
567         > ok 1 # skip passing test #1 (--run)
568         > ok 2 - passing test #2
569         > ok 3 # skip passing test #3 (--run)
570         > ok 4 - passing test #4
571         > ok 5 - passing test #5
572         > ok 6 # skip passing test #6 (--run)
573         > # passed all 6 test(s)
574         > 1..6
575         EOF
576 "
577
578 test_expect_success '--run include, exclude and include, comma separated' "
579         run_sub_test_lib_test run-inc-neg-inc-comma \
580                 '--run include, exclude and include, comma separated' \
581                 --run=1-5,\!1-3,2 <<-\\EOF &&
582         for i in 1 2 3 4 5 6
583         do
584                 test_expect_success \"passing test #\$i\" 'true'
585         done
586         test_done
587         EOF
588         check_sub_test_lib_test run-inc-neg-inc-comma <<-\\EOF
589         > ok 1 # skip passing test #1 (--run)
590         > ok 2 - passing test #2
591         > ok 3 # skip passing test #3 (--run)
592         > ok 4 - passing test #4
593         > ok 5 - passing test #5
594         > ok 6 # skip passing test #6 (--run)
595         > # passed all 6 test(s)
596         > 1..6
597         EOF
598 "
599
600 test_expect_success '--run exclude and include' "
601         run_sub_test_lib_test run-neg-inc \
602                 '--run exclude and include' \
603                 --run='"'!3- 5'"' <<-\\EOF &&
604         for i in 1 2 3 4 5 6
605         do
606                 test_expect_success \"passing test #\$i\" 'true'
607         done
608         test_done
609         EOF
610         check_sub_test_lib_test run-neg-inc <<-\\EOF
611         > ok 1 - passing test #1
612         > ok 2 - passing test #2
613         > ok 3 # skip passing test #3 (--run)
614         > ok 4 # skip passing test #4 (--run)
615         > ok 5 - passing test #5
616         > ok 6 # skip passing test #6 (--run)
617         > # passed all 6 test(s)
618         > 1..6
619         EOF
620 "
621
622 test_expect_success '--run empty selectors' "
623         run_sub_test_lib_test run-empty-sel \
624                 '--run empty selectors' \
625                 --run='1,,3,,,5' <<-\\EOF &&
626         for i in 1 2 3 4 5 6
627         do
628                 test_expect_success \"passing test #\$i\" 'true'
629         done
630         test_done
631         EOF
632         check_sub_test_lib_test run-empty-sel <<-\\EOF
633         > ok 1 - passing test #1
634         > ok 2 # skip passing test #2 (--run)
635         > ok 3 - passing test #3
636         > ok 4 # skip passing test #4 (--run)
637         > ok 5 - passing test #5
638         > ok 6 # skip passing test #6 (--run)
639         > # passed all 6 test(s)
640         > 1..6
641         EOF
642 "
643
644 test_expect_success '--run invalid range start' "
645         run_sub_test_lib_test_err run-inv-range-start \
646                 '--run invalid range start' \
647                 --run='a-5' <<-\\EOF &&
648         test_expect_success \"passing test #1\" 'true'
649         test_done
650         EOF
651         check_sub_test_lib_test_err run-inv-range-start \
652                 <<-\\EOF_OUT 3<<-\\EOF_ERR
653         > FATAL: Unexpected exit with code 1
654         EOF_OUT
655         > error: --run: invalid non-numeric in range start: 'a-5'
656         EOF_ERR
657 "
658
659 test_expect_success '--run invalid range end' "
660         run_sub_test_lib_test_err run-inv-range-end \
661                 '--run invalid range end' \
662                 --run='1-z' <<-\\EOF &&
663         test_expect_success \"passing test #1\" 'true'
664         test_done
665         EOF
666         check_sub_test_lib_test_err run-inv-range-end \
667                 <<-\\EOF_OUT 3<<-\\EOF_ERR
668         > FATAL: Unexpected exit with code 1
669         EOF_OUT
670         > error: --run: invalid non-numeric in range end: '1-z'
671         EOF_ERR
672 "
673
674 test_expect_success '--run invalid selector' "
675         run_sub_test_lib_test_err run-inv-selector \
676                 '--run invalid selector' \
677                 --run='1?' <<-\\EOF &&
678         test_expect_success \"passing test #1\" 'true'
679         test_done
680         EOF
681         check_sub_test_lib_test_err run-inv-selector \
682                 <<-\\EOF_OUT 3<<-\\EOF_ERR
683         > FATAL: Unexpected exit with code 1
684         EOF_OUT
685         > error: --run: invalid non-numeric in test selector: '1?'
686         EOF_ERR
687 "
688
689
690 test_set_prereq HAVEIT
691 haveit=no
692 test_expect_success HAVEIT 'test runs if prerequisite is satisfied' '
693         test_have_prereq HAVEIT &&
694         haveit=yes
695 '
696 donthaveit=yes
697 test_expect_success DONTHAVEIT 'unmet prerequisite causes test to be skipped' '
698         donthaveit=no
699 '
700 if test $haveit$donthaveit != yesyes
701 then
702         say "bug in test framework: prerequisite tags do not work reliably"
703         exit 1
704 fi
705
706 test_set_prereq HAVETHIS
707 haveit=no
708 test_expect_success HAVETHIS,HAVEIT 'test runs if prerequisites are satisfied' '
709         test_have_prereq HAVEIT &&
710         test_have_prereq HAVETHIS &&
711         haveit=yes
712 '
713 donthaveit=yes
714 test_expect_success HAVEIT,DONTHAVEIT 'unmet prerequisites causes test to be skipped' '
715         donthaveit=no
716 '
717 donthaveiteither=yes
718 test_expect_success DONTHAVEIT,HAVEIT 'unmet prerequisites causes test to be skipped' '
719         donthaveiteither=no
720 '
721 if test $haveit$donthaveit$donthaveiteither != yesyesyes
722 then
723         say "bug in test framework: multiple prerequisite tags do not work reliably"
724         exit 1
725 fi
726
727 test_lazy_prereq LAZY_TRUE true
728 havetrue=no
729 test_expect_success LAZY_TRUE 'test runs if lazy prereq is satisfied' '
730         havetrue=yes
731 '
732 donthavetrue=yes
733 test_expect_success !LAZY_TRUE 'missing lazy prereqs skip tests' '
734         donthavetrue=no
735 '
736
737 if test "$havetrue$donthavetrue" != yesyes
738 then
739         say 'bug in test framework: lazy prerequisites do not work'
740         exit 1
741 fi
742
743 test_lazy_prereq LAZY_FALSE false
744 nothavefalse=no
745 test_expect_success !LAZY_FALSE 'negative lazy prereqs checked' '
746         nothavefalse=yes
747 '
748 havefalse=yes
749 test_expect_success LAZY_FALSE 'missing negative lazy prereqs will skip' '
750         havefalse=no
751 '
752
753 if test "$nothavefalse$havefalse" != yesyes
754 then
755         say 'bug in test framework: negative lazy prerequisites do not work'
756         exit 1
757 fi
758
759 clean=no
760 test_expect_success 'tests clean up after themselves' '
761         test_when_finished clean=yes
762 '
763
764 if test $clean != yes
765 then
766         say "bug in test framework: basic cleanup command does not work reliably"
767         exit 1
768 fi
769
770 test_expect_success 'tests clean up even on failures' "
771         test_must_fail run_sub_test_lib_test \
772                 failing-cleanup 'Failing tests with cleanup commands' <<-\\EOF &&
773         test_expect_success 'tests clean up even after a failure' '
774                 touch clean-after-failure &&
775                 test_when_finished rm clean-after-failure &&
776                 (exit 1)
777         '
778         test_expect_success 'failure to clean up causes the test to fail' '
779                 test_when_finished \"(exit 2)\"
780         '
781         test_done
782         EOF
783         check_sub_test_lib_test failing-cleanup <<-\\EOF
784         > not ok 1 - tests clean up even after a failure
785         > #     Z
786         > #     touch clean-after-failure &&
787         > #     test_when_finished rm clean-after-failure &&
788         > #     (exit 1)
789         > #     Z
790         > not ok 2 - failure to clean up causes the test to fail
791         > #     Z
792         > #     test_when_finished \"(exit 2)\"
793         > #     Z
794         > # failed 2 among 2 test(s)
795         > 1..2
796         EOF
797 "
798
799 ################################################################
800 # Basics of the basics
801
802 # updating a new file without --add should fail.
803 test_expect_success 'git update-index without --add should fail adding' '
804         test_must_fail git update-index should-be-empty
805 '
806
807 # and with --add it should succeed, even if it is empty (it used to fail).
808 test_expect_success 'git update-index with --add should succeed' '
809         git update-index --add should-be-empty
810 '
811
812 test_expect_success 'writing tree out with git write-tree' '
813         tree=$(git write-tree)
814 '
815
816 # we know the shape and contents of the tree and know the object ID for it.
817 test_expect_success 'validate object ID of a known tree' '
818         test "$tree" = 7bb943559a305bdd6bdee2cef6e5df2413c3d30a
819     '
820
821 # Removing paths.
822 test_expect_success 'git update-index without --remove should fail removing' '
823         rm -f should-be-empty full-of-directories &&
824         test_must_fail git update-index should-be-empty
825 '
826
827 test_expect_success 'git update-index with --remove should be able to remove' '
828         git update-index --remove should-be-empty
829 '
830
831 # Empty tree can be written with recent write-tree.
832 test_expect_success 'git write-tree should be able to write an empty tree' '
833         tree=$(git write-tree)
834 '
835
836 test_expect_success 'validate object ID of a known tree' '
837         test "$tree" = 4b825dc642cb6eb9a060e54bf8d69288fbee4904
838 '
839
840 # Various types of objects
841
842 test_expect_success 'adding various types of objects with git update-index --add' '
843         mkdir path2 path3 path3/subp3 &&
844         paths="path0 path2/file2 path3/file3 path3/subp3/file3" &&
845         (
846                 for p in $paths
847                 do
848                         echo "hello $p" >$p || exit 1
849                         test_ln_s_add "hello $p" ${p}sym || exit 1
850                 done
851         ) &&
852         find path* ! -type d -print | xargs git update-index --add
853 '
854
855 # Show them and see that matches what we expect.
856 test_expect_success 'showing stage with git ls-files --stage' '
857         git ls-files --stage >current
858 '
859
860 test_expect_success 'validate git ls-files output for a known tree' '
861         cat >expected <<-\EOF &&
862         100644 f87290f8eb2cbbea7857214459a0739927eab154 0       path0
863         120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0       path0sym
864         100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0       path2/file2
865         120000 d8ce161addc5173867a3c3c730924388daedbc38 0       path2/file2sym
866         100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0       path3/file3
867         120000 8599103969b43aff7e430efea79ca4636466794f 0       path3/file3sym
868         100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0       path3/subp3/file3
869         120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0       path3/subp3/file3sym
870         EOF
871         test_cmp expected current
872 '
873
874 test_expect_success 'writing tree out with git write-tree' '
875         tree=$(git write-tree)
876 '
877
878 test_expect_success 'validate object ID for a known tree' '
879         test "$tree" = 087704a96baf1c2d1c869a8b084481e121c88b5b
880 '
881
882 test_expect_success 'showing tree with git ls-tree' '
883     git ls-tree $tree >current
884 '
885
886 test_expect_success 'git ls-tree output for a known tree' '
887         cat >expected <<-\EOF &&
888         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
889         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
890         040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
891         040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
892         EOF
893         test_cmp expected current
894 '
895
896 # This changed in ls-tree pathspec change -- recursive does
897 # not show tree nodes anymore.
898 test_expect_success 'showing tree with git ls-tree -r' '
899         git ls-tree -r $tree >current
900 '
901
902 test_expect_success 'git ls-tree -r output for a known tree' '
903         cat >expected <<-\EOF &&
904         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
905         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
906         100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
907         120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
908         100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
909         120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
910         100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
911         120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
912         EOF
913         test_cmp expected current
914 '
915
916 # But with -r -t we can have both.
917 test_expect_success 'showing tree with git ls-tree -r -t' '
918         git ls-tree -r -t $tree >current
919 '
920
921 test_expect_success 'git ls-tree -r output for a known tree' '
922         cat >expected <<-\EOF &&
923         100644 blob f87290f8eb2cbbea7857214459a0739927eab154    path0
924         120000 blob 15a98433ae33114b085f3eb3bb03b832b3180a01    path0sym
925         040000 tree 58a09c23e2ca152193f2786e06986b7b6712bdbe    path2
926         100644 blob 3feff949ed00a62d9f7af97c15cd8a30595e7ac7    path2/file2
927         120000 blob d8ce161addc5173867a3c3c730924388daedbc38    path2/file2sym
928         040000 tree 21ae8269cacbe57ae09138dcc3a2887f904d02b3    path3
929         100644 blob 0aa34cae68d0878578ad119c86ca2b5ed5b28376    path3/file3
930         120000 blob 8599103969b43aff7e430efea79ca4636466794f    path3/file3sym
931         040000 tree 3c5e5399f3a333eddecce7a9b9465b63f65f51e2    path3/subp3
932         100644 blob 00fb5908cb97c2564a9783c0c64087333b3b464f    path3/subp3/file3
933         120000 blob 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c    path3/subp3/file3sym
934         EOF
935         test_cmp expected current
936 '
937
938 test_expect_success 'writing partial tree out with git write-tree --prefix' '
939         ptree=$(git write-tree --prefix=path3)
940 '
941
942 test_expect_success 'validate object ID for a known tree' '
943         test "$ptree" = 21ae8269cacbe57ae09138dcc3a2887f904d02b3
944 '
945
946 test_expect_success 'writing partial tree out with git write-tree --prefix' '
947         ptree=$(git write-tree --prefix=path3/subp3)
948 '
949
950 test_expect_success 'validate object ID for a known tree' '
951         test "$ptree" = 3c5e5399f3a333eddecce7a9b9465b63f65f51e2
952 '
953
954 test_expect_success 'put invalid objects into the index' '
955         rm -f .git/index &&
956         cat >badobjects <<-\EOF &&
957         100644 blob 1000000000000000000000000000000000000000    dir/file1
958         100644 blob 2000000000000000000000000000000000000000    dir/file2
959         100644 blob 3000000000000000000000000000000000000000    dir/file3
960         100644 blob 4000000000000000000000000000000000000000    dir/file4
961         100644 blob 5000000000000000000000000000000000000000    dir/file5
962         EOF
963         git update-index --index-info <badobjects
964 '
965
966 test_expect_success 'writing this tree without --missing-ok' '
967         test_must_fail git write-tree
968 '
969
970 test_expect_success 'writing this tree with --missing-ok' '
971         git write-tree --missing-ok
972 '
973
974
975 ################################################################
976 test_expect_success 'git read-tree followed by write-tree should be idempotent' '
977         rm -f .git/index &&
978         git read-tree $tree &&
979         test -f .git/index &&
980         newtree=$(git write-tree) &&
981         test "$newtree" = "$tree"
982 '
983
984 test_expect_success 'validate git diff-files output for a know cache/work tree state' '
985         cat >expected <<\EOF &&
986 :100644 100644 f87290f8eb2cbbea7857214459a0739927eab154 0000000000000000000000000000000000000000 M      path0
987 :120000 120000 15a98433ae33114b085f3eb3bb03b832b3180a01 0000000000000000000000000000000000000000 M      path0sym
988 :100644 100644 3feff949ed00a62d9f7af97c15cd8a30595e7ac7 0000000000000000000000000000000000000000 M      path2/file2
989 :120000 120000 d8ce161addc5173867a3c3c730924388daedbc38 0000000000000000000000000000000000000000 M      path2/file2sym
990 :100644 100644 0aa34cae68d0878578ad119c86ca2b5ed5b28376 0000000000000000000000000000000000000000 M      path3/file3
991 :120000 120000 8599103969b43aff7e430efea79ca4636466794f 0000000000000000000000000000000000000000 M      path3/file3sym
992 :100644 100644 00fb5908cb97c2564a9783c0c64087333b3b464f 0000000000000000000000000000000000000000 M      path3/subp3/file3
993 :120000 120000 6649a1ebe9e9f1c553b66f5a6e74136a07ccc57c 0000000000000000000000000000000000000000 M      path3/subp3/file3sym
994 EOF
995         git diff-files >current &&
996         test_cmp current expected
997 '
998
999 test_expect_success 'git update-index --refresh should succeed' '
1000         git update-index --refresh
1001 '
1002
1003 test_expect_success 'no diff after checkout and git update-index --refresh' '
1004         git diff-files >current &&
1005         cmp -s current /dev/null
1006 '
1007
1008 ################################################################
1009 P=087704a96baf1c2d1c869a8b084481e121c88b5b
1010
1011 test_expect_success 'git commit-tree records the correct tree in a commit' '
1012         commit0=$(echo NO | git commit-tree $P) &&
1013         tree=$(git show --pretty=raw $commit0 |
1014                  sed -n -e "s/^tree //p" -e "/^author /q") &&
1015         test "z$tree" = "z$P"
1016 '
1017
1018 test_expect_success 'git commit-tree records the correct parent in a commit' '
1019         commit1=$(echo NO | git commit-tree $P -p $commit0) &&
1020         parent=$(git show --pretty=raw $commit1 |
1021                 sed -n -e "s/^parent //p" -e "/^author /q") &&
1022         test "z$commit0" = "z$parent"
1023 '
1024
1025 test_expect_success 'git commit-tree omits duplicated parent in a commit' '
1026         commit2=$(echo NO | git commit-tree $P -p $commit0 -p $commit0) &&
1027              parent=$(git show --pretty=raw $commit2 |
1028                 sed -n -e "s/^parent //p" -e "/^author /q" |
1029                 sort -u) &&
1030         test "z$commit0" = "z$parent" &&
1031         numparent=$(git show --pretty=raw $commit2 |
1032                 sed -n -e "s/^parent //p" -e "/^author /q" |
1033                 wc -l) &&
1034         test $numparent = 1
1035 '
1036
1037 test_expect_success 'update-index D/F conflict' '
1038         mv path0 tmp &&
1039         mv path2 path0 &&
1040         mv tmp path2 &&
1041         git update-index --add --replace path2 path0/file2 &&
1042         numpath0=$(git ls-files path0 | wc -l) &&
1043         test $numpath0 = 1
1044 '
1045
1046 test_expect_success 'very long name in the index handled sanely' '
1047
1048         a=a && # 1
1049         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 16
1050         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 256
1051         a=$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a && # 4096
1052         a=${a}q &&
1053
1054         >path4 &&
1055         git update-index --add path4 &&
1056         (
1057                 git ls-files -s path4 |
1058                 sed -e "s/      .*/     /" |
1059                 tr -d "\012"
1060                 echo "$a"
1061         ) | git update-index --index-info &&
1062         len=$(git ls-files "a*" | wc -c) &&
1063         test $len = 4098
1064 '
1065
1066 test_done