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 || return 1
  56
  57         if git bisect next
  58         then
  59                 echo Oops, should have failed.
  60                 false
  61         else
  62                 :
  63         fi
  64 '
  65
  66 test_expect_success 'bisect start with one bad and good' '
  67         git bisect reset &&
  68         git bisect start &&
  69         git bisect good $HASH1 &&
  70         git bisect bad $HASH4 &&
  71         git bisect next
  72 '
  73
  74 test_expect_success 'bisect fails if given any junk instead of revs' '
  75         git bisect reset &&
  76         test_must_fail git bisect start foo $HASH1 -- &&
  77         test_must_fail git bisect start $HASH4 $HASH1 bar -- &&
  78         test -z "$(git for-each-ref "refs/bisect/*")" &&
  79         test -z "$(ls .git/BISECT_* 2>/dev/null)" &&
  80         git bisect start &&
  81         test_must_fail git bisect good foo $HASH1 &&
  82         test_must_fail git bisect good $HASH1 bar &&
  83         test_must_fail git bisect bad frotz &&
  84         test_must_fail git bisect bad $HASH3 $HASH4 &&
  85         test_must_fail git bisect skip bar $HASH3 &&
  86         test_must_fail git bisect skip $HASH1 foo &&
  87         test -z "$(git for-each-ref "refs/bisect/*")" &&
  88         git bisect good $HASH1 &&
  89         git bisect bad $HASH4
  90 '
  91
  92 test_expect_success 'bisect reset: back in the master branch' '
  93         git bisect reset &&
  94         echo "* master" > branch.expect &&
  95         git branch > branch.output &&
  96         cmp branch.expect branch.output
  97 '
  98
  99 test_expect_success 'bisect reset: back in another branch' '
 100         git checkout -b other &&
 101         git bisect start &&
 102         git bisect good $HASH1 &&
 103         git bisect bad $HASH3 &&
 104         git bisect reset &&
 105         echo "  master" > branch.expect &&
 106         echo "* other" >> branch.expect &&
 107         git branch > branch.output &&
 108         cmp branch.expect branch.output
 109 '
 110
 111 test_expect_success 'bisect reset when not bisecting' '
 112         git bisect reset &&
 113         git branch > branch.output &&
 114         cmp branch.expect branch.output
 115 '
 116
 117 test_expect_success 'bisect reset removes packed refs' '
 118         git bisect reset &&
 119         git bisect start &&
 120         git bisect good $HASH1 &&
 121         git bisect bad $HASH3 &&
 122         git pack-refs --all --prune &&
 123         git bisect next &&
 124         git bisect reset &&
 125         test -z "$(git for-each-ref "refs/bisect/*")" &&
 126         test -z "$(git for-each-ref "refs/heads/bisect")"
 127 '
 128
 129 test_expect_success 'bisect reset removes bisect state after --no-checkout' '
 130         git bisect reset &&
 131         git bisect start --no-checkout &&
 132         git bisect good $HASH1 &&
 133         git bisect bad $HASH3 &&
 134         git bisect next &&
 135         git bisect reset &&
 136         test -z "$(git for-each-ref "refs/bisect/*")" &&
 137         test -z "$(git for-each-ref "refs/heads/bisect")" &&
 138         test -z "$(git for-each-ref "BISECT_HEAD")"
 139 '
 140
 141 test_expect_success 'bisect start: back in good branch' '
 142         git branch > branch.output &&
 143         grep "* other" branch.output > /dev/null &&
 144         git bisect start $HASH4 $HASH1 -- &&
 145         git bisect good &&
 146         git bisect start $HASH4 $HASH1 -- &&
 147         git bisect bad &&
 148         git bisect reset &&
 149         git branch > branch.output &&
 150         grep "* other" branch.output > /dev/null
 151 '
 152
 153 test_expect_success 'bisect start: no ".git/BISECT_START" created if junk rev' '
 154         git bisect reset &&
 155         test_must_fail git bisect start $HASH4 foo -- &&
 156         git branch > branch.output &&
 157         grep "* other" branch.output > /dev/null &&
 158         test_must_fail test -e .git/BISECT_START
 159 '
 160
 161 test_expect_success 'bisect start: existing ".git/BISECT_START" not modified if junk rev' '
 162         git bisect start $HASH4 $HASH1 -- &&
 163         git bisect good &&
 164         cp .git/BISECT_START saved &&
 165         test_must_fail git bisect start $HASH4 foo -- &&
 166         git branch > branch.output &&
 167         test_i18ngrep "* (no branch)" branch.output > /dev/null &&
 168         test_cmp saved .git/BISECT_START
 169 '
 170 test_expect_success 'bisect start: no ".git/BISECT_START" if mistaken rev' '
 171         git bisect start $HASH4 $HASH1 -- &&
 172         git bisect good &&
 173         test_must_fail git bisect start $HASH1 $HASH4 -- &&
 174         git branch > branch.output &&
 175         grep "* other" branch.output > /dev/null &&
 176         test_must_fail test -e .git/BISECT_START
 177 '
 178
 179 test_expect_success 'bisect start: no ".git/BISECT_START" if checkout error' '
 180         echo "temp stuff" > hello &&
 181         test_must_fail git bisect start $HASH4 $HASH1 -- &&
 182         git branch &&
 183         git branch > branch.output &&
 184         grep "* other" branch.output > /dev/null &&
 185         test_must_fail test -e .git/BISECT_START &&
 186         test -z "$(git for-each-ref "refs/bisect/*")" &&
 187         git checkout HEAD hello
 188 '
 189
 190 # $HASH1 is good, $HASH4 is bad, we skip $HASH3
 191 # but $HASH2 is bad,
 192 # so we should find $HASH2 as the first bad commit
 193 test_expect_success 'bisect skip: successfull result' '
 194         git bisect reset &&
 195         git bisect start $HASH4 $HASH1 &&
 196         git bisect skip &&
 197         git bisect bad > my_bisect_log.txt &&
 198         grep "$HASH2 is the first bad commit" my_bisect_log.txt &&
 199         git bisect reset
 200 '
 201
 202 # $HASH1 is good, $HASH4 is bad, we skip $HASH3 and $HASH2
 203 # so we should not be able to tell the first bad commit
 204 # among $HASH2, $HASH3 and $HASH4
 205 test_expect_success 'bisect skip: cannot tell between 3 commits' '
 206         git bisect start $HASH4 $HASH1 &&
 207         git bisect skip || return 1
 208
 209         if git bisect skip > my_bisect_log.txt
 210         then
 211                 echo Oops, should have failed.
 212                 false
 213         else
 214                 test $? -eq 2 &&
 215                 grep "first bad commit could be any of" my_bisect_log.txt &&
 216                 ! grep $HASH1 my_bisect_log.txt &&
 217                 grep $HASH2 my_bisect_log.txt &&
 218                 grep $HASH3 my_bisect_log.txt &&
 219                 grep $HASH4 my_bisect_log.txt &&
 220                 git bisect reset
 221         fi
 222 '
 223
 224 # $HASH1 is good, $HASH4 is bad, we skip $HASH3
 225 # but $HASH2 is good,
 226 # so we should not be able to tell the first bad commit
 227 # among $HASH3 and $HASH4
 228 test_expect_success 'bisect skip: cannot tell between 2 commits' '
 229         git bisect start $HASH4 $HASH1 &&
 230         git bisect skip || return 1
 231
 232         if git bisect good > my_bisect_log.txt
 233         then
 234                 echo Oops, should have failed.
 235                 false
 236         else
 237                 test $? -eq 2 &&
 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                 git bisect reset
 244         fi
 245 '
 246
 247 # $HASH1 is good, $HASH4 is both skipped and bad, we skip $HASH3
 248 # and $HASH2 is good,
 249 # so we should not be able to tell the first bad commit
 250 # among $HASH3 and $HASH4
 251 test_expect_success 'bisect skip: with commit both bad and skipped' '
 252         git bisect start &&
 253         git bisect skip &&
 254         git bisect bad &&
 255         git bisect good $HASH1 &&
 256         git bisect skip &&
 257         if git bisect good > my_bisect_log.txt
 258         then
 259                 echo Oops, should have failed.
 260                 false
 261         else
 262                 test $? -eq 2 &&
 263                 grep "first bad commit could be any of" my_bisect_log.txt &&
 264                 ! grep $HASH1 my_bisect_log.txt &&
 265                 ! grep $HASH2 my_bisect_log.txt &&
 266                 grep $HASH3 my_bisect_log.txt &&
 267                 grep $HASH4 my_bisect_log.txt &&
 268                 git bisect reset
 269         fi
 270 '
 271
 272 # We want to automatically find the commit that
 273 # introduced "Another" into hello.
 274 test_expect_success \
 275     '"git bisect run" simple case' \
 276     'echo "#"\!"/bin/sh" > test_script.sh &&
 277      echo "grep Another hello > /dev/null" >> test_script.sh &&
 278      echo "test \$? -ne 0" >> test_script.sh &&
 279      chmod +x test_script.sh &&
 280      git bisect start &&
 281      git bisect good $HASH1 &&
 282      git bisect bad $HASH4 &&
 283      git bisect run ./test_script.sh > my_bisect_log.txt &&
 284      grep "$HASH3 is the first bad commit" my_bisect_log.txt &&
 285      git bisect reset'
 286
 287 # We want to automatically find the commit that
 288 # introduced "Ciao" into hello.
 289 test_expect_success \
 290     '"git bisect run" with more complex "git bisect start"' \
 291     'echo "#"\!"/bin/sh" > test_script.sh &&
 292      echo "grep Ciao hello > /dev/null" >> test_script.sh &&
 293      echo "test \$? -ne 0" >> test_script.sh &&
 294      chmod +x test_script.sh &&
 295      git bisect start $HASH4 $HASH1 &&
 296      git bisect run ./test_script.sh > my_bisect_log.txt &&
 297      grep "$HASH4 is the first bad commit" my_bisect_log.txt &&
 298      git bisect reset'
 299
 300 # $HASH1 is good, $HASH5 is bad, we skip $HASH3
 301 # but $HASH4 is good,
 302 # so we should find $HASH5 as the first bad commit
 303 HASH5=
 304 test_expect_success 'bisect skip: add line and then a new test' '
 305         add_line_into_file "5: Another new line." hello &&
 306         HASH5=$(git rev-parse --verify HEAD) &&
 307         git bisect start $HASH5 $HASH1 &&
 308         git bisect skip &&
 309         git bisect good > my_bisect_log.txt &&
 310         grep "$HASH5 is the first bad commit" my_bisect_log.txt &&
 311         git bisect log > log_to_replay.txt &&
 312         git bisect reset
 313 '
 314
 315 test_expect_success 'bisect skip and bisect replay' '
 316         git bisect replay log_to_replay.txt > my_bisect_log.txt &&
 317         grep "$HASH5 is the first bad commit" my_bisect_log.txt &&
 318         git bisect reset
 319 '
 320
 321 HASH6=
 322 test_expect_success 'bisect run & skip: cannot tell between 2' '
 323         add_line_into_file "6: Yet a line." hello &&
 324         HASH6=$(git rev-parse --verify HEAD) &&
 325         echo "#"\!"/bin/sh" > test_script.sh &&
 326         echo "sed -ne \\\$p hello | grep Ciao > /dev/null && exit 125" >> test_script.sh &&
 327         echo "grep line hello > /dev/null" >> test_script.sh &&
 328         echo "test \$? -ne 0" >> test_script.sh &&
 329         chmod +x test_script.sh &&
 330         git bisect start $HASH6 $HASH1 &&
 331         if git bisect run ./test_script.sh > my_bisect_log.txt
 332         then
 333                 echo Oops, should have failed.
 334                 false
 335         else
 336                 test $? -eq 2 &&
 337                 grep "first bad commit could be any of" my_bisect_log.txt &&
 338                 ! grep $HASH3 my_bisect_log.txt &&
 339                 ! grep $HASH6 my_bisect_log.txt &&
 340                 grep $HASH4 my_bisect_log.txt &&
 341                 grep $HASH5 my_bisect_log.txt
 342         fi
 343 '
 344
 345 HASH7=
 346 test_expect_success 'bisect run & skip: find first bad' '
 347         git bisect reset &&
 348         add_line_into_file "7: Should be the last line." hello &&
 349         HASH7=$(git rev-parse --verify HEAD) &&
 350         echo "#"\!"/bin/sh" > test_script.sh &&
 351         echo "sed -ne \\\$p hello | grep Ciao > /dev/null && exit 125" >> test_script.sh &&
 352         echo "sed -ne \\\$p hello | grep day > /dev/null && exit 125" >> test_script.sh &&
 353         echo "grep Yet hello > /dev/null" >> test_script.sh &&
 354         echo "test \$? -ne 0" >> test_script.sh &&
 355         chmod +x test_script.sh &&
 356         git bisect start $HASH7 $HASH1 &&
 357         git bisect run ./test_script.sh > my_bisect_log.txt &&
 358         grep "$HASH6 is the first bad commit" my_bisect_log.txt
 359 '
 360
 361 test_expect_success 'bisect skip only one range' '
 362         git bisect reset &&
 363         git bisect start $HASH7 $HASH1 &&
 364         git bisect skip $HASH1..$HASH5 &&
 365         test "$HASH6" = "$(git rev-parse --verify HEAD)" &&
 366         test_must_fail git bisect bad > my_bisect_log.txt &&
 367         grep "first bad commit could be any of" my_bisect_log.txt
 368 '
 369
 370 test_expect_success 'bisect skip many ranges' '
 371         git bisect start $HASH7 $HASH1 &&
 372         test "$HASH4" = "$(git rev-parse --verify HEAD)" &&
 373         git bisect skip $HASH2 $HASH2.. ..$HASH5 &&
 374         test "$HASH6" = "$(git rev-parse --verify HEAD)" &&
 375         test_must_fail git bisect bad > my_bisect_log.txt &&
 376         grep "first bad commit could be any of" my_bisect_log.txt
 377 '
 378
 379 test_expect_success 'bisect starting with a detached HEAD' '
 380         git bisect reset &&
 381         git checkout master^ &&
 382         HEAD=$(git rev-parse --verify HEAD) &&
 383         git bisect start &&
 384         test $HEAD = $(cat .git/BISECT_START) &&
 385         git bisect reset &&
 386         test $HEAD = $(git rev-parse --verify HEAD)
 387 '
 388
 389 test_expect_success 'bisect errors out if bad and good are mistaken' '
 390         git bisect reset &&
 391         test_must_fail git bisect start $HASH2 $HASH4 2> rev_list_error &&
 392         grep "mistake good and bad" rev_list_error &&
 393         git bisect reset
 394 '
 395
 396 test_expect_success 'bisect does not create a "bisect" branch' '
 397         git bisect reset &&
 398         git bisect start $HASH7 $HASH1 &&
 399         git branch bisect &&
 400         rev_hash4=$(git rev-parse --verify HEAD) &&
 401         test "$rev_hash4" = "$HASH4" &&
 402         git branch -D bisect &&
 403         git bisect good &&
 404         git branch bisect &&
 405         rev_hash6=$(git rev-parse --verify HEAD) &&
 406         test "$rev_hash6" = "$HASH6" &&
 407         git bisect good > my_bisect_log.txt &&
 408         grep "$HASH7 is the first bad commit" my_bisect_log.txt &&
 409         git bisect reset &&
 410         rev_hash6=$(git rev-parse --verify bisect) &&
 411         test "$rev_hash6" = "$HASH6" &&
 412         git branch -D bisect
 413 '
 414
 415 # This creates a "side" branch to test "siblings" cases.
 416 #
 417 # H1-H2-H3-H4-H5-H6-H7  <--other
 418 #            \
 419 #             S5-S6-S7  <--side
 420 #
 421 test_expect_success 'side branch creation' '
 422         git bisect reset &&
 423         git checkout -b side $HASH4 &&
 424         add_line_into_file "5(side): first line on a side branch" hello2 &&
 425         SIDE_HASH5=$(git rev-parse --verify HEAD) &&
 426         add_line_into_file "6(side): second line on a side branch" hello2 &&
 427         SIDE_HASH6=$(git rev-parse --verify HEAD) &&
 428         add_line_into_file "7(side): third line on a side branch" hello2 &&
 429         SIDE_HASH7=$(git rev-parse --verify HEAD)
 430 '
 431
 432 test_expect_success 'good merge base when good and bad are siblings' '
 433         git bisect start "$HASH7" "$SIDE_HASH7" > my_bisect_log.txt &&
 434         grep "merge base must be tested" my_bisect_log.txt &&
 435         grep $HASH4 my_bisect_log.txt &&
 436         git bisect good > my_bisect_log.txt &&
 437         test_must_fail grep "merge base must be tested" my_bisect_log.txt &&
 438         grep $HASH6 my_bisect_log.txt &&
 439         git bisect reset
 440 '
 441 test_expect_success 'skipped merge base when good and bad are siblings' '
 442         git bisect start "$SIDE_HASH7" "$HASH7" > my_bisect_log.txt &&
 443         grep "merge base must be tested" my_bisect_log.txt &&
 444         grep $HASH4 my_bisect_log.txt &&
 445         git bisect skip > my_bisect_log.txt 2>&1 &&
 446         grep "warning" my_bisect_log.txt &&
 447         grep $SIDE_HASH6 my_bisect_log.txt &&
 448         git bisect reset
 449 '
 450
 451 test_expect_success 'bad merge base when good and bad are siblings' '
 452         git bisect start "$HASH7" HEAD > my_bisect_log.txt &&
 453         grep "merge base must be tested" my_bisect_log.txt &&
 454         grep $HASH4 my_bisect_log.txt &&
 455         test_must_fail git bisect bad > my_bisect_log.txt 2>&1 &&
 456         grep "merge base $HASH4 is bad" my_bisect_log.txt &&
 457         grep "fixed between $HASH4 and \[$SIDE_HASH7\]" my_bisect_log.txt &&
 458         git bisect reset
 459 '
 460
 461 # This creates a few more commits (A and B) to test "siblings" cases
 462 # when a good and a bad rev have many merge bases.
 463 #
 464 # We should have the following:
 465 #
 466 # H1-H2-H3-H4-H5-H6-H7
 467 #            \  \     \
 468 #             S5-A     \
 469 #              \        \
 470 #               S6-S7----B
 471 #
 472 # And there A and B have 2 merge bases (S5 and H5) that should be
 473 # reported by "git merge-base --all A B".
 474 #
 475 test_expect_success 'many merge bases creation' '
 476         git checkout "$SIDE_HASH5" &&
 477         git merge -m "merge HASH5 and SIDE_HASH5" "$HASH5" &&
 478         A_HASH=$(git rev-parse --verify HEAD) &&
 479         git checkout side &&
 480         git merge -m "merge HASH7 and SIDE_HASH7" "$HASH7" &&
 481         B_HASH=$(git rev-parse --verify HEAD) &&
 482         git merge-base --all "$A_HASH" "$B_HASH" > merge_bases.txt &&
 483         test $(wc -l < merge_bases.txt) = "2" &&
 484         grep "$HASH5" merge_bases.txt &&
 485         grep "$SIDE_HASH5" merge_bases.txt
 486 '
 487
 488 test_expect_success 'good merge bases when good and bad are siblings' '
 489         git bisect start "$B_HASH" "$A_HASH" > my_bisect_log.txt &&
 490         grep "merge base must be tested" my_bisect_log.txt &&
 491         git bisect good > my_bisect_log2.txt &&
 492         grep "merge base must be tested" my_bisect_log2.txt &&
 493         {
 494                 {
 495                         grep "$SIDE_HASH5" my_bisect_log.txt &&
 496                         grep "$HASH5" my_bisect_log2.txt
 497                 } || {
 498                         grep "$SIDE_HASH5" my_bisect_log2.txt &&
 499                         grep "$HASH5" my_bisect_log.txt
 500                 }
 501         } &&
 502         git bisect reset
 503 '
 504
 505 test_expect_success 'optimized merge base checks' '
 506         git bisect start "$HASH7" "$SIDE_HASH7" > my_bisect_log.txt &&
 507         grep "merge base must be tested" my_bisect_log.txt &&
 508         grep "$HASH4" my_bisect_log.txt &&
 509         git bisect good > my_bisect_log2.txt &&
 510         test -f ".git/BISECT_ANCESTORS_OK" &&
 511         test "$HASH6" = $(git rev-parse --verify HEAD) &&
 512         git bisect bad > my_bisect_log3.txt &&
 513         git bisect good "$A_HASH" > my_bisect_log4.txt &&
 514         grep "merge base must be tested" my_bisect_log4.txt &&
 515         test_must_fail test -f ".git/BISECT_ANCESTORS_OK"
 516 '
 517
 518 # This creates another side branch called "parallel" with some files
 519 # in some directories, to test bisecting with paths.
 520 #
 521 # We should have the following:
 522 #
 523 #    P1-P2-P3-P4-P5-P6-P7
 524 #   /        /        /
 525 # H1-H2-H3-H4-H5-H6-H7
 526 #            \  \     \
 527 #             S5-A     \
 528 #              \        \
 529 #               S6-S7----B
 530 #
 531 test_expect_success '"parallel" side branch creation' '
 532         git bisect reset &&
 533         git checkout -b parallel $HASH1 &&
 534         mkdir dir1 dir2 &&
 535         add_line_into_file "1(para): line 1 on parallel branch" dir1/file1 &&
 536         PARA_HASH1=$(git rev-parse --verify HEAD) &&
 537         add_line_into_file "2(para): line 2 on parallel branch" dir2/file2 &&
 538         PARA_HASH2=$(git rev-parse --verify HEAD) &&
 539         add_line_into_file "3(para): line 3 on parallel branch" dir2/file3 &&
 540         PARA_HASH3=$(git rev-parse --verify HEAD) &&
 541         git merge -m "merge HASH4 and PARA_HASH3" "$HASH4" &&
 542         PARA_HASH4=$(git rev-parse --verify HEAD) &&
 543         add_line_into_file "5(para): add line on parallel branch" dir1/file1 &&
 544         PARA_HASH5=$(git rev-parse --verify HEAD) &&
 545         add_line_into_file "6(para): add line on parallel branch" dir2/file2 &&
 546         PARA_HASH6=$(git rev-parse --verify HEAD) &&
 547         git merge -m "merge HASH7 and PARA_HASH6" "$HASH7" &&
 548         PARA_HASH7=$(git rev-parse --verify HEAD)
 549 '
 550
 551 test_expect_success 'restricting bisection on one dir' '
 552         git bisect reset &&
 553         git bisect start HEAD $HASH1 -- dir1 &&
 554         para1=$(git rev-parse --verify HEAD) &&
 555         test "$para1" = "$PARA_HASH1" &&
 556         git bisect bad > my_bisect_log.txt &&
 557         grep "$PARA_HASH1 is the first bad commit" my_bisect_log.txt
 558 '
 559
 560 test_expect_success 'restricting bisection on one dir and a file' '
 561         git bisect reset &&
 562         git bisect start HEAD $HASH1 -- dir1 hello &&
 563         para4=$(git rev-parse --verify HEAD) &&
 564         test "$para4" = "$PARA_HASH4" &&
 565         git bisect bad &&
 566         hash3=$(git rev-parse --verify HEAD) &&
 567         test "$hash3" = "$HASH3" &&
 568         git bisect good &&
 569         hash4=$(git rev-parse --verify HEAD) &&
 570         test "$hash4" = "$HASH4" &&
 571         git bisect good &&
 572         para1=$(git rev-parse --verify HEAD) &&
 573         test "$para1" = "$PARA_HASH1" &&
 574         git bisect good > my_bisect_log.txt &&
 575         grep "$PARA_HASH4 is the first bad commit" my_bisect_log.txt
 576 '
 577
 578 test_expect_success 'skipping away from skipped commit' '
 579         git bisect start $PARA_HASH7 $HASH1 &&
 580         para4=$(git rev-parse --verify HEAD) &&
 581         test "$para4" = "$PARA_HASH4" &&
 582         git bisect skip &&
 583         hash7=$(git rev-parse --verify HEAD) &&
 584         test "$hash7" = "$HASH7" &&
 585         git bisect skip &&
 586         para3=$(git rev-parse --verify HEAD) &&
 587         test "$para3" = "$PARA_HASH3"
 588 '
 589
 590 test_expect_success 'erroring out when using bad path parameters' '
 591         test_must_fail git bisect start $PARA_HASH7 $HASH1 -- foobar 2> error.txt &&
 592         grep "bad path parameters" error.txt
 593 '
 594
 595 test_expect_success 'test bisection on bare repo - --no-checkout specified' '
 596         git clone --bare . bare.nocheckout &&
 597         (
 598                 cd bare.nocheckout &&
 599                 git bisect start --no-checkout &&
 600                 git bisect good $HASH1 &&
 601                 git bisect bad $HASH4 &&
 602                 git bisect run eval \
 603                         "test \$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0" \
 604                         >../nocheckout.log &&
 605                 git bisect reset
 606         ) &&
 607         grep "$HASH3 is the first bad commit" nocheckout.log
 608 '
 609
 610
 611 test_expect_success 'test bisection on bare repo - --no-checkout defaulted' '
 612         git clone --bare . bare.defaulted &&
 613         (
 614                 cd bare.defaulted &&
 615                 git bisect start &&
 616                 git bisect good $HASH1 &&
 617                 git bisect bad $HASH4 &&
 618                 git bisect run eval \
 619                         "test \$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0" \
 620                         >../defaulted.log &&
 621                 git bisect reset
 622         ) &&
 623         grep "$HASH3 is the first bad commit" defaulted.log
 624 '
 625
 626 #
 627 # This creates a broken branch which cannot be checked out because
 628 # the tree created has been deleted.
 629 #
 630 # H1-H2-H3-H4-H5-H6-H7  <--other
 631 #            \
 632 #             S5-S6'-S7'-S8'-S9  <--broken
 633 #
 634 # Commits marked with ' have a missing tree.
 635 #
 636 test_expect_success 'broken branch creation' '
 637         git bisect reset &&
 638         git checkout -b broken $HASH4 &&
 639         git tag BROKEN_HASH4 $HASH4 &&
 640         add_line_into_file "5(broken): first line on a broken branch" hello2 &&
 641         git tag BROKEN_HASH5 &&
 642         mkdir missing &&
 643         :> missing/MISSING &&
 644         git add missing/MISSING &&
 645         git commit -m "6(broken): Added file that will be deleted"
 646         git tag BROKEN_HASH6 &&
 647         add_line_into_file "7(broken): second line on a broken branch" hello2 &&
 648         git tag BROKEN_HASH7 &&
 649         add_line_into_file "8(broken): third line on a broken branch" hello2 &&
 650         git tag BROKEN_HASH8 &&
 651         git rm missing/MISSING &&
 652         git commit -m "9(broken): Remove missing file"
 653         git tag BROKEN_HASH9 &&
 654         rm .git/objects/39/f7e61a724187ab767d2e08442d9b6b9dab587d
 655 '
 656
 657 echo "" > expected.ok
 658 cat > expected.missing-tree.default <<EOF
 659 fatal: unable to read tree 39f7e61a724187ab767d2e08442d9b6b9dab587d
 660 EOF
 661
 662 test_expect_success 'bisect fails if tree is broken on start commit' '
 663         git bisect reset &&
 664         test_must_fail git bisect start BROKEN_HASH7 BROKEN_HASH4 2>error.txt &&
 665         test_cmp expected.missing-tree.default error.txt
 666 '
 667
 668 test_expect_success 'bisect fails if tree is broken on trial commit' '
 669         git bisect reset &&
 670         test_must_fail git bisect start BROKEN_HASH9 BROKEN_HASH4 2>error.txt &&
 671         git reset --hard broken &&
 672         git checkout broken &&
 673         test_cmp expected.missing-tree.default error.txt
 674 '
 675
 676 check_same()
 677 {
 678         echo "Checking $1 is the same as $2" &&
 679         git rev-parse "$1" > expected.same &&
 680         git rev-parse "$2" > expected.actual &&
 681         test_cmp expected.same expected.actual
 682 }
 683
 684 test_expect_success 'bisect: --no-checkout - start commit bad' '
 685         git bisect reset &&
 686         git bisect start BROKEN_HASH7 BROKEN_HASH4 --no-checkout &&
 687         check_same BROKEN_HASH6 BISECT_HEAD &&
 688         git bisect reset
 689 '
 690
 691 test_expect_success 'bisect: --no-checkout - trial commit bad' '
 692         git bisect reset &&
 693         git bisect start broken BROKEN_HASH4 --no-checkout &&
 694         check_same BROKEN_HASH6 BISECT_HEAD &&
 695         git bisect reset
 696 '
 697
 698 test_expect_success 'bisect: --no-checkout - target before breakage' '
 699         git bisect reset &&
 700         git bisect start broken BROKEN_HASH4 --no-checkout &&
 701         check_same BROKEN_HASH6 BISECT_HEAD &&
 702         git bisect bad BISECT_HEAD &&
 703         check_same BROKEN_HASH5 BISECT_HEAD &&
 704         git bisect bad BISECT_HEAD &&
 705         check_same BROKEN_HASH5 bisect/bad &&
 706         git bisect reset
 707 '
 708
 709 test_expect_success 'bisect: --no-checkout - target in breakage' '
 710         git bisect reset &&
 711         git bisect start broken BROKEN_HASH4 --no-checkout &&
 712         check_same BROKEN_HASH6 BISECT_HEAD &&
 713         git bisect bad BISECT_HEAD &&
 714         check_same BROKEN_HASH5 BISECT_HEAD &&
 715         git bisect good BISECT_HEAD &&
 716         check_same BROKEN_HASH6 bisect/bad &&
 717         git bisect reset
 718 '
 719
 720 test_expect_success 'bisect: --no-checkout - target after breakage' '
 721         git bisect reset &&
 722         git bisect start broken BROKEN_HASH4 --no-checkout &&
 723         check_same BROKEN_HASH6 BISECT_HEAD &&
 724         git bisect good BISECT_HEAD &&
 725         check_same BROKEN_HASH8 BISECT_HEAD &&
 726         git bisect good BISECT_HEAD &&
 727         check_same BROKEN_HASH9 bisect/bad &&
 728         git bisect reset
 729 '
 730
 731 test_expect_success 'bisect: demonstrate identification of damage boundary' "
 732         git bisect reset &&
 733         git checkout broken &&
 734         git bisect start broken master --no-checkout &&
 735         git bisect run \"\$SHELL_PATH\" -c '
 736                 GOOD=\$(git for-each-ref \"--format=%(objectname)\" refs/bisect/good-*) &&
 737                 git rev-list --objects BISECT_HEAD --not \$GOOD >tmp.\$\$ &&
 738                 git pack-objects --stdout >/dev/null < tmp.\$\$
 739                 rc=\$?
 740                 rm -f tmp.\$\$
 741                 test \$rc = 0' &&
 742         check_same BROKEN_HASH6 bisect/bad &&
 743         git bisect reset
 744 "
 745
 746 test_done