Merge branch 'sb/submodule-update-initial-runs-custom-script'
[git] / t / t6030-bisect-porcelain.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2007 Christian Couder
4 #
5 test_description='Tests git bisect functionality'
6
7 exec </dev/null
8
9 . ./test-lib.sh
10
11 add_line_into_file()
12 {
13     _line=$1
14     _file=$2
15
16     if [ -f "$_file" ]; then
17         echo "$_line" >> $_file || return $?
18         MSG="Add <$_line> into <$_file>."
19     else
20         echo "$_line" > $_file || return $?
21         git add $_file || return $?
22         MSG="Create file <$_file> with <$_line> inside."
23     fi
24
25     test_tick
26     git commit --quiet -m "$MSG" $_file
27 }
28
29 HASH1=
30 HASH2=
31 HASH3=
32 HASH4=
33
34 test_expect_success 'set up basic repo with 1 file (hello) and 4 commits' '
35      add_line_into_file "1: Hello World" hello &&
36      HASH1=$(git rev-parse --verify HEAD) &&
37      add_line_into_file "2: A new day for git" hello &&
38      HASH2=$(git rev-parse --verify HEAD) &&
39      add_line_into_file "3: Another new day for git" hello &&
40      HASH3=$(git rev-parse --verify HEAD) &&
41      add_line_into_file "4: Ciao for now" hello &&
42      HASH4=$(git rev-parse --verify HEAD)
43 '
44
45 test_expect_success 'bisect starts with only one bad' '
46         git bisect reset &&
47         git bisect start &&
48         git bisect bad $HASH4 &&
49         git bisect next
50 '
51
52 test_expect_success 'bisect does not start with only one good' '
53         git bisect reset &&
54         git bisect start &&
55         git bisect good $HASH1 &&
56         test_must_fail git bisect next
57 '
58
59 test_expect_success 'bisect start with one bad and good' '
60         git bisect reset &&
61         git bisect start &&
62         git bisect good $HASH1 &&
63         git bisect bad $HASH4 &&
64         git bisect next
65 '
66
67 test_expect_success 'bisect fails if given any junk instead of revs' '
68         git bisect reset &&
69         test_must_fail git bisect start foo $HASH1 -- &&
70         test_must_fail git bisect start $HASH4 $HASH1 bar -- &&
71         test -z "$(git for-each-ref "refs/bisect/*")" &&
72         test -z "$(ls .git/BISECT_* 2>/dev/null)" &&
73         git bisect start &&
74         test_must_fail git bisect good foo $HASH1 &&
75         test_must_fail git bisect good $HASH1 bar &&
76         test_must_fail git bisect bad frotz &&
77         test_must_fail git bisect bad $HASH3 $HASH4 &&
78         test_must_fail git bisect skip bar $HASH3 &&
79         test_must_fail git bisect skip $HASH1 foo &&
80         test -z "$(git for-each-ref "refs/bisect/*")" &&
81         git bisect good $HASH1 &&
82         git bisect bad $HASH4
83 '
84
85 test_expect_success 'bisect reset: back in the master branch' '
86         git bisect reset &&
87         echo "* master" > branch.expect &&
88         git branch > branch.output &&
89         cmp branch.expect branch.output
90 '
91
92 test_expect_success 'bisect reset: back in another branch' '
93         git checkout -b other &&
94         git bisect start &&
95         git bisect good $HASH1 &&
96         git bisect bad $HASH3 &&
97         git bisect reset &&
98         echo "  master" > branch.expect &&
99         echo "* other" >> branch.expect &&
100         git branch > branch.output &&
101         cmp branch.expect branch.output
102 '
103
104 test_expect_success 'bisect reset when not bisecting' '
105         git bisect reset &&
106         git branch > branch.output &&
107         cmp branch.expect branch.output
108 '
109
110 test_expect_success 'bisect reset removes packed refs' '
111         git bisect reset &&
112         git bisect start &&
113         git bisect good $HASH1 &&
114         git bisect bad $HASH3 &&
115         git pack-refs --all --prune &&
116         git bisect next &&
117         git bisect reset &&
118         test -z "$(git for-each-ref "refs/bisect/*")" &&
119         test -z "$(git for-each-ref "refs/heads/bisect")"
120 '
121
122 test_expect_success 'bisect reset removes bisect state after --no-checkout' '
123         git bisect reset &&
124         git bisect start --no-checkout &&
125         git bisect good $HASH1 &&
126         git bisect bad $HASH3 &&
127         git bisect next &&
128         git bisect reset &&
129         test -z "$(git for-each-ref "refs/bisect/*")" &&
130         test -z "$(git for-each-ref "refs/heads/bisect")" &&
131         test -z "$(git for-each-ref "BISECT_HEAD")"
132 '
133
134 test_expect_success 'bisect start: back in good branch' '
135         git branch > branch.output &&
136         grep "* other" branch.output > /dev/null &&
137         git bisect start $HASH4 $HASH1 -- &&
138         git bisect good &&
139         git bisect start $HASH4 $HASH1 -- &&
140         git bisect bad &&
141         git bisect reset &&
142         git branch > branch.output &&
143         grep "* other" branch.output > /dev/null
144 '
145
146 test_expect_success 'bisect start: no ".git/BISECT_START" created if junk rev' '
147         git bisect reset &&
148         test_must_fail git bisect start $HASH4 foo -- &&
149         git branch > branch.output &&
150         grep "* other" branch.output > /dev/null &&
151         test_must_fail test -e .git/BISECT_START
152 '
153
154 test_expect_success 'bisect start: existing ".git/BISECT_START" not modified if junk rev' '
155         git bisect start $HASH4 $HASH1 -- &&
156         git bisect good &&
157         cp .git/BISECT_START saved &&
158         test_must_fail git bisect start $HASH4 foo -- &&
159         git branch > branch.output &&
160         test_i18ngrep "* (no branch, bisect started on other)" branch.output > /dev/null &&
161         test_cmp saved .git/BISECT_START
162 '
163 test_expect_success 'bisect start: no ".git/BISECT_START" if mistaken rev' '
164         git bisect start $HASH4 $HASH1 -- &&
165         git bisect good &&
166         test_must_fail git bisect start $HASH1 $HASH4 -- &&
167         git branch > branch.output &&
168         grep "* other" branch.output > /dev/null &&
169         test_must_fail test -e .git/BISECT_START
170 '
171
172 test_expect_success 'bisect start: no ".git/BISECT_START" if checkout error' '
173         echo "temp stuff" > hello &&
174         test_must_fail git bisect start $HASH4 $HASH1 -- &&
175         git branch &&
176         git branch > branch.output &&
177         grep "* other" branch.output > /dev/null &&
178         test_must_fail test -e .git/BISECT_START &&
179         test -z "$(git for-each-ref "refs/bisect/*")" &&
180         git checkout HEAD hello
181 '
182
183 # $HASH1 is good, $HASH4 is bad, we skip $HASH3
184 # but $HASH2 is bad,
185 # so we should find $HASH2 as the first bad commit
186 test_expect_success 'bisect skip: successful result' '
187         test_when_finished git bisect reset &&
188         git bisect reset &&
189         git bisect start $HASH4 $HASH1 &&
190         git bisect skip &&
191         git bisect bad > my_bisect_log.txt &&
192         grep "$HASH2 is the first bad commit" my_bisect_log.txt
193 '
194
195 # $HASH1 is good, $HASH4 is bad, we skip $HASH3 and $HASH2
196 # so we should not be able to tell the first bad commit
197 # among $HASH2, $HASH3 and $HASH4
198 test_expect_success 'bisect skip: cannot tell between 3 commits' '
199         test_when_finished git bisect reset &&
200         git bisect start $HASH4 $HASH1 &&
201         git bisect skip &&
202         test_expect_code 2 git bisect skip >my_bisect_log.txt &&
203         grep "first bad commit could be any of" my_bisect_log.txt &&
204         ! grep $HASH1 my_bisect_log.txt &&
205         grep $HASH2 my_bisect_log.txt &&
206         grep $HASH3 my_bisect_log.txt &&
207         grep $HASH4 my_bisect_log.txt
208 '
209
210 # $HASH1 is good, $HASH4 is bad, we skip $HASH3
211 # but $HASH2 is good,
212 # so we should not be able to tell the first bad commit
213 # among $HASH3 and $HASH4
214 test_expect_success 'bisect skip: cannot tell between 2 commits' '
215         test_when_finished git bisect reset &&
216         git bisect start $HASH4 $HASH1 &&
217         git bisect skip &&
218         test_expect_code 2 git bisect good >my_bisect_log.txt &&
219         grep "first bad commit could be any of" my_bisect_log.txt &&
220         ! grep $HASH1 my_bisect_log.txt &&
221         ! grep $HASH2 my_bisect_log.txt &&
222         grep $HASH3 my_bisect_log.txt &&
223         grep $HASH4 my_bisect_log.txt
224 '
225
226 # $HASH1 is good, $HASH4 is both skipped and bad, we skip $HASH3
227 # and $HASH2 is good,
228 # so we should not be able to tell the first bad commit
229 # among $HASH3 and $HASH4
230 test_expect_success 'bisect skip: with commit both bad and skipped' '
231         test_when_finished git bisect reset &&
232         git bisect start &&
233         git bisect skip &&
234         git bisect bad &&
235         git bisect good $HASH1 &&
236         git bisect skip &&
237         test_expect_code 2 git bisect good >my_bisect_log.txt &&
238         grep "first bad commit could be any of" my_bisect_log.txt &&
239         ! grep $HASH1 my_bisect_log.txt &&
240         ! grep $HASH2 my_bisect_log.txt &&
241         grep $HASH3 my_bisect_log.txt &&
242         grep $HASH4 my_bisect_log.txt
243 '
244
245 # We want to automatically find the commit that
246 # introduced "Another" into hello.
247 test_expect_success \
248     '"git bisect run" simple case' \
249     'echo "#"\!"/bin/sh" > test_script.sh &&
250      echo "grep Another hello > /dev/null" >> test_script.sh &&
251      echo "test \$? -ne 0" >> test_script.sh &&
252      chmod +x test_script.sh &&
253      git bisect start &&
254      git bisect good $HASH1 &&
255      git bisect bad $HASH4 &&
256      git bisect run ./test_script.sh > my_bisect_log.txt &&
257      grep "$HASH3 is the first bad commit" my_bisect_log.txt &&
258      git bisect reset'
259
260 # We want to automatically find the commit that
261 # introduced "Ciao" into hello.
262 test_expect_success \
263     '"git bisect run" with more complex "git bisect start"' \
264     'echo "#"\!"/bin/sh" > test_script.sh &&
265      echo "grep Ciao hello > /dev/null" >> test_script.sh &&
266      echo "test \$? -ne 0" >> test_script.sh &&
267      chmod +x test_script.sh &&
268      git bisect start $HASH4 $HASH1 &&
269      git bisect run ./test_script.sh > my_bisect_log.txt &&
270      grep "$HASH4 is the first bad commit" my_bisect_log.txt &&
271      git bisect reset'
272
273 # $HASH1 is good, $HASH5 is bad, we skip $HASH3
274 # but $HASH4 is good,
275 # so we should find $HASH5 as the first bad commit
276 HASH5=
277 test_expect_success 'bisect skip: add line and then a new test' '
278         add_line_into_file "5: Another new line." hello &&
279         HASH5=$(git rev-parse --verify HEAD) &&
280         git bisect start $HASH5 $HASH1 &&
281         git bisect skip &&
282         git bisect good > my_bisect_log.txt &&
283         grep "$HASH5 is the first bad commit" my_bisect_log.txt &&
284         git bisect log > log_to_replay.txt &&
285         git bisect reset
286 '
287
288 test_expect_success 'bisect skip and bisect replay' '
289         git bisect replay log_to_replay.txt > my_bisect_log.txt &&
290         grep "$HASH5 is the first bad commit" my_bisect_log.txt &&
291         git bisect reset
292 '
293
294 HASH6=
295 test_expect_success 'bisect run & skip: cannot tell between 2' '
296         add_line_into_file "6: Yet a line." hello &&
297         HASH6=$(git rev-parse --verify HEAD) &&
298         echo "#"\!"/bin/sh" > test_script.sh &&
299         echo "sed -ne \\\$p hello | grep Ciao > /dev/null && exit 125" >> test_script.sh &&
300         echo "grep line hello > /dev/null" >> test_script.sh &&
301         echo "test \$? -ne 0" >> test_script.sh &&
302         chmod +x test_script.sh &&
303         git bisect start $HASH6 $HASH1 &&
304         if git bisect run ./test_script.sh > my_bisect_log.txt
305         then
306                 echo Oops, should have failed.
307                 false
308         else
309                 test $? -eq 2 &&
310                 grep "first bad commit could be any of" my_bisect_log.txt &&
311                 ! grep $HASH3 my_bisect_log.txt &&
312                 ! grep $HASH6 my_bisect_log.txt &&
313                 grep $HASH4 my_bisect_log.txt &&
314                 grep $HASH5 my_bisect_log.txt
315         fi
316 '
317
318 HASH7=
319 test_expect_success 'bisect run & skip: find first bad' '
320         git bisect reset &&
321         add_line_into_file "7: Should be the last line." hello &&
322         HASH7=$(git rev-parse --verify HEAD) &&
323         echo "#"\!"/bin/sh" > test_script.sh &&
324         echo "sed -ne \\\$p hello | grep Ciao > /dev/null && exit 125" >> test_script.sh &&
325         echo "sed -ne \\\$p hello | grep day > /dev/null && exit 125" >> test_script.sh &&
326         echo "grep Yet hello > /dev/null" >> test_script.sh &&
327         echo "test \$? -ne 0" >> test_script.sh &&
328         chmod +x test_script.sh &&
329         git bisect start $HASH7 $HASH1 &&
330         git bisect run ./test_script.sh > my_bisect_log.txt &&
331         grep "$HASH6 is the first bad commit" my_bisect_log.txt
332 '
333
334 test_expect_success 'bisect skip only one range' '
335         git bisect reset &&
336         git bisect start $HASH7 $HASH1 &&
337         git bisect skip $HASH1..$HASH5 &&
338         test "$HASH6" = "$(git rev-parse --verify HEAD)" &&
339         test_must_fail git bisect bad > my_bisect_log.txt &&
340         grep "first bad commit could be any of" my_bisect_log.txt
341 '
342
343 test_expect_success 'bisect skip many ranges' '
344         git bisect start $HASH7 $HASH1 &&
345         test "$HASH4" = "$(git rev-parse --verify HEAD)" &&
346         git bisect skip $HASH2 $HASH2.. ..$HASH5 &&
347         test "$HASH6" = "$(git rev-parse --verify HEAD)" &&
348         test_must_fail git bisect bad > my_bisect_log.txt &&
349         grep "first bad commit could be any of" my_bisect_log.txt
350 '
351
352 test_expect_success 'bisect starting with a detached HEAD' '
353         git bisect reset &&
354         git checkout master^ &&
355         HEAD=$(git rev-parse --verify HEAD) &&
356         git bisect start &&
357         test $HEAD = $(cat .git/BISECT_START) &&
358         git bisect reset &&
359         test $HEAD = $(git rev-parse --verify HEAD)
360 '
361
362 test_expect_success 'bisect errors out if bad and good are mistaken' '
363         git bisect reset &&
364         test_must_fail git bisect start $HASH2 $HASH4 2> rev_list_error &&
365         test_i18ngrep "mistook good and bad" rev_list_error &&
366         git bisect reset
367 '
368
369 test_expect_success 'bisect does not create a "bisect" branch' '
370         git bisect reset &&
371         git bisect start $HASH7 $HASH1 &&
372         git branch bisect &&
373         rev_hash4=$(git rev-parse --verify HEAD) &&
374         test "$rev_hash4" = "$HASH4" &&
375         git branch -D bisect &&
376         git bisect good &&
377         git branch bisect &&
378         rev_hash6=$(git rev-parse --verify HEAD) &&
379         test "$rev_hash6" = "$HASH6" &&
380         git bisect good > my_bisect_log.txt &&
381         grep "$HASH7 is the first bad commit" my_bisect_log.txt &&
382         git bisect reset &&
383         rev_hash6=$(git rev-parse --verify bisect) &&
384         test "$rev_hash6" = "$HASH6" &&
385         git branch -D bisect
386 '
387
388 # This creates a "side" branch to test "siblings" cases.
389 #
390 # H1-H2-H3-H4-H5-H6-H7  <--other
391 #            \
392 #             S5-S6-S7  <--side
393 #
394 test_expect_success 'side branch creation' '
395         git bisect reset &&
396         git checkout -b side $HASH4 &&
397         add_line_into_file "5(side): first line on a side branch" hello2 &&
398         SIDE_HASH5=$(git rev-parse --verify HEAD) &&
399         add_line_into_file "6(side): second line on a side branch" hello2 &&
400         SIDE_HASH6=$(git rev-parse --verify HEAD) &&
401         add_line_into_file "7(side): third line on a side branch" hello2 &&
402         SIDE_HASH7=$(git rev-parse --verify HEAD)
403 '
404
405 test_expect_success 'good merge base when good and bad are siblings' '
406         git bisect start "$HASH7" "$SIDE_HASH7" > my_bisect_log.txt &&
407         test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
408         grep $HASH4 my_bisect_log.txt &&
409         git bisect good > my_bisect_log.txt &&
410         ! grep "merge base must be tested" my_bisect_log.txt &&
411         grep $HASH6 my_bisect_log.txt &&
412         git bisect reset
413 '
414 test_expect_success 'skipped merge base when good and bad are siblings' '
415         git bisect start "$SIDE_HASH7" "$HASH7" > my_bisect_log.txt &&
416         test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
417         grep $HASH4 my_bisect_log.txt &&
418         git bisect skip > my_bisect_log.txt 2>&1 &&
419         grep "warning" my_bisect_log.txt &&
420         grep $SIDE_HASH6 my_bisect_log.txt &&
421         git bisect reset
422 '
423
424 test_expect_success 'bad merge base when good and bad are siblings' '
425         git bisect start "$HASH7" HEAD > my_bisect_log.txt &&
426         test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
427         grep $HASH4 my_bisect_log.txt &&
428         test_must_fail git bisect bad > my_bisect_log.txt 2>&1 &&
429         test_i18ngrep "merge base $HASH4 is bad" my_bisect_log.txt &&
430         test_i18ngrep "fixed between $HASH4 and \[$SIDE_HASH7\]" my_bisect_log.txt &&
431         git bisect reset
432 '
433
434 # This creates a few more commits (A and B) to test "siblings" cases
435 # when a good and a bad rev have many merge bases.
436 #
437 # We should have the following:
438 #
439 # H1-H2-H3-H4-H5-H6-H7
440 #            \  \     \
441 #             S5-A     \
442 #              \        \
443 #               S6-S7----B
444 #
445 # And there A and B have 2 merge bases (S5 and H5) that should be
446 # reported by "git merge-base --all A B".
447 #
448 test_expect_success 'many merge bases creation' '
449         git checkout "$SIDE_HASH5" &&
450         git merge -m "merge HASH5 and SIDE_HASH5" "$HASH5" &&
451         A_HASH=$(git rev-parse --verify HEAD) &&
452         git checkout side &&
453         git merge -m "merge HASH7 and SIDE_HASH7" "$HASH7" &&
454         B_HASH=$(git rev-parse --verify HEAD) &&
455         git merge-base --all "$A_HASH" "$B_HASH" > merge_bases.txt &&
456         test_line_count = 2 merge_bases.txt &&
457         grep "$HASH5" merge_bases.txt &&
458         grep "$SIDE_HASH5" merge_bases.txt
459 '
460
461 test_expect_success 'good merge bases when good and bad are siblings' '
462         git bisect start "$B_HASH" "$A_HASH" > my_bisect_log.txt &&
463         test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
464         git bisect good > my_bisect_log2.txt &&
465         test_i18ngrep "merge base must be tested" my_bisect_log2.txt &&
466         {
467                 {
468                         grep "$SIDE_HASH5" my_bisect_log.txt &&
469                         grep "$HASH5" my_bisect_log2.txt
470                 } || {
471                         grep "$SIDE_HASH5" my_bisect_log2.txt &&
472                         grep "$HASH5" my_bisect_log.txt
473                 }
474         } &&
475         git bisect reset
476 '
477
478 test_expect_success 'optimized merge base checks' '
479         git bisect start "$HASH7" "$SIDE_HASH7" > my_bisect_log.txt &&
480         test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
481         grep "$HASH4" my_bisect_log.txt &&
482         git bisect good > my_bisect_log2.txt &&
483         test -f ".git/BISECT_ANCESTORS_OK" &&
484         test "$HASH6" = $(git rev-parse --verify HEAD) &&
485         git bisect bad > my_bisect_log3.txt &&
486         git bisect good "$A_HASH" > my_bisect_log4.txt &&
487         test_i18ngrep "merge base must be tested" my_bisect_log4.txt &&
488         test_must_fail test -f ".git/BISECT_ANCESTORS_OK"
489 '
490
491 # This creates another side branch called "parallel" with some files
492 # in some directories, to test bisecting with paths.
493 #
494 # We should have the following:
495 #
496 #    P1-P2-P3-P4-P5-P6-P7
497 #   /        /        /
498 # H1-H2-H3-H4-H5-H6-H7
499 #            \  \     \
500 #             S5-A     \
501 #              \        \
502 #               S6-S7----B
503 #
504 test_expect_success '"parallel" side branch creation' '
505         git bisect reset &&
506         git checkout -b parallel $HASH1 &&
507         mkdir dir1 dir2 &&
508         add_line_into_file "1(para): line 1 on parallel branch" dir1/file1 &&
509         PARA_HASH1=$(git rev-parse --verify HEAD) &&
510         add_line_into_file "2(para): line 2 on parallel branch" dir2/file2 &&
511         PARA_HASH2=$(git rev-parse --verify HEAD) &&
512         add_line_into_file "3(para): line 3 on parallel branch" dir2/file3 &&
513         PARA_HASH3=$(git rev-parse --verify HEAD) &&
514         git merge -m "merge HASH4 and PARA_HASH3" "$HASH4" &&
515         PARA_HASH4=$(git rev-parse --verify HEAD) &&
516         add_line_into_file "5(para): add line on parallel branch" dir1/file1 &&
517         PARA_HASH5=$(git rev-parse --verify HEAD) &&
518         add_line_into_file "6(para): add line on parallel branch" dir2/file2 &&
519         PARA_HASH6=$(git rev-parse --verify HEAD) &&
520         git merge -m "merge HASH7 and PARA_HASH6" "$HASH7" &&
521         PARA_HASH7=$(git rev-parse --verify HEAD)
522 '
523
524 test_expect_success 'restricting bisection on one dir' '
525         git bisect reset &&
526         git bisect start HEAD $HASH1 -- dir1 &&
527         para1=$(git rev-parse --verify HEAD) &&
528         test "$para1" = "$PARA_HASH1" &&
529         git bisect bad > my_bisect_log.txt &&
530         grep "$PARA_HASH1 is the first bad commit" my_bisect_log.txt
531 '
532
533 test_expect_success 'restricting bisection on one dir and a file' '
534         git bisect reset &&
535         git bisect start HEAD $HASH1 -- dir1 hello &&
536         para4=$(git rev-parse --verify HEAD) &&
537         test "$para4" = "$PARA_HASH4" &&
538         git bisect bad &&
539         hash3=$(git rev-parse --verify HEAD) &&
540         test "$hash3" = "$HASH3" &&
541         git bisect good &&
542         hash4=$(git rev-parse --verify HEAD) &&
543         test "$hash4" = "$HASH4" &&
544         git bisect good &&
545         para1=$(git rev-parse --verify HEAD) &&
546         test "$para1" = "$PARA_HASH1" &&
547         git bisect good > my_bisect_log.txt &&
548         grep "$PARA_HASH4 is the first bad commit" my_bisect_log.txt
549 '
550
551 test_expect_success 'skipping away from skipped commit' '
552         git bisect start $PARA_HASH7 $HASH1 &&
553         para4=$(git rev-parse --verify HEAD) &&
554         test "$para4" = "$PARA_HASH4" &&
555         git bisect skip &&
556         hash7=$(git rev-parse --verify HEAD) &&
557         test "$hash7" = "$HASH7" &&
558         git bisect skip &&
559         para3=$(git rev-parse --verify HEAD) &&
560         test "$para3" = "$PARA_HASH3"
561 '
562
563 test_expect_success 'erroring out when using bad path parameters' '
564         test_must_fail git bisect start $PARA_HASH7 $HASH1 -- foobar 2> error.txt &&
565         test_i18ngrep "bad path parameters" error.txt
566 '
567
568 test_expect_success 'test bisection on bare repo - --no-checkout specified' '
569         git clone --bare . bare.nocheckout &&
570         (
571                 cd bare.nocheckout &&
572                 git bisect start --no-checkout &&
573                 git bisect good $HASH1 &&
574                 git bisect bad $HASH4 &&
575                 git bisect run eval \
576                         "test \$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0" \
577                         >../nocheckout.log
578         ) &&
579         grep "$HASH3 is the first bad commit" nocheckout.log
580 '
581
582
583 test_expect_success 'test bisection on bare repo - --no-checkout defaulted' '
584         git clone --bare . bare.defaulted &&
585         (
586                 cd bare.defaulted &&
587                 git bisect start &&
588                 git bisect good $HASH1 &&
589                 git bisect bad $HASH4 &&
590                 git bisect run eval \
591                         "test \$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0" \
592                         >../defaulted.log
593         ) &&
594         grep "$HASH3 is the first bad commit" defaulted.log
595 '
596
597 #
598 # This creates a broken branch which cannot be checked out because
599 # the tree created has been deleted.
600 #
601 # H1-H2-H3-H4-H5-H6-H7  <--other
602 #            \
603 #             S5-S6'-S7'-S8'-S9  <--broken
604 #
605 # Commits marked with ' have a missing tree.
606 #
607 test_expect_success 'broken branch creation' '
608         git bisect reset &&
609         git checkout -b broken $HASH4 &&
610         git tag BROKEN_HASH4 $HASH4 &&
611         add_line_into_file "5(broken): first line on a broken branch" hello2 &&
612         git tag BROKEN_HASH5 &&
613         mkdir missing &&
614         :> missing/MISSING &&
615         git add missing/MISSING &&
616         git commit -m "6(broken): Added file that will be deleted" &&
617         git tag BROKEN_HASH6 &&
618         add_line_into_file "7(broken): second line on a broken branch" hello2 &&
619         git tag BROKEN_HASH7 &&
620         add_line_into_file "8(broken): third line on a broken branch" hello2 &&
621         git tag BROKEN_HASH8 &&
622         git rm missing/MISSING &&
623         git commit -m "9(broken): Remove missing file" &&
624         git tag BROKEN_HASH9 &&
625         rm .git/objects/39/f7e61a724187ab767d2e08442d9b6b9dab587d
626 '
627
628 echo "" > expected.ok
629 cat > expected.missing-tree.default <<EOF
630 fatal: unable to read tree 39f7e61a724187ab767d2e08442d9b6b9dab587d
631 EOF
632
633 test_expect_success 'bisect fails if tree is broken on start commit' '
634         git bisect reset &&
635         test_must_fail git bisect start BROKEN_HASH7 BROKEN_HASH4 2>error.txt &&
636         test_cmp expected.missing-tree.default error.txt
637 '
638
639 test_expect_success 'bisect fails if tree is broken on trial commit' '
640         git bisect reset &&
641         test_must_fail git bisect start BROKEN_HASH9 BROKEN_HASH4 2>error.txt &&
642         git reset --hard broken &&
643         git checkout broken &&
644         test_cmp expected.missing-tree.default error.txt
645 '
646
647 check_same()
648 {
649         echo "Checking $1 is the same as $2" &&
650         test_cmp_rev "$1" "$2"
651 }
652
653 test_expect_success 'bisect: --no-checkout - start commit bad' '
654         git bisect reset &&
655         git bisect start BROKEN_HASH7 BROKEN_HASH4 --no-checkout &&
656         check_same BROKEN_HASH6 BISECT_HEAD &&
657         git bisect reset
658 '
659
660 test_expect_success 'bisect: --no-checkout - trial commit bad' '
661         git bisect reset &&
662         git bisect start broken BROKEN_HASH4 --no-checkout &&
663         check_same BROKEN_HASH6 BISECT_HEAD &&
664         git bisect reset
665 '
666
667 test_expect_success 'bisect: --no-checkout - target before breakage' '
668         git bisect reset &&
669         git bisect start broken BROKEN_HASH4 --no-checkout &&
670         check_same BROKEN_HASH6 BISECT_HEAD &&
671         git bisect bad BISECT_HEAD &&
672         check_same BROKEN_HASH5 BISECT_HEAD &&
673         git bisect bad BISECT_HEAD &&
674         check_same BROKEN_HASH5 bisect/bad &&
675         git bisect reset
676 '
677
678 test_expect_success 'bisect: --no-checkout - target in breakage' '
679         git bisect reset &&
680         git bisect start broken BROKEN_HASH4 --no-checkout &&
681         check_same BROKEN_HASH6 BISECT_HEAD &&
682         git bisect bad BISECT_HEAD &&
683         check_same BROKEN_HASH5 BISECT_HEAD &&
684         git bisect good BISECT_HEAD &&
685         check_same BROKEN_HASH6 bisect/bad &&
686         git bisect reset
687 '
688
689 test_expect_success 'bisect: --no-checkout - target after breakage' '
690         git bisect reset &&
691         git bisect start broken BROKEN_HASH4 --no-checkout &&
692         check_same BROKEN_HASH6 BISECT_HEAD &&
693         git bisect good BISECT_HEAD &&
694         check_same BROKEN_HASH8 BISECT_HEAD &&
695         git bisect good BISECT_HEAD &&
696         check_same BROKEN_HASH9 bisect/bad &&
697         git bisect reset
698 '
699
700 test_expect_success 'bisect: demonstrate identification of damage boundary' "
701         git bisect reset &&
702         git checkout broken &&
703         git bisect start broken master --no-checkout &&
704         git bisect run \"\$SHELL_PATH\" -c '
705                 GOOD=\$(git for-each-ref \"--format=%(objectname)\" refs/bisect/good-*) &&
706                 git rev-list --objects BISECT_HEAD --not \$GOOD >tmp.\$\$ &&
707                 git pack-objects --stdout >/dev/null < tmp.\$\$
708                 rc=\$?
709                 rm -f tmp.\$\$
710                 test \$rc = 0' &&
711         check_same BROKEN_HASH6 bisect/bad &&
712         git bisect reset
713 "
714
715 cat > expected.bisect-log <<EOF
716 # bad: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.
717 # good: [7b7f204a749c3125d5224ed61ea2ae1187ad046f] Add <2: A new day for git> into <hello>.
718 git bisect start '32a594a3fdac2d57cf6d02987e30eec68511498c' '7b7f204a749c3125d5224ed61ea2ae1187ad046f'
719 # good: [3de952f2416b6084f557ec417709eac740c6818c] Add <3: Another new day for git> into <hello>.
720 git bisect good 3de952f2416b6084f557ec417709eac740c6818c
721 # first bad commit: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.
722 EOF
723
724 test_expect_success 'bisect log: successful result' '
725         git bisect reset &&
726         git bisect start $HASH4 $HASH2 &&
727         git bisect good &&
728         git bisect log >bisect-log.txt &&
729         test_cmp expected.bisect-log bisect-log.txt &&
730         git bisect reset
731 '
732
733 cat > expected.bisect-skip-log <<EOF
734 # bad: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.
735 # good: [7b7f204a749c3125d5224ed61ea2ae1187ad046f] Add <2: A new day for git> into <hello>.
736 git bisect start '32a594a3fdac2d57cf6d02987e30eec68511498c' '7b7f204a749c3125d5224ed61ea2ae1187ad046f'
737 # skip: [3de952f2416b6084f557ec417709eac740c6818c] Add <3: Another new day for git> into <hello>.
738 git bisect skip 3de952f2416b6084f557ec417709eac740c6818c
739 # only skipped commits left to test
740 # possible first bad commit: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.
741 # possible first bad commit: [3de952f2416b6084f557ec417709eac740c6818c] Add <3: Another new day for git> into <hello>.
742 EOF
743
744 test_expect_success 'bisect log: only skip commits left' '
745         git bisect reset &&
746         git bisect start $HASH4 $HASH2 &&
747         test_must_fail git bisect skip &&
748         git bisect log >bisect-skip-log.txt &&
749         test_cmp expected.bisect-skip-log bisect-skip-log.txt &&
750         git bisect reset
751 '
752
753 test_expect_success '"git bisect bad HEAD" behaves as "git bisect bad"' '
754         git checkout parallel &&
755         git bisect start HEAD $HASH1 &&
756         git bisect good HEAD &&
757         git bisect bad HEAD &&
758         test "$HASH6" = $(git rev-parse --verify HEAD) &&
759         git bisect reset
760 '
761
762 test_expect_success 'bisect starts with only one new' '
763         git bisect reset &&
764         git bisect start &&
765         git bisect new $HASH4 &&
766         git bisect next
767 '
768
769 test_expect_success 'bisect does not start with only one old' '
770         git bisect reset &&
771         git bisect start &&
772         git bisect old $HASH1 &&
773         test_must_fail git bisect next
774 '
775
776 test_expect_success 'bisect start with one new and old' '
777         git bisect reset &&
778         git bisect start &&
779         git bisect old $HASH1 &&
780         git bisect new $HASH4 &&
781         git bisect new &&
782         git bisect new >bisect_result &&
783         grep "$HASH2 is the first new commit" bisect_result &&
784         git bisect log >log_to_replay.txt &&
785         git bisect reset
786 '
787
788 test_expect_success 'bisect replay with old and new' '
789         git bisect replay log_to_replay.txt >bisect_result &&
790         grep "$HASH2 is the first new commit" bisect_result &&
791         git bisect reset
792 '
793
794 test_expect_success 'bisect cannot mix old/new and good/bad' '
795         git bisect start &&
796         git bisect bad $HASH4 &&
797         test_must_fail git bisect old $HASH1
798 '
799
800 test_expect_success 'bisect terms needs 0 or 1 argument' '
801         git bisect reset &&
802         test_must_fail git bisect terms only-one &&
803         test_must_fail git bisect terms 1 2 &&
804         test_must_fail git bisect terms 2>actual &&
805         echo "no terms defined" >expected &&
806         test_i18ncmp expected actual
807 '
808
809 test_expect_success 'bisect terms shows good/bad after start' '
810         git bisect reset &&
811         git bisect start HEAD $HASH1 &&
812         git bisect terms --term-good >actual &&
813         echo good >expected &&
814         test_cmp expected actual &&
815         git bisect terms --term-bad >actual &&
816         echo bad >expected &&
817         test_cmp expected actual
818 '
819
820 test_expect_success 'bisect start with one term1 and term2' '
821         git bisect reset &&
822         git bisect start --term-old term2 --term-new term1 &&
823         git bisect term2 $HASH1 &&
824         git bisect term1 $HASH4 &&
825         git bisect term1 &&
826         git bisect term1 >bisect_result &&
827         grep "$HASH2 is the first term1 commit" bisect_result &&
828         git bisect log >log_to_replay.txt &&
829         git bisect reset
830 '
831
832 test_expect_success 'bisect replay with term1 and term2' '
833         git bisect replay log_to_replay.txt >bisect_result &&
834         grep "$HASH2 is the first term1 commit" bisect_result &&
835         git bisect reset
836 '
837
838 test_expect_success 'bisect start term1 term2' '
839         git bisect reset &&
840         git bisect start --term-new term1 --term-old term2 $HASH4 $HASH1 &&
841         git bisect term1 &&
842         git bisect term1 >bisect_result &&
843         grep "$HASH2 is the first term1 commit" bisect_result &&
844         git bisect log >log_to_replay.txt &&
845         git bisect reset
846 '
847
848 test_expect_success 'bisect cannot mix terms' '
849         git bisect reset &&
850         git bisect start --term-good term1 --term-bad term2 $HASH4 $HASH1 &&
851         test_must_fail git bisect a &&
852         test_must_fail git bisect b &&
853         test_must_fail git bisect bad &&
854         test_must_fail git bisect good &&
855         test_must_fail git bisect new &&
856         test_must_fail git bisect old
857 '
858
859 test_expect_success 'bisect terms rejects invalid terms' '
860         git bisect reset &&
861         test_must_fail git bisect start --term-good invalid..term &&
862         test_must_fail git bisect terms --term-bad invalid..term &&
863         test_must_fail git bisect terms --term-good bad &&
864         test_must_fail git bisect terms --term-good old &&
865         test_must_fail git bisect terms --term-good skip &&
866         test_must_fail git bisect terms --term-good reset &&
867         test_path_is_missing .git/BISECT_TERMS
868 '
869
870 test_expect_success 'bisect start --term-* does store terms' '
871         git bisect reset &&
872         git bisect start --term-bad=one --term-good=two &&
873         git bisect terms >actual &&
874         cat <<-EOF >expected &&
875         Your current terms are two for the old state
876         and one for the new state.
877         EOF
878         test_i18ncmp expected actual &&
879         git bisect terms --term-bad >actual &&
880         echo one >expected &&
881         test_cmp expected actual &&
882         git bisect terms --term-good >actual &&
883         echo two >expected &&
884         test_cmp expected actual
885 '
886
887 test_expect_success 'bisect start takes options and revs in any order' '
888         git bisect reset &&
889         git bisect start --term-good one $HASH4 \
890                 --term-good two --term-bad bad-term \
891                 $HASH1 --term-good three -- &&
892         (git bisect terms --term-bad && git bisect terms --term-good) >actual &&
893         printf "%s\n%s\n" bad-term three >expected &&
894         test_cmp expected actual
895 '
896
897 test_done