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