t/t3404-rebase-interactive.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2007 Johannes E. Schindelin
   4 #
   5
   6 test_description='git rebase interactive
   7
   8 This test runs git rebase "interactively", by faking an edit, and verifies
   9 that the result still makes sense.
  10
  11 Initial setup:
  12
  13      one - two - three - four (conflict-branch)
  14    /
  15  A - B - C - D - E            (master)
  16  | \
  17  |   F - G - H                (branch1)
  18  |     \
  19  |\      I                    (branch2)
  20  | \
  21  |   J - K - L - M            (no-conflict-branch)
  22   \
  23     N - O - P                 (no-ff-branch)
  24
  25  where A, B, D and G all touch file1, and one, two, three, four all
  26  touch file "conflict".
  27 '
  28 . ./test-lib.sh
  29
  30 . "$TEST_DIRECTORY"/lib-rebase.sh
  31
  32 # WARNING: Modifications to the initial repository can change the SHA ID used
  33 # in the expect2 file for the 'stop on conflicting pick' test.
  34
  35 test_expect_success 'setup' '
  36         test_commit A file1 &&
  37         test_commit B file1 &&
  38         test_commit C file2 &&
  39         test_commit D file1 &&
  40         test_commit E file3 &&
  41         git checkout -b branch1 A &&
  42         test_commit F file4 &&
  43         test_commit G file1 &&
  44         test_commit H file5 &&
  45         git checkout -b branch2 F &&
  46         test_commit I file6 &&
  47         git checkout -b conflict-branch A &&
  48         test_commit one conflict &&
  49         test_commit two conflict &&
  50         test_commit three conflict &&
  51         test_commit four conflict &&
  52         git checkout -b no-conflict-branch A &&
  53         test_commit J fileJ &&
  54         test_commit K fileK &&
  55         test_commit L fileL &&
  56         test_commit M fileM &&
  57         git checkout -b no-ff-branch A &&
  58         test_commit N fileN &&
  59         test_commit O fileO &&
  60         test_commit P fileP
  61 '
  62
  63 # "exec" commands are run with the user shell by default, but this may
  64 # be non-POSIX. For example, if SHELL=zsh then ">file" doesn't work
  65 # to create a file. Unsetting SHELL avoids such non-portable behavior
  66 # in tests. It must be exported for it to take effect where needed.
  67 SHELL=
  68 export SHELL
  69
  70 test_expect_success 'rebase --keep-empty' '
  71         git checkout -b emptybranch master &&
  72         git commit --allow-empty -m "empty" &&
  73         git rebase --keep-empty -i HEAD~2 &&
  74         git log --oneline >actual &&
  75         test_line_count = 6 actual
  76 '
  77
  78 test_expect_success 'rebase -i with the exec command' '
  79         git checkout master &&
  80         (
  81         set_fake_editor &&
  82         FAKE_LINES="1 exec_>touch-one
  83                 2 exec_>touch-two exec_false exec_>touch-three
  84                 3 4 exec_>\"touch-file__name_with_spaces\";_>touch-after-semicolon 5" &&
  85         export FAKE_LINES &&
  86         test_must_fail git rebase -i A
  87         ) &&
  88         test_path_is_file touch-one &&
  89         test_path_is_file touch-two &&
  90         test_path_is_missing touch-three " (should have stopped before)" &&
  91         test_cmp_rev C HEAD &&
  92         git rebase --continue &&
  93         test_path_is_file touch-three &&
  94         test_path_is_file "touch-file  name with spaces" &&
  95         test_path_is_file touch-after-semicolon &&
  96         test_cmp_rev master HEAD &&
  97         rm -f touch-*
  98 '
  99
 100 test_expect_success 'rebase -i with the exec command runs from tree root' '
 101         git checkout master &&
 102         mkdir subdir && (cd subdir &&
 103         set_fake_editor &&
 104         FAKE_LINES="1 exec_>touch-subdir" \
 105                 git rebase -i HEAD^
 106         ) &&
 107         test_path_is_file touch-subdir &&
 108         rm -fr subdir
 109 '
 110
 111 test_expect_success 'rebase -i with exec allows git commands in subdirs' '
 112         test_when_finished "rm -rf subdir" &&
 113         test_when_finished "git rebase --abort ||:" &&
 114         git checkout master &&
 115         mkdir subdir && (cd subdir &&
 116         set_fake_editor &&
 117         FAKE_LINES="1 exec_cd_subdir_&&_git_rev-parse_--is-inside-work-tree" \
 118                 git rebase -i HEAD^
 119         )
 120 '
 121
 122 test_expect_success 'rebase -i sets work tree properly' '
 123         test_when_finished "rm -rf subdir" &&
 124         test_when_finished "test_might_fail git rebase --abort" &&
 125         mkdir subdir &&
 126         git rebase -x "(cd subdir && git rev-parse --show-toplevel)" HEAD^ \
 127                 >actual &&
 128         ! grep "/subdir$" actual
 129 '
 130
 131 test_expect_success 'rebase -i with the exec command checks tree cleanness' '
 132         git checkout master &&
 133         set_fake_editor &&
 134         test_must_fail env FAKE_LINES="exec_echo_foo_>file1 1" git rebase -i HEAD^ &&
 135         test_cmp_rev master^ HEAD &&
 136         git reset --hard &&
 137         git rebase --continue
 138 '
 139
 140 test_expect_success 'rebase -i with exec of inexistent command' '
 141         git checkout master &&
 142         test_when_finished "git rebase --abort" &&
 143         set_fake_editor &&
 144         test_must_fail env FAKE_LINES="exec_this-command-does-not-exist 1" \
 145         git rebase -i HEAD^ >actual 2>&1 &&
 146         ! grep "Maybe git-rebase is broken" actual
 147 '
 148
 149 test_expect_success 'no changes are a nop' '
 150         git checkout branch2 &&
 151         set_fake_editor &&
 152         git rebase -i F &&
 153         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch2" &&
 154         test $(git rev-parse I) = $(git rev-parse HEAD)
 155 '
 156
 157 test_expect_success 'test the [branch] option' '
 158         git checkout -b dead-end &&
 159         git rm file6 &&
 160         git commit -m "stop here" &&
 161         set_fake_editor &&
 162         git rebase -i F branch2 &&
 163         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch2" &&
 164         test $(git rev-parse I) = $(git rev-parse branch2) &&
 165         test $(git rev-parse I) = $(git rev-parse HEAD)
 166 '
 167
 168 test_expect_success 'test --onto <branch>' '
 169         git checkout -b test-onto branch2 &&
 170         set_fake_editor &&
 171         git rebase -i --onto branch1 F &&
 172         test "$(git symbolic-ref -q HEAD)" = "refs/heads/test-onto" &&
 173         test $(git rev-parse HEAD^) = $(git rev-parse branch1) &&
 174         test $(git rev-parse I) = $(git rev-parse branch2)
 175 '
 176
 177 test_expect_success 'rebase on top of a non-conflicting commit' '
 178         git checkout branch1 &&
 179         git tag original-branch1 &&
 180         set_fake_editor &&
 181         git rebase -i branch2 &&
 182         test file6 = $(git diff --name-only original-branch1) &&
 183         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch1" &&
 184         test $(git rev-parse I) = $(git rev-parse branch2) &&
 185         test $(git rev-parse I) = $(git rev-parse HEAD~2)
 186 '
 187
 188 test_expect_success 'reflog for the branch shows state before rebase' '
 189         test $(git rev-parse branch1@{1}) = $(git rev-parse original-branch1)
 190 '
 191
 192 test_expect_success 'reflog for the branch shows correct finish message' '
 193         printf "rebase -i (finish): refs/heads/branch1 onto %s\n" \
 194                 "$(git rev-parse branch2)" >expected &&
 195         git log -g --pretty=%gs -1 refs/heads/branch1 >actual &&
 196         test_cmp expected actual
 197 '
 198
 199 test_expect_success 'exchange two commits' '
 200         set_fake_editor &&
 201         FAKE_LINES="2 1" git rebase -i HEAD~2 &&
 202         test H = $(git cat-file commit HEAD^ | sed -ne \$p) &&
 203         test G = $(git cat-file commit HEAD | sed -ne \$p)
 204 '
 205
 206 cat > expect << EOF
 207 diff --git a/file1 b/file1
 208 index f70f10e..fd79235 100644
 209 --- a/file1
 210 +++ b/file1
 211 @@ -1 +1 @@
 212 -A
 213 +G
 214 EOF
 215
 216 cat > expect2 << EOF
 217 <<<<<<< HEAD
 218 D
 219 =======
 220 G
 221 >>>>>>> 5d18e54... G
 222 EOF
 223
 224 test_expect_success 'stop on conflicting pick' '
 225         git tag new-branch1 &&
 226         set_fake_editor &&
 227         test_must_fail git rebase -i master &&
 228         test "$(git rev-parse HEAD~3)" = "$(git rev-parse master)" &&
 229         test_cmp expect .git/rebase-merge/patch &&
 230         test_cmp expect2 file1 &&
 231         test "$(git diff --name-status |
 232                 sed -n -e "/^U/s/^U[^a-z]*//p")" = file1 &&
 233         test 4 = $(grep -v "^#" < .git/rebase-merge/done | wc -l) &&
 234         test 0 = $(grep -c "^[^#]" < .git/rebase-merge/git-rebase-todo)
 235 '
 236
 237 test_expect_success 'show conflicted patch' '
 238         GIT_TRACE=1 git rebase --show-current-patch >/dev/null 2>stderr &&
 239         grep "show.*REBASE_HEAD" stderr &&
 240         # the original stopped-sha1 is abbreviated
 241         stopped_sha1="$(git rev-parse $(cat ".git/rebase-merge/stopped-sha"))" &&
 242         test "$(git rev-parse REBASE_HEAD)" = "$stopped_sha1"
 243 '
 244
 245 test_expect_success 'abort' '
 246         git rebase --abort &&
 247         test $(git rev-parse new-branch1) = $(git rev-parse HEAD) &&
 248         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch1" &&
 249         test_path_is_missing .git/rebase-merge
 250 '
 251
 252 test_expect_success 'abort with error when new base cannot be checked out' '
 253         git rm --cached file1 &&
 254         git commit -m "remove file in base" &&
 255         set_fake_editor &&
 256         test_must_fail git rebase -i master > output 2>&1 &&
 257         test_i18ngrep "The following untracked working tree files would be overwritten by checkout:" \
 258                 output &&
 259         test_i18ngrep "file1" output &&
 260         test_path_is_missing .git/rebase-merge &&
 261         git reset --hard HEAD^
 262 '
 263
 264 test_expect_success 'retain authorship' '
 265         echo A > file7 &&
 266         git add file7 &&
 267         test_tick &&
 268         GIT_AUTHOR_NAME="Twerp Snog" git commit -m "different author" &&
 269         git tag twerp &&
 270         set_fake_editor &&
 271         git rebase -i --onto master HEAD^ &&
 272         git show HEAD | grep "^Author: Twerp Snog"
 273 '
 274
 275 test_expect_success 'retain authorship w/ conflicts' '
 276         oGIT_AUTHOR_NAME=$GIT_AUTHOR_NAME &&
 277         test_when_finished "GIT_AUTHOR_NAME=\$oGIT_AUTHOR_NAME" &&
 278
 279         git reset --hard twerp &&
 280         test_commit a conflict a conflict-a &&
 281         git reset --hard twerp &&
 282
 283         GIT_AUTHOR_NAME=AttributeMe &&
 284         export GIT_AUTHOR_NAME &&
 285         test_commit b conflict b conflict-b &&
 286         GIT_AUTHOR_NAME=$oGIT_AUTHOR_NAME &&
 287
 288         set_fake_editor &&
 289         test_must_fail git rebase -i conflict-a &&
 290         echo resolved >conflict &&
 291         git add conflict &&
 292         git rebase --continue &&
 293         test $(git rev-parse conflict-a^0) = $(git rev-parse HEAD^) &&
 294         git show >out &&
 295         grep AttributeMe out
 296 '
 297
 298 test_expect_success 'squash' '
 299         git reset --hard twerp &&
 300         echo B > file7 &&
 301         test_tick &&
 302         GIT_AUTHOR_NAME="Nitfol" git commit -m "nitfol" file7 &&
 303         echo "******************************" &&
 304         set_fake_editor &&
 305         FAKE_LINES="1 squash 2" EXPECT_HEADER_COUNT=2 \
 306                 git rebase -i --onto master HEAD~2 &&
 307         test B = $(cat file7) &&
 308         test $(git rev-parse HEAD^) = $(git rev-parse master)
 309 '
 310
 311 test_expect_success 'retain authorship when squashing' '
 312         git show HEAD | grep "^Author: Twerp Snog"
 313 '
 314
 315 test_expect_success '-p handles "no changes" gracefully' '
 316         HEAD=$(git rev-parse HEAD) &&
 317         set_fake_editor &&
 318         git rebase -i -p HEAD^ &&
 319         git update-index --refresh &&
 320         git diff-files --quiet &&
 321         git diff-index --quiet --cached HEAD -- &&
 322         test $HEAD = $(git rev-parse HEAD)
 323 '
 324
 325 test_expect_failure 'exchange two commits with -p' '
 326         git checkout H &&
 327         set_fake_editor &&
 328         FAKE_LINES="2 1" git rebase -i -p HEAD~2 &&
 329         test H = $(git cat-file commit HEAD^ | sed -ne \$p) &&
 330         test G = $(git cat-file commit HEAD | sed -ne \$p)
 331 '
 332
 333 test_expect_success 'preserve merges with -p' '
 334         git checkout -b to-be-preserved master^ &&
 335         : > unrelated-file &&
 336         git add unrelated-file &&
 337         test_tick &&
 338         git commit -m "unrelated" &&
 339         git checkout -b another-branch master &&
 340         echo B > file1 &&
 341         test_tick &&
 342         git commit -m J file1 &&
 343         test_tick &&
 344         git merge to-be-preserved &&
 345         echo C > file1 &&
 346         test_tick &&
 347         git commit -m K file1 &&
 348         echo D > file1 &&
 349         test_tick &&
 350         git commit -m L1 file1 &&
 351         git checkout HEAD^ &&
 352         echo 1 > unrelated-file &&
 353         test_tick &&
 354         git commit -m L2 unrelated-file &&
 355         test_tick &&
 356         git merge another-branch &&
 357         echo E > file1 &&
 358         test_tick &&
 359         git commit -m M file1 &&
 360         git checkout -b to-be-rebased &&
 361         test_tick &&
 362         set_fake_editor &&
 363         git rebase -i -p --onto branch1 master &&
 364         git update-index --refresh &&
 365         git diff-files --quiet &&
 366         git diff-index --quiet --cached HEAD -- &&
 367         test $(git rev-parse HEAD~6) = $(git rev-parse branch1) &&
 368         test $(git rev-parse HEAD~4^2) = $(git rev-parse to-be-preserved) &&
 369         test $(git rev-parse HEAD^^2^) = $(git rev-parse HEAD^^^) &&
 370         test $(git show HEAD~5:file1) = B &&
 371         test $(git show HEAD~3:file1) = C &&
 372         test $(git show HEAD:file1) = E &&
 373         test $(git show HEAD:unrelated-file) = 1
 374 '
 375
 376 test_expect_success 'edit ancestor with -p' '
 377         set_fake_editor &&
 378         FAKE_LINES="1 2 edit 3 4" git rebase -i -p HEAD~3 &&
 379         echo 2 > unrelated-file &&
 380         test_tick &&
 381         git commit -m L2-modified --amend unrelated-file &&
 382         git rebase --continue &&
 383         git update-index --refresh &&
 384         git diff-files --quiet &&
 385         git diff-index --quiet --cached HEAD -- &&
 386         test $(git show HEAD:unrelated-file) = 2
 387 '
 388
 389 test_expect_success '--continue tries to commit' '
 390         test_tick &&
 391         set_fake_editor &&
 392         test_must_fail git rebase -i --onto new-branch1 HEAD^ &&
 393         echo resolved > file1 &&
 394         git add file1 &&
 395         FAKE_COMMIT_MESSAGE="chouette!" git rebase --continue &&
 396         test $(git rev-parse HEAD^) = $(git rev-parse new-branch1) &&
 397         git show HEAD | grep chouette
 398 '
 399
 400 test_expect_success 'verbose flag is heeded, even after --continue' '
 401         git reset --hard master@{1} &&
 402         test_tick &&
 403         set_fake_editor &&
 404         test_must_fail git rebase -v -i --onto new-branch1 HEAD^ &&
 405         echo resolved > file1 &&
 406         git add file1 &&
 407         git rebase --continue > output &&
 408         grep "^ file1 | 2 +-$" output
 409 '
 410
 411 test_expect_success C_LOCALE_OUTPUT 'multi-squash only fires up editor once' '
 412         base=$(git rev-parse HEAD~4) &&
 413         set_fake_editor &&
 414         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="1 squash 2 squash 3 squash 4" \
 415                 EXPECT_HEADER_COUNT=4 \
 416                 git rebase -i $base &&
 417         test $base = $(git rev-parse HEAD^) &&
 418         test 1 = $(git show | grep ONCE | wc -l)
 419 '
 420
 421 test_expect_success C_LOCALE_OUTPUT 'multi-fixup does not fire up editor' '
 422         git checkout -b multi-fixup E &&
 423         base=$(git rev-parse HEAD~4) &&
 424         set_fake_editor &&
 425         FAKE_COMMIT_AMEND="NEVER" FAKE_LINES="1 fixup 2 fixup 3 fixup 4" \
 426                 git rebase -i $base &&
 427         test $base = $(git rev-parse HEAD^) &&
 428         test 0 = $(git show | grep NEVER | wc -l) &&
 429         git checkout to-be-rebased &&
 430         git branch -D multi-fixup
 431 '
 432
 433 test_expect_success 'commit message used after conflict' '
 434         git checkout -b conflict-fixup conflict-branch &&
 435         base=$(git rev-parse HEAD~4) &&
 436         set_fake_editor &&
 437         test_must_fail env FAKE_LINES="1 fixup 3 fixup 4" git rebase -i $base &&
 438         echo three > conflict &&
 439         git add conflict &&
 440         FAKE_COMMIT_AMEND="ONCE" EXPECT_HEADER_COUNT=2 \
 441                 git rebase --continue &&
 442         test $base = $(git rev-parse HEAD^) &&
 443         test 1 = $(git show | grep ONCE | wc -l) &&
 444         git checkout to-be-rebased &&
 445         git branch -D conflict-fixup
 446 '
 447
 448 test_expect_success 'commit message retained after conflict' '
 449         git checkout -b conflict-squash conflict-branch &&
 450         base=$(git rev-parse HEAD~4) &&
 451         set_fake_editor &&
 452         test_must_fail env FAKE_LINES="1 fixup 3 squash 4" git rebase -i $base &&
 453         echo three > conflict &&
 454         git add conflict &&
 455         FAKE_COMMIT_AMEND="TWICE" EXPECT_HEADER_COUNT=2 \
 456                 git rebase --continue &&
 457         test $base = $(git rev-parse HEAD^) &&
 458         test 2 = $(git show | grep TWICE | wc -l) &&
 459         git checkout to-be-rebased &&
 460         git branch -D conflict-squash
 461 '
 462
 463 cat > expect-squash-fixup << EOF
 464 B
 465
 466 D
 467
 468 ONCE
 469 EOF
 470
 471 test_expect_success C_LOCALE_OUTPUT 'squash and fixup generate correct log messages' '
 472         git checkout -b squash-fixup E &&
 473         base=$(git rev-parse HEAD~4) &&
 474         set_fake_editor &&
 475         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="1 fixup 2 squash 3 fixup 4" \
 476                 EXPECT_HEADER_COUNT=4 \
 477                 git rebase -i $base &&
 478         git cat-file commit HEAD | sed -e 1,/^\$/d > actual-squash-fixup &&
 479         test_cmp expect-squash-fixup actual-squash-fixup &&
 480         git cat-file commit HEAD@{2} |
 481                 grep "^# This is a combination of 3 commits\."  &&
 482         git cat-file commit HEAD@{3} |
 483                 grep "^# This is a combination of 2 commits\."  &&
 484         git checkout to-be-rebased &&
 485         git branch -D squash-fixup
 486 '
 487
 488 test_expect_success C_LOCALE_OUTPUT 'squash ignores comments' '
 489         git checkout -b skip-comments E &&
 490         base=$(git rev-parse HEAD~4) &&
 491         set_fake_editor &&
 492         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="# 1 # squash 2 # squash 3 # squash 4 #" \
 493                 EXPECT_HEADER_COUNT=4 \
 494                 git rebase -i $base &&
 495         test $base = $(git rev-parse HEAD^) &&
 496         test 1 = $(git show | grep ONCE | wc -l) &&
 497         git checkout to-be-rebased &&
 498         git branch -D skip-comments
 499 '
 500
 501 test_expect_success C_LOCALE_OUTPUT 'squash ignores blank lines' '
 502         git checkout -b skip-blank-lines E &&
 503         base=$(git rev-parse HEAD~4) &&
 504         set_fake_editor &&
 505         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="> 1 > squash 2 > squash 3 > squash 4 >" \
 506                 EXPECT_HEADER_COUNT=4 \
 507                 git rebase -i $base &&
 508         test $base = $(git rev-parse HEAD^) &&
 509         test 1 = $(git show | grep ONCE | wc -l) &&
 510         git checkout to-be-rebased &&
 511         git branch -D skip-blank-lines
 512 '
 513
 514 test_expect_success 'squash works as expected' '
 515         git checkout -b squash-works no-conflict-branch &&
 516         one=$(git rev-parse HEAD~3) &&
 517         set_fake_editor &&
 518         FAKE_LINES="1 squash 3 2" EXPECT_HEADER_COUNT=2 \
 519                 git rebase -i HEAD~3 &&
 520         test $one = $(git rev-parse HEAD~2)
 521 '
 522
 523 test_expect_success 'interrupted squash works as expected' '
 524         git checkout -b interrupted-squash conflict-branch &&
 525         one=$(git rev-parse HEAD~3) &&
 526         set_fake_editor &&
 527         test_must_fail env FAKE_LINES="1 squash 3 2" git rebase -i HEAD~3 &&
 528         test_write_lines one two four > conflict &&
 529         git add conflict &&
 530         test_must_fail git rebase --continue &&
 531         echo resolved > conflict &&
 532         git add conflict &&
 533         git rebase --continue &&
 534         test $one = $(git rev-parse HEAD~2)
 535 '
 536
 537 test_expect_success 'interrupted squash works as expected (case 2)' '
 538         git checkout -b interrupted-squash2 conflict-branch &&
 539         one=$(git rev-parse HEAD~3) &&
 540         set_fake_editor &&
 541         test_must_fail env FAKE_LINES="3 squash 1 2" git rebase -i HEAD~3 &&
 542         test_write_lines one four > conflict &&
 543         git add conflict &&
 544         test_must_fail git rebase --continue &&
 545         test_write_lines one two four > conflict &&
 546         git add conflict &&
 547         test_must_fail git rebase --continue &&
 548         echo resolved > conflict &&
 549         git add conflict &&
 550         git rebase --continue &&
 551         test $one = $(git rev-parse HEAD~2)
 552 '
 553
 554 test_expect_success '--continue tries to commit, even for "edit"' '
 555         echo unrelated > file7 &&
 556         git add file7 &&
 557         test_tick &&
 558         git commit -m "unrelated change" &&
 559         parent=$(git rev-parse HEAD^) &&
 560         test_tick &&
 561         set_fake_editor &&
 562         FAKE_LINES="edit 1" git rebase -i HEAD^ &&
 563         echo edited > file7 &&
 564         git add file7 &&
 565         FAKE_COMMIT_MESSAGE="chouette!" git rebase --continue &&
 566         test edited = $(git show HEAD:file7) &&
 567         git show HEAD | grep chouette &&
 568         test $parent = $(git rev-parse HEAD^)
 569 '
 570
 571 test_expect_success 'aborted --continue does not squash commits after "edit"' '
 572         old=$(git rev-parse HEAD) &&
 573         test_tick &&
 574         set_fake_editor &&
 575         FAKE_LINES="edit 1" git rebase -i HEAD^ &&
 576         echo "edited again" > file7 &&
 577         git add file7 &&
 578         test_must_fail env FAKE_COMMIT_MESSAGE=" " git rebase --continue &&
 579         test $old = $(git rev-parse HEAD) &&
 580         git rebase --abort
 581 '
 582
 583 test_expect_success 'auto-amend only edited commits after "edit"' '
 584         test_tick &&
 585         set_fake_editor &&
 586         FAKE_LINES="edit 1" git rebase -i HEAD^ &&
 587         echo "edited again" > file7 &&
 588         git add file7 &&
 589         FAKE_COMMIT_MESSAGE="edited file7 again" git commit &&
 590         echo "and again" > file7 &&
 591         git add file7 &&
 592         test_tick &&
 593         test_must_fail env FAKE_COMMIT_MESSAGE="and again" git rebase --continue &&
 594         git rebase --abort
 595 '
 596
 597 test_expect_success 'clean error after failed "exec"' '
 598         test_tick &&
 599         test_when_finished "git rebase --abort || :" &&
 600         set_fake_editor &&
 601         test_must_fail env FAKE_LINES="1 exec_false" git rebase -i HEAD^ &&
 602         echo "edited again" > file7 &&
 603         git add file7 &&
 604         test_must_fail git rebase --continue 2>error &&
 605         test_i18ngrep "you have staged changes in your working tree" error
 606 '
 607
 608 test_expect_success 'rebase a detached HEAD' '
 609         grandparent=$(git rev-parse HEAD~2) &&
 610         git checkout $(git rev-parse HEAD) &&
 611         test_tick &&
 612         set_fake_editor &&
 613         FAKE_LINES="2 1" git rebase -i HEAD~2 &&
 614         test $grandparent = $(git rev-parse HEAD~2)
 615 '
 616
 617 test_expect_success 'rebase a commit violating pre-commit' '
 618
 619         mkdir -p .git/hooks &&
 620         write_script .git/hooks/pre-commit <<-\EOF &&
 621         test -z "$(git diff --cached --check)"
 622         EOF
 623         echo "monde! " >> file1 &&
 624         test_tick &&
 625         test_must_fail git commit -m doesnt-verify file1 &&
 626         git commit -m doesnt-verify --no-verify file1 &&
 627         test_tick &&
 628         set_fake_editor &&
 629         FAKE_LINES=2 git rebase -i HEAD~2
 630
 631 '
 632
 633 test_expect_success 'rebase with a file named HEAD in worktree' '
 634
 635         rm -fr .git/hooks &&
 636         git reset --hard &&
 637         git checkout -b branch3 A &&
 638
 639         (
 640                 GIT_AUTHOR_NAME="Squashed Away" &&
 641                 export GIT_AUTHOR_NAME &&
 642                 >HEAD &&
 643                 git add HEAD &&
 644                 git commit -m "Add head" &&
 645                 >BODY &&
 646                 git add BODY &&
 647                 git commit -m "Add body"
 648         ) &&
 649
 650         set_fake_editor &&
 651         FAKE_LINES="1 squash 2" git rebase -i to-be-rebased &&
 652         test "$(git show -s --pretty=format:%an)" = "Squashed Away"
 653
 654 '
 655
 656 test_expect_success 'do "noop" when there is nothing to cherry-pick' '
 657
 658         git checkout -b branch4 HEAD &&
 659         GIT_EDITOR=: git commit --amend \
 660                 --author="Somebody else <somebody@else.com>" &&
 661         test $(git rev-parse branch3) != $(git rev-parse branch4) &&
 662         set_fake_editor &&
 663         git rebase -i branch3 &&
 664         test $(git rev-parse branch3) = $(git rev-parse branch4)
 665
 666 '
 667
 668 test_expect_success 'submodule rebase setup' '
 669         git checkout A &&
 670         mkdir sub &&
 671         (
 672                 cd sub && git init && >elif &&
 673                 git add elif && git commit -m "submodule initial"
 674         ) &&
 675         echo 1 >file1 &&
 676         git add file1 sub &&
 677         test_tick &&
 678         git commit -m "One" &&
 679         echo 2 >file1 &&
 680         test_tick &&
 681         git commit -a -m "Two" &&
 682         (
 683                 cd sub && echo 3 >elif &&
 684                 git commit -a -m "submodule second"
 685         ) &&
 686         test_tick &&
 687         set_fake_editor &&
 688         git commit -a -m "Three changes submodule"
 689 '
 690
 691 test_expect_success 'submodule rebase -i' '
 692         set_fake_editor &&
 693         FAKE_LINES="1 squash 2 3" git rebase -i A
 694 '
 695
 696 test_expect_success 'submodule conflict setup' '
 697         git tag submodule-base &&
 698         git checkout HEAD^ &&
 699         (
 700                 cd sub && git checkout HEAD^ && echo 4 >elif &&
 701                 git add elif && git commit -m "submodule conflict"
 702         ) &&
 703         git add sub &&
 704         test_tick &&
 705         git commit -m "Conflict in submodule" &&
 706         git tag submodule-topic
 707 '
 708
 709 test_expect_success 'rebase -i continue with only submodule staged' '
 710         set_fake_editor &&
 711         test_must_fail git rebase -i submodule-base &&
 712         git add sub &&
 713         git rebase --continue &&
 714         test $(git rev-parse submodule-base) != $(git rev-parse HEAD)
 715 '
 716
 717 test_expect_success 'rebase -i continue with unstaged submodule' '
 718         git checkout submodule-topic &&
 719         git reset --hard &&
 720         set_fake_editor &&
 721         test_must_fail git rebase -i submodule-base &&
 722         git reset &&
 723         git rebase --continue &&
 724         test $(git rev-parse submodule-base) = $(git rev-parse HEAD)
 725 '
 726
 727 test_expect_success 'avoid unnecessary reset' '
 728         git checkout master &&
 729         git reset --hard &&
 730         test-tool chmtime =123456789 file3 &&
 731         git update-index --refresh &&
 732         HEAD=$(git rev-parse HEAD) &&
 733         set_fake_editor &&
 734         git rebase -i HEAD~4 &&
 735         test $HEAD = $(git rev-parse HEAD) &&
 736         MTIME=$(test-tool chmtime --get file3) &&
 737         test 123456789 = $MTIME
 738 '
 739
 740 test_expect_success 'reword' '
 741         git checkout -b reword-branch master &&
 742         set_fake_editor &&
 743         FAKE_LINES="1 2 3 reword 4" FAKE_COMMIT_MESSAGE="E changed" git rebase -i A &&
 744         git show HEAD | grep "E changed" &&
 745         test $(git rev-parse master) != $(git rev-parse HEAD) &&
 746         test $(git rev-parse master^) = $(git rev-parse HEAD^) &&
 747         FAKE_LINES="1 2 reword 3 4" FAKE_COMMIT_MESSAGE="D changed" git rebase -i A &&
 748         git show HEAD^ | grep "D changed" &&
 749         FAKE_LINES="reword 1 2 3 4" FAKE_COMMIT_MESSAGE="B changed" git rebase -i A &&
 750         git show HEAD~3 | grep "B changed" &&
 751         FAKE_LINES="1 reword 2 3 4" FAKE_COMMIT_MESSAGE="C changed" git rebase -i A &&
 752         git show HEAD~2 | grep "C changed"
 753 '
 754
 755 test_expect_success 'rebase -i can copy notes' '
 756         git config notes.rewrite.rebase true &&
 757         git config notes.rewriteRef "refs/notes/*" &&
 758         test_commit n1 &&
 759         test_commit n2 &&
 760         test_commit n3 &&
 761         git notes add -m"a note" n3 &&
 762         set_fake_editor &&
 763         git rebase -i --onto n1 n2 &&
 764         test "a note" = "$(git notes show HEAD)"
 765 '
 766
 767 cat >expect <<EOF
 768 an earlier note
 769
 770 a note
 771 EOF
 772
 773 test_expect_success 'rebase -i can copy notes over a fixup' '
 774         git reset --hard n3 &&
 775         git notes add -m"an earlier note" n2 &&
 776         set_fake_editor &&
 777         GIT_NOTES_REWRITE_MODE=concatenate FAKE_LINES="1 fixup 2" git rebase -i n1 &&
 778         git notes show > output &&
 779         test_cmp expect output
 780 '
 781
 782 test_expect_success 'rebase while detaching HEAD' '
 783         git symbolic-ref HEAD &&
 784         grandparent=$(git rev-parse HEAD~2) &&
 785         test_tick &&
 786         set_fake_editor &&
 787         FAKE_LINES="2 1" git rebase -i HEAD~2 HEAD^0 &&
 788         test $grandparent = $(git rev-parse HEAD~2) &&
 789         test_must_fail git symbolic-ref HEAD
 790 '
 791
 792 test_tick # Ensure that the rebased commits get a different timestamp.
 793 test_expect_success 'always cherry-pick with --no-ff' '
 794         git checkout no-ff-branch &&
 795         git tag original-no-ff-branch &&
 796         set_fake_editor &&
 797         git rebase -i --no-ff A &&
 798         for p in 0 1 2
 799         do
 800                 test ! $(git rev-parse HEAD~$p) = $(git rev-parse original-no-ff-branch~$p) &&
 801                 git diff HEAD~$p original-no-ff-branch~$p > out &&
 802                 test_must_be_empty out
 803         done &&
 804         test $(git rev-parse HEAD~3) = $(git rev-parse original-no-ff-branch~3) &&
 805         git diff HEAD~3 original-no-ff-branch~3 > out &&
 806         test_must_be_empty out
 807 '
 808
 809 test_expect_success 'set up commits with funny messages' '
 810         git checkout -b funny A &&
 811         echo >>file1 &&
 812         test_tick &&
 813         git commit -a -m "end with slash\\" &&
 814         echo >>file1 &&
 815         test_tick &&
 816         git commit -a -m "something (\000) that looks like octal" &&
 817         echo >>file1 &&
 818         test_tick &&
 819         git commit -a -m "something (\n) that looks like a newline" &&
 820         echo >>file1 &&
 821         test_tick &&
 822         git commit -a -m "another commit"
 823 '
 824
 825 test_expect_success 'rebase-i history with funny messages' '
 826         git rev-list A..funny >expect &&
 827         test_tick &&
 828         set_fake_editor &&
 829         FAKE_LINES="1 2 3 4" git rebase -i A &&
 830         git rev-list A.. >actual &&
 831         test_cmp expect actual
 832 '
 833
 834 test_expect_success 'prepare for rebase -i --exec' '
 835         git checkout master &&
 836         git checkout -b execute &&
 837         test_commit one_exec main.txt one_exec &&
 838         test_commit two_exec main.txt two_exec &&
 839         test_commit three_exec main.txt three_exec
 840 '
 841
 842 test_expect_success 'running "git rebase -i --exec git show HEAD"' '
 843         set_fake_editor &&
 844         git rebase -i --exec "git show HEAD" HEAD~2 >actual &&
 845         (
 846                 FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 847                 export FAKE_LINES &&
 848                 git rebase -i HEAD~2 >expect
 849         ) &&
 850         sed -e "1,9d" expect >expected &&
 851         test_cmp expected actual
 852 '
 853
 854 test_expect_success 'running "git rebase --exec git show HEAD -i"' '
 855         git reset --hard execute &&
 856         set_fake_editor &&
 857         git rebase --exec "git show HEAD" -i HEAD~2 >actual &&
 858         (
 859                 FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 860                 export FAKE_LINES &&
 861                 git rebase -i HEAD~2 >expect
 862         ) &&
 863         sed -e "1,9d" expect >expected &&
 864         test_cmp expected actual
 865 '
 866
 867 test_expect_success 'running "git rebase -ix git show HEAD"' '
 868         git reset --hard execute &&
 869         set_fake_editor &&
 870         git rebase -ix "git show HEAD" HEAD~2 >actual &&
 871         (
 872                 FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 873                 export FAKE_LINES &&
 874                 git rebase -i HEAD~2 >expect
 875         ) &&
 876         sed -e "1,9d" expect >expected &&
 877         test_cmp expected actual
 878 '
 879
 880
 881 test_expect_success 'rebase -ix with several <CMD>' '
 882         git reset --hard execute &&
 883         set_fake_editor &&
 884         git rebase -ix "git show HEAD; pwd" HEAD~2 >actual &&
 885         (
 886                 FAKE_LINES="1 exec_git_show_HEAD;_pwd 2 exec_git_show_HEAD;_pwd" &&
 887                 export FAKE_LINES &&
 888                 git rebase -i HEAD~2 >expect
 889         ) &&
 890         sed -e "1,9d" expect >expected &&
 891         test_cmp expected actual
 892 '
 893
 894 test_expect_success 'rebase -ix with several instances of --exec' '
 895         git reset --hard execute &&
 896         set_fake_editor &&
 897         git rebase -i --exec "git show HEAD" --exec "pwd" HEAD~2 >actual &&
 898         (
 899                 FAKE_LINES="1 exec_git_show_HEAD exec_pwd 2
 900                                 exec_git_show_HEAD exec_pwd" &&
 901                 export FAKE_LINES &&
 902                 git rebase -i HEAD~2 >expect
 903         ) &&
 904         sed -e "1,11d" expect >expected &&
 905         test_cmp expected actual
 906 '
 907
 908 test_expect_success C_LOCALE_OUTPUT 'rebase -ix with --autosquash' '
 909         git reset --hard execute &&
 910         git checkout -b autosquash &&
 911         echo second >second.txt &&
 912         git add second.txt &&
 913         git commit -m "fixup! two_exec" &&
 914         echo bis >bis.txt &&
 915         git add bis.txt &&
 916         git commit -m "fixup! two_exec" &&
 917         set_fake_editor &&
 918         (
 919                 git checkout -b autosquash_actual &&
 920                 git rebase -i --exec "git show HEAD" --autosquash HEAD~4 >actual
 921         ) &&
 922         git checkout autosquash &&
 923         (
 924                 git checkout -b autosquash_expected &&
 925                 FAKE_LINES="1 fixup 3 fixup 4 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 926                 export FAKE_LINES &&
 927                 git rebase -i HEAD~4 >expect
 928         ) &&
 929         sed -e "1,13d" expect >expected &&
 930         test_cmp expected actual
 931 '
 932
 933 test_expect_success 'rebase --exec works without -i ' '
 934         git reset --hard execute &&
 935         rm -rf exec_output &&
 936         EDITOR="echo >invoked_editor" git rebase --exec "echo a line >>exec_output"  HEAD~2 2>actual &&
 937         test_i18ngrep  "Successfully rebased and updated" actual &&
 938         test_line_count = 2 exec_output &&
 939         test_path_is_missing invoked_editor
 940 '
 941
 942 test_expect_success 'rebase -i --exec without <CMD>' '
 943         git reset --hard execute &&
 944         set_fake_editor &&
 945         test_must_fail git rebase -i --exec 2>actual &&
 946         test_i18ngrep "requires a value" actual &&
 947         git checkout master
 948 '
 949
 950 test_expect_success 'rebase -i --root re-order and drop commits' '
 951         git checkout E &&
 952         set_fake_editor &&
 953         FAKE_LINES="3 1 2 5" git rebase -i --root &&
 954         test E = $(git cat-file commit HEAD | sed -ne \$p) &&
 955         test B = $(git cat-file commit HEAD^ | sed -ne \$p) &&
 956         test A = $(git cat-file commit HEAD^^ | sed -ne \$p) &&
 957         test C = $(git cat-file commit HEAD^^^ | sed -ne \$p) &&
 958         test 0 = $(git cat-file commit HEAD^^^ | grep -c ^parent\ )
 959 '
 960
 961 test_expect_success 'rebase -i --root retain root commit author and message' '
 962         git checkout A &&
 963         echo B >file7 &&
 964         git add file7 &&
 965         GIT_AUTHOR_NAME="Twerp Snog" git commit -m "different author" &&
 966         set_fake_editor &&
 967         FAKE_LINES="2" git rebase -i --root &&
 968         git cat-file commit HEAD | grep -q "^author Twerp Snog" &&
 969         git cat-file commit HEAD | grep -q "^different author$"
 970 '
 971
 972 test_expect_success 'rebase -i --root temporary sentinel commit' '
 973         git checkout B &&
 974         set_fake_editor &&
 975         test_must_fail env FAKE_LINES="2" git rebase -i --root &&
 976         git cat-file commit HEAD | grep "^tree 4b825dc642cb" &&
 977         git rebase --abort
 978 '
 979
 980 test_expect_success 'rebase -i --root fixup root commit' '
 981         git checkout B &&
 982         set_fake_editor &&
 983         FAKE_LINES="1 fixup 2" git rebase -i --root &&
 984         test A = $(git cat-file commit HEAD | sed -ne \$p) &&
 985         test B = $(git show HEAD:file1) &&
 986         test 0 = $(git cat-file commit HEAD | grep -c ^parent\ )
 987 '
 988
 989 test_expect_success 'rebase -i --root reword root commit' '
 990         test_when_finished "test_might_fail git rebase --abort" &&
 991         git checkout -b reword-root-branch master &&
 992         set_fake_editor &&
 993         FAKE_LINES="reword 1 2" FAKE_COMMIT_MESSAGE="A changed" \
 994         git rebase -i --root &&
 995         git show HEAD^ | grep "A changed" &&
 996         test -z "$(git show -s --format=%p HEAD^)"
 997 '
 998
 999 test_expect_success 'rebase -i --root when root has untracked file confilct' '
1000         test_when_finished "reset_rebase" &&
1001         git checkout -b failing-root-pick A &&
1002         echo x >file2 &&
1003         git rm file1 &&
1004         git commit -m "remove file 1 add file 2" &&
1005         echo z >file1 &&
1006         set_fake_editor &&
1007         test_must_fail env FAKE_LINES="1 2" git rebase -i --root &&
1008         rm file1 &&
1009         git rebase --continue &&
1010         test "$(git log -1 --format=%B)" = "remove file 1 add file 2" &&
1011         test "$(git rev-list --count HEAD)" = 2
1012 '
1013
1014 test_expect_success 'rebase -i --root reword root when root has untracked file conflict' '
1015         test_when_finished "reset_rebase" &&
1016         echo z>file1 &&
1017         set_fake_editor &&
1018         test_must_fail env FAKE_LINES="reword 1 2" \
1019                 FAKE_COMMIT_MESSAGE="Modified A" git rebase -i --root &&
1020         rm file1 &&
1021         FAKE_COMMIT_MESSAGE="Reworded A" git rebase --continue &&
1022         test "$(git log -1 --format=%B HEAD^)" = "Reworded A" &&
1023         test "$(git rev-list --count HEAD)" = 2
1024 '
1025
1026 test_expect_success C_LOCALE_OUTPUT 'rebase --edit-todo does not work on non-interactive rebase' '
1027         git checkout reword-root-branch &&
1028         git reset --hard &&
1029         git checkout conflict-branch &&
1030         set_fake_editor &&
1031         test_must_fail git rebase --onto HEAD~2 HEAD~ &&
1032         test_must_fail git rebase --edit-todo &&
1033         git rebase --abort
1034 '
1035
1036 test_expect_success 'rebase --edit-todo can be used to modify todo' '
1037         git reset --hard &&
1038         git checkout no-conflict-branch^0 &&
1039         set_fake_editor &&
1040         FAKE_LINES="edit 1 2 3" git rebase -i HEAD~3 &&
1041         FAKE_LINES="2 1" git rebase --edit-todo &&
1042         git rebase --continue &&
1043         test M = $(git cat-file commit HEAD^ | sed -ne \$p) &&
1044         test L = $(git cat-file commit HEAD | sed -ne \$p)
1045 '
1046
1047 test_expect_success 'rebase -i produces readable reflog' '
1048         git reset --hard &&
1049         git branch -f branch-reflog-test H &&
1050         set_fake_editor &&
1051         git rebase -i --onto I F branch-reflog-test &&
1052         cat >expect <<-\EOF &&
1053         rebase -i (finish): returning to refs/heads/branch-reflog-test
1054         rebase -i (pick): H
1055         rebase -i (pick): G
1056         rebase -i (start): checkout I
1057         EOF
1058         git reflog -n4 HEAD |
1059         sed "s/[^:]*: //" >actual &&
1060         test_cmp expect actual
1061 '
1062
1063 test_expect_success 'rebase -i respects core.commentchar' '
1064         git reset --hard &&
1065         git checkout E^0 &&
1066         test_config core.commentchar "\\" &&
1067         write_script remove-all-but-first.sh <<-\EOF &&
1068         sed -e "2,\$s/^/\\\\/" "$1" >"$1.tmp" &&
1069         mv "$1.tmp" "$1"
1070         EOF
1071         test_set_editor "$(pwd)/remove-all-but-first.sh" &&
1072         git rebase -i B &&
1073         test B = $(git cat-file commit HEAD^ | sed -ne \$p)
1074 '
1075
1076 test_expect_success 'rebase -i respects core.commentchar=auto' '
1077         test_config core.commentchar auto &&
1078         write_script copy-edit-script.sh <<-\EOF &&
1079         cp "$1" edit-script
1080         EOF
1081         test_set_editor "$(pwd)/copy-edit-script.sh" &&
1082         test_when_finished "git rebase --abort || :" &&
1083         git rebase -i HEAD^ &&
1084         test -z "$(grep -ve "^#" -e "^\$" -e "^pick" edit-script)"
1085 '
1086
1087 test_expect_success 'rebase -i, with <onto> and <upstream> specified as :/quuxery' '
1088         test_when_finished "git branch -D torebase" &&
1089         git checkout -b torebase branch1 &&
1090         upstream=$(git rev-parse ":/J") &&
1091         onto=$(git rev-parse ":/A") &&
1092         git rebase --onto $onto $upstream &&
1093         git reset --hard branch1 &&
1094         git rebase --onto ":/A" ":/J" &&
1095         git checkout branch1
1096 '
1097
1098 test_expect_success 'rebase -i with --strategy and -X' '
1099         git checkout -b conflict-merge-use-theirs conflict-branch &&
1100         git reset --hard HEAD^ &&
1101         echo five >conflict &&
1102         echo Z >file1 &&
1103         git commit -a -m "one file conflict" &&
1104         EDITOR=true git rebase -i --strategy=recursive -Xours conflict-branch &&
1105         test $(git show conflict-branch:conflict) = $(cat conflict) &&
1106         test $(cat file1) = Z
1107 '
1108
1109 test_expect_success 'interrupted rebase -i with --strategy and -X' '
1110         git checkout -b conflict-merge-use-theirs-interrupted conflict-branch &&
1111         git reset --hard HEAD^ &&
1112         >breakpoint &&
1113         git add breakpoint &&
1114         git commit -m "breakpoint for interactive mode" &&
1115         echo five >conflict &&
1116         echo Z >file1 &&
1117         git commit -a -m "one file conflict" &&
1118         set_fake_editor &&
1119         FAKE_LINES="edit 1 2" git rebase -i --strategy=recursive -Xours conflict-branch &&
1120         git rebase --continue &&
1121         test $(git show conflict-branch:conflict) = $(cat conflict) &&
1122         test $(cat file1) = Z
1123 '
1124
1125 test_expect_success 'rebase -i error on commits with \ in message' '
1126         current_head=$(git rev-parse HEAD) &&
1127         test_when_finished "git rebase --abort; git reset --hard $current_head; rm -f error" &&
1128         test_commit TO-REMOVE will-conflict old-content &&
1129         test_commit "\temp" will-conflict new-content dummy &&
1130         test_must_fail env EDITOR=true git rebase -i HEAD^ --onto HEAD^^ 2>error &&
1131         test_expect_code 1 grep  "      emp" error
1132 '
1133
1134 test_expect_success 'short SHA-1 setup' '
1135         test_when_finished "git checkout master" &&
1136         git checkout --orphan collide &&
1137         git rm -rf . &&
1138         (
1139         unset test_tick &&
1140         test_commit collide1 collide &&
1141         test_commit --notick collide2 collide &&
1142         test_commit --notick collide3 collide
1143         )
1144 '
1145
1146 test_expect_success 'short SHA-1 collide' '
1147         test_when_finished "reset_rebase && git checkout master" &&
1148         git checkout collide &&
1149         (
1150         unset test_tick &&
1151         test_tick &&
1152         set_fake_editor &&
1153         FAKE_COMMIT_MESSAGE="collide2 ac4f2ee" \
1154         FAKE_LINES="reword 1 2" git rebase -i HEAD~2
1155         )
1156 '
1157
1158 test_expect_success 'respect core.abbrev' '
1159         git config core.abbrev 12 &&
1160         set_cat_todo_editor &&
1161         test_must_fail git rebase -i HEAD~4 >todo-list &&
1162         test 4 = $(grep -c "pick [0-9a-f]\{12,\}" todo-list)
1163 '
1164
1165 test_expect_success 'todo count' '
1166         write_script dump-raw.sh <<-\EOF &&
1167                 cat "$1"
1168         EOF
1169         test_set_editor "$(pwd)/dump-raw.sh" &&
1170         git rebase -i HEAD~4 >actual &&
1171         test_i18ngrep "^# Rebase ..* onto ..* ([0-9]" actual
1172 '
1173
1174 test_expect_success 'rebase -i commits that overwrite untracked files (pick)' '
1175         git checkout --force branch2 &&
1176         git clean -f &&
1177         set_fake_editor &&
1178         FAKE_LINES="edit 1 2" git rebase -i A &&
1179         test_cmp_rev HEAD F &&
1180         test_path_is_missing file6 &&
1181         >file6 &&
1182         test_must_fail git rebase --continue &&
1183         test_cmp_rev HEAD F &&
1184         rm file6 &&
1185         git rebase --continue &&
1186         test_cmp_rev HEAD I
1187 '
1188
1189 test_expect_success 'rebase -i commits that overwrite untracked files (squash)' '
1190         git checkout --force branch2 &&
1191         git clean -f &&
1192         git tag original-branch2 &&
1193         set_fake_editor &&
1194         FAKE_LINES="edit 1 squash 2" git rebase -i A &&
1195         test_cmp_rev HEAD F &&
1196         test_path_is_missing file6 &&
1197         >file6 &&
1198         test_must_fail git rebase --continue &&
1199         test_cmp_rev HEAD F &&
1200         rm file6 &&
1201         git rebase --continue &&
1202         test $(git cat-file commit HEAD | sed -ne \$p) = I &&
1203         git reset --hard original-branch2
1204 '
1205
1206 test_expect_success 'rebase -i commits that overwrite untracked files (no ff)' '
1207         git checkout --force branch2 &&
1208         git clean -f &&
1209         set_fake_editor &&
1210         FAKE_LINES="edit 1 2" git rebase -i --no-ff A &&
1211         test $(git cat-file commit HEAD | sed -ne \$p) = F &&
1212         test_path_is_missing file6 &&
1213         >file6 &&
1214         test_must_fail git rebase --continue &&
1215         test $(git cat-file commit HEAD | sed -ne \$p) = F &&
1216         rm file6 &&
1217         git rebase --continue &&
1218         test $(git cat-file commit HEAD | sed -ne \$p) = I
1219 '
1220
1221 test_expect_success 'rebase --continue removes CHERRY_PICK_HEAD' '
1222         git checkout -b commit-to-skip &&
1223         for double in X 3 1
1224         do
1225                 test_seq 5 | sed "s/$double/&&/" >seq &&
1226                 git add seq &&
1227                 test_tick &&
1228                 git commit -m seq-$double
1229         done &&
1230         git tag seq-onto &&
1231         git reset --hard HEAD~2 &&
1232         git cherry-pick seq-onto &&
1233         set_fake_editor &&
1234         test_must_fail env FAKE_LINES= git rebase -i seq-onto &&
1235         test -d .git/rebase-merge &&
1236         git rebase --continue &&
1237         git diff --exit-code seq-onto &&
1238         test ! -d .git/rebase-merge &&
1239         test ! -f .git/CHERRY_PICK_HEAD
1240 '
1241
1242 rebase_setup_and_clean () {
1243         test_when_finished "
1244                 git checkout master &&
1245                 test_might_fail git branch -D $1 &&
1246                 test_might_fail git rebase --abort
1247         " &&
1248         git checkout -b $1 ${2:-master}
1249 }
1250
1251 test_expect_success 'drop' '
1252         rebase_setup_and_clean drop-test &&
1253         set_fake_editor &&
1254         FAKE_LINES="1 drop 2 3 drop 4 5" git rebase -i --root &&
1255         test E = $(git cat-file commit HEAD | sed -ne \$p) &&
1256         test C = $(git cat-file commit HEAD^ | sed -ne \$p) &&
1257         test A = $(git cat-file commit HEAD^^ | sed -ne \$p)
1258 '
1259
1260 test_expect_success 'rebase -i respects rebase.missingCommitsCheck = ignore' '
1261         test_config rebase.missingCommitsCheck ignore &&
1262         rebase_setup_and_clean missing-commit &&
1263         set_fake_editor &&
1264         FAKE_LINES="1 2 3 4" \
1265                 git rebase -i --root 2>actual &&
1266         test D = $(git cat-file commit HEAD | sed -ne \$p) &&
1267         test_i18ngrep \
1268                 "Successfully rebased and updated refs/heads/missing-commit" \
1269                 actual
1270 '
1271
1272 cat >expect <<EOF
1273 Warning: some commits may have been dropped accidentally.
1274 Dropped commits (newer to older):
1275  - $(git rev-list --pretty=oneline --abbrev-commit -1 master)
1276 To avoid this message, use "drop" to explicitly remove a commit.
1277
1278 Use 'git config rebase.missingCommitsCheck' to change the level of warnings.
1279 The possible behaviours are: ignore, warn, error.
1280
1281 Rebasing (1/4)
1282 Rebasing (2/4)
1283 Rebasing (3/4)
1284 Rebasing (4/4)
1285 Successfully rebased and updated refs/heads/missing-commit.
1286 EOF
1287
1288 cr_to_nl () {
1289         tr '\015' '\012'
1290 }
1291
1292 test_expect_success 'rebase -i respects rebase.missingCommitsCheck = warn' '
1293         test_config rebase.missingCommitsCheck warn &&
1294         rebase_setup_and_clean missing-commit &&
1295         set_fake_editor &&
1296         FAKE_LINES="1 2 3 4" \
1297                 git rebase -i --root 2>actual.2 &&
1298         cr_to_nl <actual.2 >actual &&
1299         test_i18ncmp expect actual &&
1300         test D = $(git cat-file commit HEAD | sed -ne \$p)
1301 '
1302
1303 cat >expect <<EOF
1304 Warning: some commits may have been dropped accidentally.
1305 Dropped commits (newer to older):
1306  - $(git rev-list --pretty=oneline --abbrev-commit -1 master)
1307  - $(git rev-list --pretty=oneline --abbrev-commit -1 master~2)
1308 To avoid this message, use "drop" to explicitly remove a commit.
1309
1310 Use 'git config rebase.missingCommitsCheck' to change the level of warnings.
1311 The possible behaviours are: ignore, warn, error.
1312
1313 You can fix this with 'git rebase --edit-todo' and then run 'git rebase --continue'.
1314 Or you can abort the rebase with 'git rebase --abort'.
1315 EOF
1316
1317 test_expect_success 'rebase -i respects rebase.missingCommitsCheck = error' '
1318         test_config rebase.missingCommitsCheck error &&
1319         rebase_setup_and_clean missing-commit &&
1320         set_fake_editor &&
1321         test_must_fail env FAKE_LINES="1 2 4" \
1322                 git rebase -i --root 2>actual &&
1323         test_i18ncmp expect actual &&
1324         cp .git/rebase-merge/git-rebase-todo.backup \
1325                 .git/rebase-merge/git-rebase-todo &&
1326         FAKE_LINES="1 2 drop 3 4 drop 5" \
1327                 git rebase --edit-todo &&
1328         git rebase --continue &&
1329         test D = $(git cat-file commit HEAD | sed -ne \$p) &&
1330         test B = $(git cat-file commit HEAD^ | sed -ne \$p)
1331 '
1332
1333 test_expect_success 'respects rebase.abbreviateCommands with fixup, squash and exec' '
1334         rebase_setup_and_clean abbrevcmd &&
1335         test_commit "first" file1.txt "first line" first &&
1336         test_commit "second" file1.txt "another line" second &&
1337         test_commit "fixup! first" file2.txt "first line again" first_fixup &&
1338         test_commit "squash! second" file1.txt "another line here" second_squash &&
1339         cat >expected <<-EOF &&
1340         p $(git rev-list --abbrev-commit -1 first) first
1341         f $(git rev-list --abbrev-commit -1 first_fixup) fixup! first
1342         x git show HEAD
1343         p $(git rev-list --abbrev-commit -1 second) second
1344         s $(git rev-list --abbrev-commit -1 second_squash) squash! second
1345         x git show HEAD
1346         EOF
1347         git checkout abbrevcmd &&
1348         set_cat_todo_editor &&
1349         test_config rebase.abbreviateCommands true &&
1350         test_must_fail git rebase -i --exec "git show HEAD" \
1351                 --autosquash master >actual &&
1352         test_cmp expected actual
1353 '
1354
1355 test_expect_success 'static check of bad command' '
1356         rebase_setup_and_clean bad-cmd &&
1357         set_fake_editor &&
1358         test_must_fail env FAKE_LINES="1 2 3 bad 4 5" \
1359                 git rebase -i --root 2>actual &&
1360         test_i18ngrep "badcmd $(git rev-list --oneline -1 master~1)" actual &&
1361         test_i18ngrep "You can fix this with .git rebase --edit-todo.." actual &&
1362         FAKE_LINES="1 2 3 drop 4 5" git rebase --edit-todo &&
1363         git rebase --continue &&
1364         test E = $(git cat-file commit HEAD | sed -ne \$p) &&
1365         test C = $(git cat-file commit HEAD^ | sed -ne \$p)
1366 '
1367
1368 test_expect_success 'tabs and spaces are accepted in the todolist' '
1369         rebase_setup_and_clean indented-comment &&
1370         write_script add-indent.sh <<-\EOF &&
1371         (
1372                 # Turn single spaces into space/tab mix
1373                 sed "1s/ /      /g; 2s/ /  /g; 3s/ /    /g" "$1"
1374                 printf "\n\t# comment\n #more\n\t # comment\n"
1375         ) >"$1.new"
1376         mv "$1.new" "$1"
1377         EOF
1378         test_set_editor "$(pwd)/add-indent.sh" &&
1379         git rebase -i HEAD^^^ &&
1380         test E = $(git cat-file commit HEAD | sed -ne \$p)
1381 '
1382
1383 test_expect_success 'static check of bad SHA-1' '
1384         rebase_setup_and_clean bad-sha &&
1385         set_fake_editor &&
1386         test_must_fail env FAKE_LINES="1 2 edit fakesha 3 4 5 #" \
1387                 git rebase -i --root 2>actual &&
1388         test_i18ngrep "edit XXXXXXX False commit" actual &&
1389         test_i18ngrep "You can fix this with .git rebase --edit-todo.." actual &&
1390         FAKE_LINES="1 2 4 5 6" git rebase --edit-todo &&
1391         git rebase --continue &&
1392         test E = $(git cat-file commit HEAD | sed -ne \$p)
1393 '
1394
1395 test_expect_success 'editor saves as CR/LF' '
1396         git checkout -b with-crlf &&
1397         write_script add-crs.sh <<-\EOF &&
1398         sed -e "s/\$/Q/" <"$1" | tr Q "\\015" >"$1".new &&
1399         mv -f "$1".new "$1"
1400         EOF
1401         (
1402                 test_set_editor "$(pwd)/add-crs.sh" &&
1403                 git rebase -i HEAD^
1404         )
1405 '
1406
1407 SQ="'"
1408 test_expect_success 'rebase -i --gpg-sign=<key-id>' '
1409         test_when_finished "test_might_fail git rebase --abort" &&
1410         set_fake_editor &&
1411         FAKE_LINES="edit 1" git rebase -i --gpg-sign="\"S I Gner\"" HEAD^ \
1412                 >out 2>err &&
1413         test_i18ngrep "$SQ-S\"S I Gner\"$SQ" err
1414 '
1415
1416 test_expect_success 'rebase -i --gpg-sign=<key-id> overrides commit.gpgSign' '
1417         test_when_finished "test_might_fail git rebase --abort" &&
1418         test_config commit.gpgsign true &&
1419         set_fake_editor &&
1420         FAKE_LINES="edit 1" git rebase -i --gpg-sign="\"S I Gner\"" HEAD^ \
1421                 >out 2>err &&
1422         test_i18ngrep "$SQ-S\"S I Gner\"$SQ" err
1423 '
1424
1425 test_expect_success 'valid author header after --root swap' '
1426         rebase_setup_and_clean author-header no-conflict-branch &&
1427         set_fake_editor &&
1428         git commit --amend --author="Au ${SQ}thor <author@example.com>" --no-edit &&
1429         git cat-file commit HEAD | grep ^author >expected &&
1430         FAKE_LINES="5 1" git rebase -i --root &&
1431         git cat-file commit HEAD^ | grep ^author >actual &&
1432         test_cmp expected actual
1433 '
1434
1435 test_expect_success 'valid author header when author contains single quote' '
1436         rebase_setup_and_clean author-header no-conflict-branch &&
1437         set_fake_editor &&
1438         git commit --amend --author="Au ${SQ}thor <author@example.com>" --no-edit &&
1439         git cat-file commit HEAD | grep ^author >expected &&
1440         FAKE_LINES="2" git rebase -i HEAD~2 &&
1441         git cat-file commit HEAD | grep ^author >actual &&
1442         test_cmp expected actual
1443 '
1444
1445 test_done