regress/cmdline/histedit.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2019 Stefan Sperling <stsp@openbsd.org>
   4 #
   5 # Permission to use, copy, modify, and distribute this software for any
   6 # purpose with or without fee is hereby granted, provided that the above
   7 # copyright notice and this permission notice appear in all copies.
   8 #
   9 # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16
  17 . ./common.sh
  18
  19 test_histedit_no_op() {
  20         local testroot=`test_init histedit_no_op`
  21
  22         local orig_commit=`git_show_head $testroot/repo`
  23         local orig_author_time=`git_show_author_time $testroot/repo`
  24
  25         echo "modified alpha on master" > $testroot/repo/alpha
  26         git -C $testroot/repo rm -q beta
  27         echo "new file on master" > $testroot/repo/epsilon/new
  28         git -C $testroot/repo add epsilon/new
  29         git_commit $testroot/repo -m "committing changes"
  30         local old_commit1=`git_show_head $testroot/repo`
  31         local old_author_time1=`git_show_author_time $testroot/repo`
  32
  33         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
  34         git_commit $testroot/repo -m "committing to zeta on master"
  35         local old_commit2=`git_show_head $testroot/repo`
  36         local old_author_time2=`git_show_author_time $testroot/repo`
  37
  38         got diff -r $testroot/repo $orig_commit $old_commit2 \
  39                 > $testroot/diff.expected
  40
  41         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
  42         ret=$?
  43         if [ $ret -ne 0 ]; then
  44                 test_done "$testroot" "$ret"
  45                 return 1
  46         fi
  47
  48         echo "pick $old_commit1" > $testroot/histedit-script
  49         echo "pick $old_commit2" >> $testroot/histedit-script
  50
  51         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
  52                 > $testroot/stdout)
  53
  54         local new_commit1=`git_show_parent_commit $testroot/repo`
  55         local new_commit2=`git_show_head $testroot/repo`
  56         local new_author_time2=`git_show_author_time $testroot/repo`
  57
  58         local short_old_commit1=`trim_obj_id 12 $old_commit1`
  59         local short_old_commit2=`trim_obj_id 12 $old_commit2`
  60         local short_new_commit1=`trim_obj_id 12 $new_commit1`
  61         local short_new_commit2=`trim_obj_id 12 $new_commit2`
  62
  63         echo "G  alpha" > $testroot/stdout.expected
  64         echo "D  beta" >> $testroot/stdout.expected
  65         echo "A  epsilon/new" >> $testroot/stdout.expected
  66         echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
  67                 >> $testroot/stdout.expected
  68         echo "G  epsilon/zeta" >> $testroot/stdout.expected
  69         echo -n "$short_old_commit2 -> $short_new_commit2: " \
  70                 >> $testroot/stdout.expected
  71         echo "committing to zeta on master" >> $testroot/stdout.expected
  72         echo "Switching work tree to refs/heads/master" \
  73                 >> $testroot/stdout.expected
  74
  75         cmp -s $testroot/stdout.expected $testroot/stdout
  76         ret=$?
  77         if [ $ret -ne 0 ]; then
  78                 diff -u $testroot/stdout.expected $testroot/stdout
  79                 test_done "$testroot" "$ret"
  80                 return 1
  81         fi
  82
  83         echo "modified alpha on master" > $testroot/content.expected
  84         cat $testroot/wt/alpha > $testroot/content
  85         cmp -s $testroot/content.expected $testroot/content
  86         ret=$?
  87         if [ $ret -ne 0 ]; then
  88                 diff -u $testroot/content.expected $testroot/content
  89                 test_done "$testroot" "$ret"
  90                 return 1
  91         fi
  92
  93         if [ -e $testroot/wt/beta ]; then
  94                 echo "removed file beta still exists on disk" >&2
  95                 test_done "$testroot" "1"
  96                 return 1
  97         fi
  98
  99         echo "new file on master" > $testroot/content.expected
 100         cat $testroot/wt/epsilon/new > $testroot/content
 101         cmp -s $testroot/content.expected $testroot/content
 102         ret=$?
 103         if [ $ret -ne 0 ]; then
 104                 diff -u $testroot/content.expected $testroot/content
 105                 test_done "$testroot" "$ret"
 106                 return 1
 107         fi
 108
 109         (cd $testroot/wt && got status > $testroot/stdout)
 110
 111         echo -n > $testroot/stdout.expected
 112         cmp -s $testroot/stdout.expected $testroot/stdout
 113         ret=$?
 114         if [ $ret -ne 0 ]; then
 115                 diff -u $testroot/stdout.expected $testroot/stdout
 116                 test_done "$testroot" "$ret"
 117                 return 1
 118         fi
 119
 120         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 121         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 122         echo "commit $new_commit1" >> $testroot/stdout.expected
 123         echo "commit $orig_commit" >> $testroot/stdout.expected
 124         cmp -s $testroot/stdout.expected $testroot/stdout
 125         ret=$?
 126         if [ $ret -ne 0 ]; then
 127                 diff -u $testroot/stdout.expected $testroot/stdout
 128                 test_done "$testroot" "$ret"
 129                 return 1
 130         fi
 131
 132         got diff -r $testroot/repo $orig_commit $new_commit2 \
 133                 > $testroot/diff
 134         ed -s $testroot/diff.expected <<-EOF
 135         ,s/$old_commit2/$new_commit2/
 136         w
 137         EOF
 138         cmp -s $testroot/diff.expected $testroot/diff
 139         ret=$?
 140         if [ $ret -ne 0 ]; then
 141                 diff -u $testroot/diff.expected $testroot/diff
 142                 test_done "$testroot" "$ret"
 143                 return 1
 144         fi
 145
 146         (cd $testroot/wt && got update > $testroot/stdout)
 147
 148         echo 'Already up-to-date' > $testroot/stdout.expected
 149         cmp -s $testroot/stdout.expected $testroot/stdout
 150         ret=$?
 151         if [ $ret -ne 0 ]; then
 152                 diff -u $testroot/stdout.expected $testroot/stdout
 153                 test_done "$testroot" "$ret"
 154                 return 1
 155         fi
 156
 157         # We should have a backup of old commits
 158         (cd $testroot/repo && got histedit -l > $testroot/stdout)
 159         d_orig1=`date -u -r $old_author_time1 +"%F"`
 160         d_orig2=`date -u -r $old_author_time2 +"%a %b %e %X %Y UTC"`
 161         d_new2=`date -u -r $new_author_time2 +"%F"`
 162         d_orig=`date -u -r $orig_author_time +"%F"`
 163         cat > $testroot/stdout.expected <<EOF
 164 -----------------------------------------------
 165 commit $old_commit2 (formerly master)
 166 from: $GOT_AUTHOR
 167 date: $d_orig2
 168
 169  committing to zeta on master
 170
 171 has become commit $new_commit2 (master)
 172  $d_new2 $GOT_AUTHOR_11  committing to zeta on master
 173 EOF
 174
 175         local is_forked=true d_fork fork_commit fork_commit_msg
 176
 177         if [ "$old_commit1" = "$new_commit1" ]; then
 178                 if [ "$old_commit2" = "$new_commit2" ]; then
 179                         is_forked=false
 180                 else
 181                         d_fork=$d_orig1
 182                         fork_commit=$new_commit1
 183                         fork_commit_msg="committing changes"
 184                 fi
 185         else
 186                 d_fork=$d_orig
 187                 fork_commit=$orig_commit
 188                 fork_commit_msg="adding the test tree"
 189         fi
 190
 191         $is_forked && cat >> $testroot/stdout.expected <<EOF
 192 history forked at $fork_commit
 193  $d_fork $GOT_AUTHOR_11  $fork_commit_msg
 194 EOF
 195
 196         cmp -s $testroot/stdout.expected $testroot/stdout
 197         ret=$?
 198         if [ $ret -ne 0 ]; then
 199                 diff -u $testroot/stdout.expected $testroot/stdout
 200                 test_done "$testroot" "$ret"
 201                 return 1
 202         fi
 203
 204         (cd $testroot/repo && got histedit -X master \
 205                 > $testroot/stdout 2> $testroot/stderr)
 206         echo -n "Deleted refs/got/backup/histedit/master/$new_commit2: " \
 207                 > $testroot/stdout.expected
 208         echo "$old_commit2" >> $testroot/stdout.expected
 209         echo -n > $testroot/stderr.expected
 210         cmp -s $testroot/stdout.expected $testroot/stdout
 211         ret=$?
 212         if [ $ret -ne 0 ]; then
 213                 diff -u $testroot/stdout.expected $testroot/stdout
 214                 test_done "$testroot" "$ret"
 215                 return 1
 216         fi
 217         cmp -s $testroot/stderr.expected $testroot/stderr
 218         ret=$?
 219         if [ $ret -ne 0 ]; then
 220                 diff -u $testroot/stderr.expected $testroot/stderr
 221                 test_done "$testroot" "$ret"
 222                 return 1
 223         fi
 224
 225         (cd $testroot/repo && got histedit -l > $testroot/stdout)
 226         echo -n > $testroot/stdout.expected
 227         cmp -s $testroot/stdout.expected $testroot/stdout
 228         ret=$?
 229         if [ $ret -ne 0 ]; then
 230                 diff -u $testroot/stdout.expected $testroot/stdout
 231         fi
 232         test_done "$testroot" "$ret"
 233 }
 234
 235 test_histedit_swap() {
 236         local testroot=`test_init histedit_swap`
 237
 238         local orig_commit=`git_show_head $testroot/repo`
 239
 240         echo "modified alpha on master" > $testroot/repo/alpha
 241         git -C $testroot/repo rm -q beta
 242         echo "new file on master" > $testroot/repo/epsilon/new
 243         git -C $testroot/repo add epsilon/new
 244         git_commit $testroot/repo -m "committing changes"
 245         local old_commit1=`git_show_head $testroot/repo`
 246
 247         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 248         git_commit $testroot/repo -m "committing to zeta on master"
 249         local old_commit2=`git_show_head $testroot/repo`
 250
 251         got diff -r $testroot/repo $orig_commit $old_commit2 \
 252                 > $testroot/diff.expected
 253
 254         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 255         ret=$?
 256         if [ $ret -ne 0 ]; then
 257                 test_done "$testroot" "$ret"
 258                 return 1
 259         fi
 260
 261         echo "pick $old_commit2" > $testroot/histedit-script
 262         echo "pick $old_commit1" >> $testroot/histedit-script
 263
 264         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 265                 > $testroot/stdout)
 266
 267         local new_commit2=`git_show_parent_commit $testroot/repo`
 268         local new_commit1=`git_show_head $testroot/repo`
 269
 270         local short_old_commit1=`trim_obj_id 12 $old_commit1`
 271         local short_old_commit2=`trim_obj_id 12 $old_commit2`
 272         local short_new_commit1=`trim_obj_id 12 $new_commit1`
 273         local short_new_commit2=`trim_obj_id 12 $new_commit2`
 274
 275         echo "G  epsilon/zeta" > $testroot/stdout.expected
 276         echo -n "$short_old_commit2 -> $short_new_commit2: " \
 277                 >> $testroot/stdout.expected
 278         echo "committing to zeta on master" >> $testroot/stdout.expected
 279         echo "G  alpha" >> $testroot/stdout.expected
 280         echo "D  beta" >> $testroot/stdout.expected
 281         echo "A  epsilon/new" >> $testroot/stdout.expected
 282         echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
 283                 >> $testroot/stdout.expected
 284         echo "Switching work tree to refs/heads/master" \
 285                 >> $testroot/stdout.expected
 286
 287         cmp -s $testroot/stdout.expected $testroot/stdout
 288         ret=$?
 289         if [ $ret -ne 0 ]; then
 290                 diff -u $testroot/stdout.expected $testroot/stdout
 291                 test_done "$testroot" "$ret"
 292                 return 1
 293         fi
 294
 295         echo "modified alpha on master" > $testroot/content.expected
 296         cat $testroot/wt/alpha > $testroot/content
 297         cmp -s $testroot/content.expected $testroot/content
 298         ret=$?
 299         if [ $ret -ne 0 ]; then
 300                 diff -u $testroot/content.expected $testroot/content
 301                 test_done "$testroot" "$ret"
 302                 return 1
 303         fi
 304
 305         if [ -e $testroot/wt/beta ]; then
 306                 echo "removed file beta still exists on disk" >&2
 307                 test_done "$testroot" "1"
 308                 return 1
 309         fi
 310
 311         echo "new file on master" > $testroot/content.expected
 312         cat $testroot/wt/epsilon/new > $testroot/content
 313         cmp -s $testroot/content.expected $testroot/content
 314         ret=$?
 315         if [ $ret -ne 0 ]; then
 316                 diff -u $testroot/content.expected $testroot/content
 317                 test_done "$testroot" "$ret"
 318                 return 1
 319         fi
 320
 321         (cd $testroot/wt && got status > $testroot/stdout)
 322
 323         echo -n > $testroot/stdout.expected
 324         cmp -s $testroot/stdout.expected $testroot/stdout
 325         ret=$?
 326         if [ $ret -ne 0 ]; then
 327                 diff -u $testroot/stdout.expected $testroot/stdout
 328                 test_done "$testroot" "$ret"
 329                 return 1
 330         fi
 331
 332         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 333         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
 334         echo "commit $new_commit2" >> $testroot/stdout.expected
 335         echo "commit $orig_commit" >> $testroot/stdout.expected
 336         cmp -s $testroot/stdout.expected $testroot/stdout
 337         ret=$?
 338         if [ $ret -ne 0 ]; then
 339                 diff -u $testroot/stdout.expected $testroot/stdout
 340                 test_done "$testroot" "$ret"
 341                 return 1
 342         fi
 343
 344         got diff -r $testroot/repo $orig_commit $new_commit1 \
 345                 > $testroot/diff
 346         ed -s $testroot/diff.expected <<-EOF
 347         ,s/$old_commit2/$new_commit1/
 348         w
 349         EOF
 350         cmp -s $testroot/diff.expected $testroot/diff
 351         ret=$?
 352         if [ $ret -ne 0 ]; then
 353                 diff -u $testroot/diff.expected $testroot/diff
 354         fi
 355         test_done "$testroot" "$ret"
 356 }
 357
 358 test_histedit_drop() {
 359         local testroot=`test_init histedit_drop`
 360         local orig_commit=`git_show_head $testroot/repo`
 361
 362         echo "modified alpha on master" > $testroot/repo/alpha
 363         git -C $testroot/repo rm -q beta
 364         echo "new file on master" > $testroot/repo/epsilon/new
 365         git -C $testroot/repo add epsilon/new
 366         git_commit $testroot/repo -m "committing changes"
 367         local old_commit1=`git_show_head $testroot/repo`
 368
 369         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 370         git_commit $testroot/repo -m "committing to zeta on master"
 371         local old_commit2=`git_show_head $testroot/repo`
 372
 373         got diff -r $testroot/repo $old_commit1 $old_commit2 \
 374                 > $testroot/diff.expected
 375
 376         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 377         ret=$?
 378         if [ $ret -ne 0 ]; then
 379                 test_done "$testroot" "$ret"
 380                 return 1
 381         fi
 382
 383         echo "drop $old_commit1" > $testroot/histedit-script
 384         echo "pick $old_commit2" >> $testroot/histedit-script
 385
 386         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 387                 > $testroot/stdout)
 388
 389         local new_commit2=`git_show_head $testroot/repo`
 390
 391         local short_old_commit1=`trim_obj_id 12 $old_commit1`
 392         local short_old_commit2=`trim_obj_id 12 $old_commit2`
 393         local short_new_commit2=`trim_obj_id 12 $new_commit2`
 394
 395         echo "$short_old_commit1 ->  drop commit: committing changes" \
 396                 > $testroot/stdout.expected
 397         echo "G  epsilon/zeta" >> $testroot/stdout.expected
 398         echo -n "$short_old_commit2 -> $short_new_commit2: " \
 399                 >> $testroot/stdout.expected
 400         echo "committing to zeta on master" >> $testroot/stdout.expected
 401         echo "Switching work tree to refs/heads/master" \
 402                 >> $testroot/stdout.expected
 403
 404         cmp -s $testroot/stdout.expected $testroot/stdout
 405         ret=$?
 406         if [ $ret -ne 0 ]; then
 407                 diff -u $testroot/stdout.expected $testroot/stdout
 408                 test_done "$testroot" "$ret"
 409                 return 1
 410         fi
 411
 412         for f in alpha beta; do
 413                 echo "$f" > $testroot/content.expected
 414                 cat $testroot/wt/$f > $testroot/content
 415                 cmp -s $testroot/content.expected $testroot/content
 416                 ret=$?
 417                 if [ $ret -ne 0 ]; then
 418                         diff -u $testroot/content.expected $testroot/content
 419                         test_done "$testroot" "$ret"
 420                         return 1
 421                 fi
 422         done
 423
 424         if [ -e $testroot/wt/new ]; then
 425                 echo "file new exists on disk but should not" >&2
 426                 test_done "$testroot" "1"
 427                 return 1
 428         fi
 429
 430         (cd $testroot/wt && got status > $testroot/stdout)
 431
 432         echo -n > $testroot/stdout.expected
 433         cmp -s $testroot/stdout.expected $testroot/stdout
 434         ret=$?
 435         if [ $ret -ne 0 ]; then
 436                 diff -u $testroot/stdout.expected $testroot/stdout
 437                 test_done "$testroot" "$ret"
 438                 return 1
 439         fi
 440
 441         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 442         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 443         echo "commit $orig_commit" >> $testroot/stdout.expected
 444         cmp -s $testroot/stdout.expected $testroot/stdout
 445         ret=$?
 446         if [ $ret -ne 0 ]; then
 447                 diff -u $testroot/stdout.expected $testroot/stdout
 448                 test_done "$testroot" "$ret"
 449                 return 1
 450         fi
 451
 452         got diff -r $testroot/repo $orig_commit $new_commit2 \
 453                 > $testroot/diff
 454         ed -s $testroot/diff.expected <<-EOF
 455         ,s/$old_commit1/$orig_commit/
 456         ,s/$old_commit2/$new_commit2/
 457         w
 458         EOF
 459         cmp -s $testroot/diff.expected $testroot/diff
 460         ret=$?
 461         if [ $ret -ne 0 ]; then
 462                 diff -u $testroot/diff.expected $testroot/diff
 463         fi
 464         test_done "$testroot" "$ret"
 465 }
 466
 467 test_histedit_fold() {
 468         local testroot=`test_init histedit_fold`
 469
 470         local orig_commit=`git_show_head $testroot/repo`
 471
 472         echo "modified alpha on master" > $testroot/repo/alpha
 473         git -C $testroot/repo rm -q beta
 474         echo "new file on master" > $testroot/repo/epsilon/new
 475         git -C $testroot/repo add epsilon/new
 476         git_commit $testroot/repo -m "committing changes"
 477         local old_commit1=`git_show_head $testroot/repo`
 478
 479         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 480         git_commit $testroot/repo -m "committing to zeta on master"
 481         local old_commit2=`git_show_head $testroot/repo`
 482
 483         echo "modified delta on master" > $testroot/repo/gamma/delta
 484         git_commit $testroot/repo -m "committing to delta on master"
 485         local old_commit3=`git_show_head $testroot/repo`
 486
 487         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 488         ret=$?
 489         if [ $ret -ne 0 ]; then
 490                 test_done "$testroot" "$ret"
 491                 return 1
 492         fi
 493
 494         cat > $testroot/editor.sh <<EOF
 495 #!/bin/sh
 496 ed -s "\$1" <<-EOF
 497         ,s/.*/committing folded changes/
 498         w
 499         EOF
 500 EOF
 501         chmod +x $testroot/editor.sh
 502
 503         echo "fold $old_commit1" > $testroot/histedit-script
 504         echo "drop $old_commit2" >> $testroot/histedit-script
 505         echo "pick $old_commit3" >> $testroot/histedit-script
 506
 507         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
 508                 VISUAL="$testroot/editor.sh" \
 509                 got histedit -F $testroot/histedit-script > $testroot/stdout)
 510
 511         local new_commit1=`git_show_parent_commit $testroot/repo`
 512         local new_commit2=`git_show_head $testroot/repo`
 513
 514         local short_old_commit1=`trim_obj_id 12 $old_commit1`
 515         local short_old_commit2=`trim_obj_id 12 $old_commit2`
 516         local short_old_commit3=`trim_obj_id 12 $old_commit3`
 517         local short_new_commit1=`trim_obj_id 12 $new_commit1`
 518         local short_new_commit2=`trim_obj_id 12 $new_commit2`
 519
 520         echo "G  alpha" > $testroot/stdout.expected
 521         echo "D  beta" >> $testroot/stdout.expected
 522         echo "A  epsilon/new" >> $testroot/stdout.expected
 523         echo "$short_old_commit1 ->  fold commit: committing changes" \
 524                 >> $testroot/stdout.expected
 525         echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
 526         echo "drop commit: committing to zeta on master" \
 527                 >> $testroot/stdout.expected
 528         echo "G  gamma/delta" >> $testroot/stdout.expected
 529         echo -n "$short_old_commit3 -> $short_new_commit2: " \
 530                 >> $testroot/stdout.expected
 531         echo "committing folded changes" >> $testroot/stdout.expected
 532         echo "Switching work tree to refs/heads/master" \
 533                 >> $testroot/stdout.expected
 534
 535         cmp -s $testroot/stdout.expected $testroot/stdout
 536         ret=$?
 537         if [ $ret -ne 0 ]; then
 538                 diff -u $testroot/stdout.expected $testroot/stdout
 539                 test_done "$testroot" "$ret"
 540                 return 1
 541         fi
 542
 543         echo "modified alpha on master" > $testroot/content.expected
 544         cat $testroot/wt/alpha > $testroot/content
 545         cmp -s $testroot/content.expected $testroot/content
 546         ret=$?
 547         if [ $ret -ne 0 ]; then
 548                 diff -u $testroot/content.expected $testroot/content
 549                 test_done "$testroot" "$ret"
 550                 return 1
 551         fi
 552
 553         if [ -e $testroot/wt/beta ]; then
 554                 echo "removed file beta still exists on disk" >&2
 555                 test_done "$testroot" "1"
 556                 return 1
 557         fi
 558
 559         echo "new file on master" > $testroot/content.expected
 560         cat $testroot/wt/epsilon/new > $testroot/content
 561         cmp -s $testroot/content.expected $testroot/content
 562         ret=$?
 563         if [ $ret -ne 0 ]; then
 564                 diff -u $testroot/content.expected $testroot/content
 565                 test_done "$testroot" "$ret"
 566                 return 1
 567         fi
 568
 569         (cd $testroot/wt && got status > $testroot/stdout)
 570
 571         echo -n > $testroot/stdout.expected
 572         cmp -s $testroot/stdout.expected $testroot/stdout
 573         ret=$?
 574         if [ $ret -ne 0 ]; then
 575                 diff -u $testroot/stdout.expected $testroot/stdout
 576                 test_done "$testroot" "$ret"
 577                 return 1
 578         fi
 579
 580         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 581         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 582         echo "commit $orig_commit" >> $testroot/stdout.expected
 583         cmp -s $testroot/stdout.expected $testroot/stdout
 584         ret=$?
 585         if [ $ret -ne 0 ]; then
 586                 diff -u $testroot/stdout.expected $testroot/stdout
 587         fi
 588         test_done "$testroot" "$ret"
 589 }
 590
 591 test_histedit_edit() {
 592         local testroot=`test_init histedit_edit`
 593
 594         local orig_commit=`git_show_head $testroot/repo`
 595
 596         echo "modified alpha on master" > $testroot/repo/alpha
 597         git -C $testroot/repo rm -q beta
 598         echo "new file on master" > $testroot/repo/epsilon/new
 599         git -C $testroot/repo add epsilon/new
 600         git_commit $testroot/repo -m "committing changes"
 601         local old_commit1=`git_show_head $testroot/repo`
 602
 603         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 604         git_commit $testroot/repo -m "committing to zeta on master"
 605         local old_commit2=`git_show_head $testroot/repo`
 606
 607         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 608         ret=$?
 609         if [ $ret -ne 0 ]; then
 610                 test_done "$testroot" "$ret"
 611                 return 1
 612         fi
 613
 614         echo "edit $old_commit1" > $testroot/histedit-script
 615         echo "pick $old_commit2" >> $testroot/histedit-script
 616
 617         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 618                 > $testroot/stdout)
 619
 620         local short_old_commit1=`trim_obj_id 12 $old_commit1`
 621         local short_old_commit2=`trim_obj_id 12 $old_commit2`
 622
 623         echo "G  alpha" > $testroot/stdout.expected
 624         echo "D  beta" >> $testroot/stdout.expected
 625         echo "A  epsilon/new" >> $testroot/stdout.expected
 626         echo "Stopping histedit for amending commit $old_commit1" \
 627                 >> $testroot/stdout.expected
 628         cmp -s $testroot/stdout.expected $testroot/stdout
 629         ret=$?
 630         if [ $ret -ne 0 ]; then
 631                 diff -u $testroot/stdout.expected $testroot/stdout
 632                 test_done "$testroot" "$ret"
 633                 return 1
 634         fi
 635
 636         echo "edited modified alpha on master" > $testroot/wt/alpha
 637
 638         # test interaction of 'got stage' and histedit -c
 639         (cd $testroot/wt && got stage alpha > /dev/null)
 640         (cd $testroot/wt && got histedit -c > $testroot/stdout \
 641                 2> $testroot/stderr)
 642         ret=$?
 643         if [ $ret -eq 0 ]; then
 644                 echo "histedit succeeded unexpectedly" >&2
 645                 test_done "$testroot" "1"
 646                 return 1
 647         fi
 648         echo -n "got: work tree contains files with staged changes; " \
 649                 > $testroot/stderr.expected
 650         echo "these changes must be committed or unstaged first" \
 651                 >> $testroot/stderr.expected
 652         cmp -s $testroot/stderr.expected $testroot/stderr
 653         ret=$?
 654         if [ $ret -ne 0 ]; then
 655                 diff -u $testroot/stderr.expected $testroot/stderr
 656                 test_done "$testroot" "$ret"
 657                 return 1
 658         fi
 659
 660         (cd $testroot/wt && got unstage alpha > /dev/null)
 661
 662         cat > $testroot/editor.sh <<EOF
 663 #!/bin/sh
 664 ed -s "\$1" <<-EOF
 665         ,s/.*/committing changes/
 666         w
 667         EOF
 668 EOF
 669         chmod +x $testroot/editor.sh
 670
 671         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
 672                 VISUAL="$testroot/editor.sh" \
 673                 got histedit -c > $testroot/stdout)
 674
 675         local new_commit1=`git_show_parent_commit $testroot/repo`
 676         local new_commit2=`git_show_head $testroot/repo`
 677
 678         local short_new_commit1=`trim_obj_id 12 $new_commit1`
 679         local short_new_commit2=`trim_obj_id 12 $new_commit2`
 680
 681         echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
 682                 > $testroot/stdout.expected
 683         echo "G  epsilon/zeta" >> $testroot/stdout.expected
 684         echo -n "$short_old_commit2 -> $short_new_commit2: " \
 685                 >> $testroot/stdout.expected
 686         echo "committing to zeta on master" >> $testroot/stdout.expected
 687         echo "Switching work tree to refs/heads/master" \
 688                 >> $testroot/stdout.expected
 689
 690         cmp -s $testroot/stdout.expected $testroot/stdout
 691         ret=$?
 692         if [ $ret -ne 0 ]; then
 693                 diff -u $testroot/stdout.expected $testroot/stdout
 694                 test_done "$testroot" "$ret"
 695                 return 1
 696         fi
 697
 698         echo "edited modified alpha on master" > $testroot/content.expected
 699         cat $testroot/wt/alpha > $testroot/content
 700         cmp -s $testroot/content.expected $testroot/content
 701         ret=$?
 702         if [ $ret -ne 0 ]; then
 703                 diff -u $testroot/content.expected $testroot/content
 704                 test_done "$testroot" "$ret"
 705                 return 1
 706         fi
 707
 708         if [ -e $testroot/wt/beta ]; then
 709                 echo "removed file beta still exists on disk" >&2
 710                 test_done "$testroot" "1"
 711                 return 1
 712         fi
 713
 714         echo "new file on master" > $testroot/content.expected
 715         cat $testroot/wt/epsilon/new > $testroot/content
 716         cmp -s $testroot/content.expected $testroot/content
 717         ret=$?
 718         if [ $ret -ne 0 ]; then
 719                 diff -u $testroot/content.expected $testroot/content
 720                 test_done "$testroot" "$ret"
 721                 return 1
 722         fi
 723
 724         (cd $testroot/wt && got status > $testroot/stdout)
 725
 726         echo -n > $testroot/stdout.expected
 727         cmp -s $testroot/stdout.expected $testroot/stdout
 728         ret=$?
 729         if [ $ret -ne 0 ]; then
 730                 diff -u $testroot/stdout.expected $testroot/stdout
 731                 test_done "$testroot" "$ret"
 732                 return 1
 733         fi
 734
 735         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 736         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 737         echo "commit $new_commit1" >> $testroot/stdout.expected
 738         echo "commit $orig_commit" >> $testroot/stdout.expected
 739         cmp -s $testroot/stdout.expected $testroot/stdout
 740         ret=$?
 741         if [ $ret -ne 0 ]; then
 742                 diff -u $testroot/stdout.expected $testroot/stdout
 743         fi
 744         test_done "$testroot" "$ret"
 745 }
 746
 747 test_histedit_fold_last_commit() {
 748         local testroot=`test_init histedit_fold_last_commit`
 749
 750         local orig_commit=`git_show_head $testroot/repo`
 751
 752         echo "modified alpha on master" > $testroot/repo/alpha
 753         git -C $testroot/repo rm -q beta
 754         echo "new file on master" > $testroot/repo/epsilon/new
 755         git -C $testroot/repo add epsilon/new
 756         git_commit $testroot/repo -m "committing changes"
 757         local old_commit1=`git_show_head $testroot/repo`
 758
 759         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 760         git_commit $testroot/repo -m "committing to zeta on master"
 761         local old_commit2=`git_show_head $testroot/repo`
 762
 763         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 764         ret=$?
 765         if [ $ret -ne 0 ]; then
 766                 test_done "$testroot" "$ret"
 767                 return 1
 768         fi
 769
 770         echo "pick $old_commit1" > $testroot/histedit-script
 771         echo "fold $old_commit2" >> $testroot/histedit-script
 772
 773         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 774                 > $testroot/stdout 2> $testroot/stderr)
 775
 776         ret=$?
 777         if [ $ret -eq 0 ]; then
 778                 echo "histedit succeeded unexpectedly" >&2
 779                 test_done "$testroot" "1"
 780                 return 1
 781         fi
 782
 783         echo "got: last commit in histedit script cannot be folded" \
 784                 > $testroot/stderr.expected
 785
 786         cmp -s $testroot/stderr.expected $testroot/stderr
 787         ret=$?
 788         if [ $ret -ne 0 ]; then
 789                 diff -u $testroot/stderr.expected $testroot/stderr
 790         fi
 791         test_done "$testroot" "$ret"
 792 }
 793
 794 test_histedit_missing_commit_pick() {
 795         local testroot=`test_init histedit_missing_commit`
 796
 797         local orig_commit=`git_show_head $testroot/repo`
 798
 799         echo "modified alpha on master" > $testroot/repo/alpha
 800         git -C $testroot/repo rm -q beta
 801         echo "new file on master" > $testroot/repo/epsilon/new
 802         git -C $testroot/repo add epsilon/new
 803         git_commit $testroot/repo -m "committing changes"
 804         local old_commit1=`git_show_head $testroot/repo`
 805
 806         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 807         git_commit $testroot/repo -m "committing to zeta on master"
 808         local old_commit2=`git_show_head $testroot/repo`
 809
 810         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 811         ret=$?
 812         if [ $ret -ne 0 ]; then
 813                 test_done "$testroot" "$ret"
 814                 return 1
 815         fi
 816
 817         echo "pick $old_commit1" > $testroot/histedit-script
 818
 819         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 820                 > $testroot/stdout 2> $testroot/stderr)
 821
 822         ret=$?
 823         if [ $ret -eq 0 ]; then
 824                 echo "histedit succeeded unexpectedly" >&2
 825                 test_done "$testroot" "1"
 826                 return 1
 827         fi
 828
 829         echo "got: commit $old_commit2 missing from histedit script" \
 830                 > $testroot/stderr.expected
 831
 832         cmp -s $testroot/stderr.expected $testroot/stderr
 833         ret=$?
 834         if [ $ret -ne 0 ]; then
 835                 diff -u $testroot/stderr.expected $testroot/stderr
 836         fi
 837         test_done "$testroot" "$ret"
 838 }
 839
 840 test_histedit_missing_commit_mesg() {
 841         local testroot=`test_init histedit_missing_commit`
 842
 843         local orig_commit=`git_show_head $testroot/repo`
 844
 845         echo "modified alpha on master" > $testroot/repo/alpha
 846         git -C $testroot/repo rm -q beta
 847         echo "new file on master" > $testroot/repo/epsilon/new
 848         git -C $testroot/repo add epsilon/new
 849         git_commit $testroot/repo -m "committing changes"
 850         local old_commit1=`git_show_head $testroot/repo`
 851
 852         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 853         git_commit $testroot/repo -m "committing to zeta on master"
 854         local old_commit2=`git_show_head $testroot/repo`
 855
 856         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 857         ret=$?
 858         if [ $ret -ne 0 ]; then
 859                 test_done "$testroot" "$ret"
 860                 return 1
 861         fi
 862
 863         cat > $testroot/editor.sh <<EOF
 864 #!/bin/sh
 865 ed -s "\$1" <<-EOF
 866         ,s/.*/committing folded changes/
 867         w
 868         EOF
 869 EOF
 870         chmod +x $testroot/editor.sh
 871
 872         echo "mesg $old_commit1" > $testroot/histedit-script
 873
 874         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
 875                 VISUAL="$testroot/editor.sh" \
 876                 got histedit -F $testroot/histedit-script > $testroot/stdout \
 877                         2>$testroot/stderr)
 878
 879         ret=$?
 880         if [ $ret -eq 0 ]; then
 881                 echo "histedit succeeded unexpectedly" >&2
 882                 test_done "$testroot" "1"
 883                 return 1
 884         fi
 885
 886         echo "got: commit $old_commit2 missing from histedit script" \
 887                 > $testroot/stderr.expected
 888
 889         cmp -s $testroot/stderr.expected $testroot/stderr
 890         ret=$?
 891         if [ $ret -ne 0 ]; then
 892                 diff -u $testroot/stderr.expected $testroot/stderr
 893         fi
 894         test_done "$testroot" "$ret"
 895 }
 896
 897 test_histedit_abort() {
 898         local testroot=`test_init histedit_abort`
 899
 900         local orig_commit=`git_show_head $testroot/repo`
 901
 902         echo "modified alpha on master" > $testroot/repo/alpha
 903         git -C $testroot/repo rm -q beta
 904         echo "new file on master" > $testroot/repo/epsilon/new
 905         git -C $testroot/repo add epsilon/new
 906         git_commit $testroot/repo -m "committing changes"
 907         local old_commit1=`git_show_head $testroot/repo`
 908
 909         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 910         git_commit $testroot/repo -m "committing to zeta on master"
 911         local old_commit2=`git_show_head $testroot/repo`
 912
 913         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 914         ret=$?
 915         if [ $ret -ne 0 ]; then
 916                 test_done "$testroot" "$ret"
 917                 return 1
 918         fi
 919
 920         # unrelated unversioned file in work tree
 921         touch $testroot/wt/unversioned-file
 922
 923         echo "edit $old_commit1" > $testroot/histedit-script
 924         echo "pick $old_commit2" >> $testroot/histedit-script
 925
 926         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 927                 > $testroot/stdout)
 928
 929         local short_old_commit1=`trim_obj_id 12 $old_commit1`
 930         local short_old_commit2=`trim_obj_id 12 $old_commit2`
 931
 932         echo "G  alpha" > $testroot/stdout.expected
 933         echo "D  beta" >> $testroot/stdout.expected
 934         echo "A  epsilon/new" >> $testroot/stdout.expected
 935         echo "Stopping histedit for amending commit $old_commit1" \
 936                 >> $testroot/stdout.expected
 937         cmp -s $testroot/stdout.expected $testroot/stdout
 938         ret=$?
 939         if [ $ret -ne 0 ]; then
 940                 diff -u $testroot/stdout.expected $testroot/stdout
 941                 test_done "$testroot" "$ret"
 942                 return 1
 943         fi
 944
 945         echo "edited modified alpha on master" > $testroot/wt/alpha
 946
 947         (cd $testroot/wt && got histedit -a > $testroot/stdout)
 948
 949         local new_commit1=`git_show_parent_commit $testroot/repo`
 950         local new_commit2=`git_show_head $testroot/repo`
 951
 952         echo "Switching work tree to refs/heads/master" \
 953                 > $testroot/stdout.expected
 954         echo "R  alpha" >> $testroot/stdout.expected
 955         echo "R  beta" >> $testroot/stdout.expected
 956         echo "R  epsilon/new" >> $testroot/stdout.expected
 957         echo "Histedit of refs/heads/master aborted" \
 958                 >> $testroot/stdout.expected
 959
 960         cmp -s $testroot/stdout.expected $testroot/stdout
 961         ret=$?
 962         if [ $ret -ne 0 ]; then
 963                 diff -u $testroot/stdout.expected $testroot/stdout
 964                 test_done "$testroot" "$ret"
 965                 return 1
 966         fi
 967
 968         for f in alpha beta; do
 969                 echo "$f" > $testroot/content.expected
 970                 cat $testroot/wt/$f > $testroot/content
 971                 cmp -s $testroot/content.expected $testroot/content
 972                 ret=$?
 973                 if [ $ret -ne 0 ]; then
 974                         diff -u $testroot/content.expected $testroot/content
 975                         test_done "$testroot" "$ret"
 976                         return 1
 977                 fi
 978         done
 979
 980         if [ -e $testroot/wt/epsilon/new ]; then
 981                 echo "removed file new still exists on disk" >&2
 982                 test_done "$testroot" "1"
 983                 return 1
 984         fi
 985
 986         (cd $testroot/wt && got status > $testroot/stdout)
 987
 988         echo "?  unversioned-file" > $testroot/stdout.expected
 989         cmp -s $testroot/stdout.expected $testroot/stdout
 990         ret=$?
 991         if [ $ret -ne 0 ]; then
 992                 diff -u $testroot/stdout.expected $testroot/stdout
 993                 test_done "$testroot" "$ret"
 994                 return 1
 995         fi
 996
 997         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 998         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 999         echo "commit $new_commit1" >> $testroot/stdout.expected
1000         echo "commit $orig_commit" >> $testroot/stdout.expected
1001         cmp -s $testroot/stdout.expected $testroot/stdout
1002         ret=$?
1003         if [ $ret -ne 0 ]; then
1004                 diff -u $testroot/stdout.expected $testroot/stdout
1005         fi
1006         test_done "$testroot" "$ret"
1007 }
1008
1009 test_histedit_path_prefix_drop() {
1010         local testroot=`test_init histedit_path_prefix_drop`
1011         local orig_commit=`git_show_head $testroot/repo`
1012
1013         echo "modified zeta" > $testroot/repo/epsilon/zeta
1014         git_commit $testroot/repo -m "changing zeta"
1015         local old_commit1=`git_show_head $testroot/repo`
1016
1017         got checkout -c $orig_commit -p gamma $testroot/repo \
1018                 $testroot/wt > /dev/null
1019         ret=$?
1020         if [ $ret -ne 0 ]; then
1021                 test_done "$testroot" "$ret"
1022                 return 1
1023         fi
1024
1025         echo "drop $old_commit1" > $testroot/histedit-script
1026
1027         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1028                 > $testroot/stdout 2> $testroot/stderr)
1029
1030         ret=$?
1031         if [ $ret -eq 0 ]; then
1032                 echo "histedit succeeded unexpectedly" >&2
1033                 test_done "$testroot" "1"
1034                 return 1
1035         fi
1036
1037         echo -n "got: cannot edit branch history which contains changes " \
1038                 > $testroot/stderr.expected
1039         echo "outside of this work tree's path prefix" \
1040                 >> $testroot/stderr.expected
1041
1042         cmp -s $testroot/stderr.expected $testroot/stderr
1043         ret=$?
1044         if [ $ret -ne 0 ]; then
1045                 diff -u $testroot/stderr.expected $testroot/stderr
1046                 test_done "$testroot" "$ret"
1047                 return 1
1048         fi
1049
1050         rm -rf $testroot/wt
1051         got checkout -c $orig_commit -p epsilon $testroot/repo \
1052                 $testroot/wt > /dev/null
1053         ret=$?
1054         if [ $ret -ne 0 ]; then
1055                 test_done "$testroot" "$ret"
1056                 return 1
1057         fi
1058         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1059                 > $testroot/stdout)
1060
1061         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1062         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1063
1064         echo "$short_old_commit1 ->  drop commit: changing zeta" \
1065                 > $testroot/stdout.expected
1066         echo "Switching work tree to refs/heads/master" \
1067                 >> $testroot/stdout.expected
1068
1069         cmp -s $testroot/stdout.expected $testroot/stdout
1070         ret=$?
1071         if [ $ret -ne 0 ]; then
1072                 diff -u $testroot/stdout.expected $testroot/stdout
1073                 test_done "$testroot" "$ret"
1074                 return 1
1075         fi
1076
1077         echo "zeta" > $testroot/content.expected
1078         cat $testroot/wt/zeta > $testroot/content
1079         cmp -s $testroot/content.expected $testroot/content
1080         ret=$?
1081         if [ $ret -ne 0 ]; then
1082                 diff -u $testroot/content.expected $testroot/content
1083                 test_done "$testroot" "$ret"
1084                 return 1
1085         fi
1086
1087
1088         (cd $testroot/wt && got status > $testroot/stdout)
1089
1090         echo -n > $testroot/stdout.expected
1091         cmp -s $testroot/stdout.expected $testroot/stdout
1092         ret=$?
1093         if [ $ret -ne 0 ]; then
1094                 diff -u $testroot/stdout.expected $testroot/stdout
1095                 test_done "$testroot" "$ret"
1096                 return 1
1097         fi
1098
1099         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1100         echo "commit $orig_commit (master)" > $testroot/stdout.expected
1101         cmp -s $testroot/stdout.expected $testroot/stdout
1102         ret=$?
1103         if [ $ret -ne 0 ]; then
1104                 diff -u $testroot/stdout.expected $testroot/stdout
1105         fi
1106         test_done "$testroot" "$ret"
1107 }
1108
1109 test_histedit_path_prefix_edit() {
1110         local testroot=`test_init histedit_path_prefix_edit`
1111         local orig_commit=`git_show_head $testroot/repo`
1112
1113         echo "modified zeta" > $testroot/repo/epsilon/zeta
1114         git_commit $testroot/repo -m "changing zeta"
1115         local old_commit1=`git_show_head $testroot/repo`
1116
1117         got diff -r $testroot/repo $orig_commit $old_commit1 \
1118                 > $testroot/diff.expected
1119
1120         got checkout -c $orig_commit -p gamma $testroot/repo \
1121                 $testroot/wt > /dev/null
1122         ret=$?
1123         if [ $ret -ne 0 ]; then
1124                 test_done "$testroot" "$ret"
1125                 return 1
1126         fi
1127
1128         echo "edit $old_commit1" > $testroot/histedit-script
1129
1130         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1131                 > $testroot/stdout 2> $testroot/stderr)
1132
1133         ret=$?
1134         if [ $ret -eq 0 ]; then
1135                 echo "histedit succeeded unexpectedly" >&2
1136                 test_done "$testroot" "1"
1137                 return 1
1138         fi
1139
1140         echo -n "got: cannot edit branch history which contains changes " \
1141                 > $testroot/stderr.expected
1142         echo "outside of this work tree's path prefix" \
1143                 >> $testroot/stderr.expected
1144
1145         cmp -s $testroot/stderr.expected $testroot/stderr
1146         ret=$?
1147         if [ $ret -ne 0 ]; then
1148                 diff -u $testroot/stderr.expected $testroot/stderr
1149                 test_done "$testroot" "$ret"
1150                 return 1
1151         fi
1152
1153         rm -rf $testroot/wt
1154         got checkout -c $orig_commit -p epsilon $testroot/repo \
1155                 $testroot/wt > /dev/null
1156         ret=$?
1157         if [ $ret -ne 0 ]; then
1158                 test_done "$testroot" "$ret"
1159                 return 1
1160         fi
1161         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1162                 > $testroot/stdout)
1163
1164         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1165
1166         echo "G  zeta" > $testroot/stdout.expected
1167         echo "Stopping histedit for amending commit $old_commit1" \
1168                 >> $testroot/stdout.expected
1169         cmp -s $testroot/stdout.expected $testroot/stdout
1170         ret=$?
1171         if [ $ret -ne 0 ]; then
1172                 diff -u $testroot/stdout.expected $testroot/stdout
1173                 test_done "$testroot" "$ret"
1174                 return 1
1175         fi
1176
1177         echo "modified zeta" > $testroot/content.expected
1178         cat $testroot/wt/zeta > $testroot/content
1179         cmp -s $testroot/content.expected $testroot/content
1180         ret=$?
1181         if [ $ret -ne 0 ]; then
1182                 diff -u $testroot/content.expected $testroot/content
1183                 test_done "$testroot" "$ret"
1184                 return 1
1185         fi
1186
1187         (cd $testroot/wt && got status > $testroot/stdout)
1188
1189         cat > $testroot/stdout.expected <<EOF
1190 M  zeta
1191 Work tree is editing the history of refs/heads/master
1192 EOF
1193         cmp -s $testroot/stdout.expected $testroot/stdout
1194         ret=$?
1195         if [ $ret -ne 0 ]; then
1196                 diff -u $testroot/stdout.expected $testroot/stdout
1197                 test_done "$testroot" "$ret"
1198                 return 1
1199         fi
1200
1201         cat > $testroot/editor.sh <<EOF
1202 #!/bin/sh
1203 ed -s "\$1" <<-EOF
1204         ,s/.*/modified zeta/
1205         w
1206         EOF
1207 EOF
1208         chmod +x $testroot/editor.sh
1209
1210         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1211                 VISUAL="$testroot/editor.sh" \
1212                 got histedit -c > $testroot/stdout)
1213
1214         local new_commit1=`git_show_head $testroot/repo`
1215         local short_new_commit1=`trim_obj_id 12 $new_commit1`
1216
1217         echo -n "$short_old_commit1 -> $short_new_commit1: " \
1218                 > $testroot/stdout.expected
1219         echo "modified zeta" >> $testroot/stdout.expected
1220         echo "Switching work tree to refs/heads/master" \
1221                 >> $testroot/stdout.expected
1222
1223         cmp -s $testroot/stdout.expected $testroot/stdout
1224         ret=$?
1225         if [ $ret -ne 0 ]; then
1226                 diff -u $testroot/stdout.expected $testroot/stdout
1227                 test_done "$testroot" "$ret"
1228                 return 1
1229         fi
1230
1231         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1232         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1233         echo "commit $orig_commit" >> $testroot/stdout.expected
1234         cmp -s $testroot/stdout.expected $testroot/stdout
1235         ret=$?
1236         if [ $ret -ne 0 ]; then
1237                 diff -u $testroot/stdout.expected $testroot/stdout
1238                 test_done "$testroot" "$ret"
1239                 return 1
1240         fi
1241
1242         got diff -r $testroot/repo $orig_commit $new_commit1 \
1243                 > $testroot/diff
1244         ed -s $testroot/diff.expected <<-EOF
1245         ,s/$old_commit1/$new_commit1/
1246         w
1247         EOF
1248         cmp -s $testroot/diff.expected $testroot/diff
1249         ret=$?
1250         if [ $ret -ne 0 ]; then
1251                 diff -u $testroot/diff.expected $testroot/diff
1252         fi
1253         test_done "$testroot" "$ret"
1254 }
1255
1256 test_histedit_outside_refs_heads() {
1257         local testroot=`test_init histedit_outside_refs_heads`
1258         local commit1=`git_show_head $testroot/repo`
1259
1260         got checkout $testroot/repo $testroot/wt > /dev/null
1261         ret=$?
1262         if [ $ret -ne 0 ]; then
1263                 echo "got checkout failed unexpectedly"
1264                 test_done "$testroot" "$ret"
1265                 return 1
1266         fi
1267
1268         echo "modified alpha" > $testroot/wt/alpha
1269
1270         (cd $testroot/wt && got commit -m 'change alpha' \
1271                 > $testroot/stdout 2> $testroot/stderr)
1272         ret=$?
1273         if [ $ret -ne 0 ]; then
1274                 echo "got commit failed unexpectedly" >&2
1275                 test_done "$testroot" "1"
1276                 return 1
1277         fi
1278         local commit2=`git_show_head $testroot/repo`
1279
1280         got ref -r $testroot/repo -c master refs/remotes/origin/master
1281         ret=$?
1282         if [ $ret -ne 0 ]; then
1283                 echo "got ref failed unexpectedly" >&2
1284                 test_done "$testroot" "1"
1285                 return 1
1286         fi
1287
1288         (cd $testroot/wt && got update -b origin/master -c $commit1 >/dev/null)
1289         ret=$?
1290         if [ $ret -ne 0 ]; then
1291                 echo "got update failed unexpectedly"
1292                 test_done "$testroot" "$ret"
1293                 return 1
1294         fi
1295
1296         echo "edit $commit2" > $testroot/histedit-script
1297         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1298                 2> $testroot/stderr)
1299
1300         echo -n "got: will not edit commit history of a branch outside the " \
1301                 > $testroot/stderr.expected
1302         echo '"refs/heads/" reference namespace' \
1303                 >> $testroot/stderr.expected
1304         cmp -s $testroot/stderr.expected $testroot/stderr
1305         ret=$?
1306         if [ $ret -ne 0 ]; then
1307                 diff -u $testroot/stderr.expected $testroot/stderr
1308         fi
1309         test_done "$testroot" "$ret"
1310 }
1311
1312 test_histedit_fold_last_commit_swap() {
1313         local testroot=`test_init histedit_fold_last_commit_swap`
1314
1315         local orig_commit=`git_show_head $testroot/repo`
1316
1317         echo "modified alpha on master" > $testroot/repo/alpha
1318         git -C $testroot/repo rm -q beta
1319         echo "new file on master" > $testroot/repo/epsilon/new
1320         git -C $testroot/repo add epsilon/new
1321         git_commit $testroot/repo -m "committing changes"
1322         local old_commit1=`git_show_head $testroot/repo`
1323
1324         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1325         git_commit $testroot/repo -m "committing to zeta on master"
1326         local old_commit2=`git_show_head $testroot/repo`
1327
1328         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1329         ret=$?
1330         if [ $ret -ne 0 ]; then
1331                 test_done "$testroot" "$ret"
1332                 return 1
1333         fi
1334
1335         cat > $testroot/editor.sh <<EOF
1336 #!/bin/sh
1337 ed -s "\$1" <<-EOF
1338         ,s/.*/committing folded changes/
1339         w
1340         EOF
1341 EOF
1342         chmod +x $testroot/editor.sh
1343
1344         # fold commit2 into commit1 (requires swapping commits)
1345         echo "fold $old_commit2" > $testroot/histedit-script
1346         echo "mesg $old_commit1" >> $testroot/histedit-script
1347
1348         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1349                 VISUAL="$testroot/editor.sh" \
1350                 got histedit -F $testroot/histedit-script > $testroot/stdout \
1351                 2> $testroot/stderr)
1352
1353         ret=$?
1354         if [ $ret -ne 0 ]; then
1355                 echo "histedit failed unexpectedly" >&2
1356                 test_done "$testroot" "$ret"
1357                 return 1
1358         fi
1359
1360         local new_commit=`git_show_head $testroot/repo`
1361
1362         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1363         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1364         local short_new_commit=`trim_obj_id 12 $new_commit`
1365
1366         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1367         echo -n "$short_old_commit2 ->  fold commit: committing to zeta " \
1368                 >> $testroot/stdout.expected
1369         echo "on master" >> $testroot/stdout.expected
1370         echo "G  alpha" >> $testroot/stdout.expected
1371         echo "D  beta" >> $testroot/stdout.expected
1372         echo "A  epsilon/new" >> $testroot/stdout.expected
1373         echo -n "$short_old_commit1 -> $short_new_commit: " \
1374                 >> $testroot/stdout.expected
1375         echo "committing folded changes" >> $testroot/stdout.expected
1376         echo "Switching work tree to refs/heads/master" \
1377                 >> $testroot/stdout.expected
1378
1379         cmp -s $testroot/stdout.expected $testroot/stdout
1380         ret=$?
1381         if [ $ret -ne 0 ]; then
1382                 diff -u $testroot/stdout.expected $testroot/stdout
1383         fi
1384         test_done "$testroot" "$ret"
1385 }
1386
1387 test_histedit_split_commit() {
1388         local testroot=`test_init histedit_split_commit`
1389
1390         local orig_commit=`git_show_head $testroot/repo`
1391
1392         echo "modified alpha on master" > $testroot/repo/alpha
1393         git -C $testroot/repo rm -q beta
1394         echo "new file on master" > $testroot/repo/epsilon/new
1395         git -C $testroot/repo add epsilon/new
1396         git_commit $testroot/repo -m "committing changes 1"
1397         local old_commit1=`git_show_head $testroot/repo`
1398         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1399
1400         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1401         git_commit $testroot/repo -m "committing changes 2"
1402         local old_commit2=`git_show_head $testroot/repo`
1403         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1404
1405         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1406         ret=$?
1407         if [ $ret -ne 0 ]; then
1408                 test_done "$testroot" "$ret"
1409                 return 1
1410         fi
1411
1412         # split commit1 into commitA and commitB and commitC
1413         echo "e $old_commit1" > $testroot/histedit-script
1414         echo "p $old_commit2" >> $testroot/histedit-script
1415
1416         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1417                 > $testroot/stdout 2> $testroot/stderr)
1418         ret=$?
1419         if [ $ret -ne 0 ]; then
1420                 echo "histedit failed unexpectedly:" >&2
1421                 cat $testroot/stderr >&2
1422                 test_done "$testroot" "$ret"
1423                 return 1
1424         fi
1425
1426         echo "G  alpha" > $testroot/stdout.expected
1427         echo "D  beta" >> $testroot/stdout.expected
1428         echo "A  epsilon/new" >> $testroot/stdout.expected
1429         echo "Stopping histedit for amending commit $old_commit1" \
1430                 >> $testroot/stdout.expected
1431
1432         cmp -s $testroot/stdout.expected $testroot/stdout
1433         ret=$?
1434         if [ $ret -ne 0 ]; then
1435                 diff -u $testroot/stdout.expected $testroot/stdout
1436                 test_done "$testroot" "$ret"
1437                 return 1
1438         fi
1439
1440         (cd $testroot/wt && got ci -m "commitA" alpha >/dev/null)
1441         ret=$?
1442         if [ $ret -ne 0 ]; then
1443                 echo "commit failed unexpectedly" >&2
1444                 test_done "$testroot" "$ret"
1445                 return 1
1446         fi
1447
1448         (cd $testroot/wt && got ci -m "commitB" beta >/dev/null)
1449         ret=$?
1450         if [ $ret -ne 0 ]; then
1451                 echo "commit failed unexpectedly" >&2
1452                 test_done "$testroot" "$ret"
1453                 return 1
1454         fi
1455
1456         (cd $testroot/wt && got ci -m "commitC" epsilon/new >/dev/null)
1457         ret=$?
1458         if [ $ret -ne 0 ]; then
1459                 echo "commit failed unexpectedly" >&2
1460                 test_done "$testroot" "$ret"
1461                 return 1
1462         fi
1463
1464         (cd $testroot/wt && got histedit -c \
1465                 > $testroot/stdout 2> $testroot/stderr)
1466         ret=$?
1467         if [ $ret -ne 0 ]; then
1468                 echo "histedit failed unexpectedly:" >&2
1469                 cat $testroot/stderr >&2
1470                 test_done "$testroot" "$ret"
1471                 return 1
1472         fi
1473         local new_commit2=`git_show_head $testroot/repo`
1474         local short_new_commit2=`trim_obj_id 12 $new_commit2`
1475
1476         echo "$short_old_commit1 -> no-op change: committing changes 1" \
1477                 > $testroot/stdout.expected
1478         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1479         echo "$short_old_commit2 -> $short_new_commit2: committing changes 2" \
1480                 >> $testroot/stdout.expected
1481         echo "Switching work tree to refs/heads/master" \
1482                 >> $testroot/stdout.expected
1483
1484         cmp -s $testroot/stdout.expected $testroot/stdout
1485         ret=$?
1486         if [ $ret -ne 0 ]; then
1487                 diff -u $testroot/stdout.expected $testroot/stdout
1488         fi
1489         test_done "$testroot" "$ret"
1490
1491 }
1492
1493 test_histedit_duplicate_commit_in_script() {
1494         local testroot=`test_init histedit_duplicate_commit_in_script`
1495
1496         local orig_commit=`git_show_head $testroot/repo`
1497
1498         echo "modified alpha on master" > $testroot/repo/alpha
1499         git -C $testroot/repo rm -q beta
1500         echo "new file on master" > $testroot/repo/epsilon/new
1501         git -C $testroot/repo add epsilon/new
1502         git_commit $testroot/repo -m "committing changes 1"
1503         local old_commit1=`git_show_head $testroot/repo`
1504
1505         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1506         git_commit $testroot/repo -m "committing changes 2"
1507         local old_commit2=`git_show_head $testroot/repo`
1508
1509         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1510         ret=$?
1511         if [ $ret -ne 0 ]; then
1512                 test_done "$testroot" "$ret"
1513                 return 1
1514         fi
1515
1516         # This histedit script lists commit1 more than once
1517         echo "p $old_commit1" > $testroot/histedit-script
1518         echo "p $old_commit1" >> $testroot/histedit-script
1519         echo "p $old_commit2" >> $testroot/histedit-script
1520
1521         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1522                 > $testroot/stdout 2> $testroot/stderr)
1523         ret=$?
1524         if [ $ret -eq 0 ]; then
1525                 echo "histedit succeeded unexpectedly:" >&2
1526                 cat $testroot/stdout >&2
1527                 test_done "$testroot" 1
1528                 return 1
1529         fi
1530
1531         echo -n "got: commit $old_commit1 is listed more than once " \
1532                 > $testroot/stderr.expected
1533         echo "in histedit script" >> $testroot/stderr.expected
1534
1535         cmp -s $testroot/stderr.expected $testroot/stderr
1536         ret=$?
1537         if [ $ret -ne 0 ]; then
1538                 diff -u $testroot/stderr.expected $testroot/stderr
1539         fi
1540         test_done "$testroot" "$ret"
1541
1542 }
1543
1544 # if a previous commit introduces a new file, and it is folded into a commit
1545 # that deletes the same file, the file still exists after the histedit
1546 test_histedit_fold_add_delete() {
1547         local testroot=`test_init histedit_fold_add_delete`
1548
1549         local orig_commit=`git_show_head $testroot/repo`
1550
1551         echo "added new file epsilon/psi" > $testroot/repo/epsilon/psi
1552         git -C $testroot/repo add epsilon/psi
1553         git_commit $testroot/repo -m "committing changes"
1554         local old_commit1=`git_show_head $testroot/repo`
1555
1556         echo "modified epsilon/psi" > $testroot/repo/epsilon/psi
1557         git_commit $testroot/repo -m "editing psi"
1558         local old_commit2=`git_show_head $testroot/repo`
1559
1560         git -C $testroot/repo rm -q epsilon/psi
1561         git_commit $testroot/repo -m "removing psi"
1562         local old_commit3=`git_show_head $testroot/repo`
1563
1564         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1565         ret=$?
1566         if [ $ret -ne 0 ]; then
1567                 test_done "$testroot" "$ret"
1568                 return 1
1569         fi
1570
1571         cat > $testroot/editor.sh <<EOF
1572 #!/bin/sh
1573 ed -s "\$1" <<-EOF
1574         ,s/.*/folded changes/
1575         w
1576         EOF
1577 EOF
1578         chmod +x $testroot/editor.sh
1579
1580         echo "fold $old_commit1" > $testroot/histedit-script
1581         echo "fold $old_commit2" >> $testroot/histedit-script
1582         echo "pick $old_commit3" >> $testroot/histedit-script
1583
1584         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1585                 VISUAL="$testroot/editor.sh" \
1586                 got histedit -F $testroot/histedit-script > $testroot/stdout)
1587
1588         local new_commit1=`git_show_head $testroot/repo`
1589
1590         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1591         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1592         local short_old_commit3=`trim_obj_id 12 $old_commit3`
1593         local short_new_commit1=`trim_obj_id 12 $new_commit1`
1594
1595         echo "A  epsilon/psi" >> $testroot/stdout.expected
1596         echo "$short_old_commit1 ->  fold commit: committing changes" \
1597                 >> $testroot/stdout.expected
1598         echo "G  epsilon/psi" >> $testroot/stdout.expected
1599         echo "$short_old_commit2 ->  fold commit: editing psi" \
1600                 >> $testroot/stdout.expected
1601         echo "D  epsilon/psi" >> $testroot/stdout.expected
1602         echo "$short_old_commit3 -> no-op change: folded changes" \
1603                 >> $testroot/stdout.expected
1604         echo "Switching work tree to refs/heads/master" \
1605                 >> $testroot/stdout.expected
1606
1607         cmp -s $testroot/stdout.expected $testroot/stdout
1608         ret=$?
1609         if [ $ret -ne 0 ]; then
1610                 diff -u $testroot/stdout.expected $testroot/stdout
1611                 test_done "$testroot" "$ret"
1612                 return 1
1613         fi
1614
1615         if [ -e $testroot/wt/epsilon/psi ]; then
1616                 echo "removed file psi still exists on disk" >&2
1617                 test_done "$testroot" "1"
1618                 return 1
1619         fi
1620
1621         (cd $testroot/wt && got status > $testroot/stdout)
1622
1623         echo -n > $testroot/stdout.expected
1624         cmp -s $testroot/stdout.expected $testroot/stdout
1625         ret=$?
1626         if [ $ret -ne 0 ]; then
1627                 diff -u $testroot/stdout.expected $testroot/stdout
1628                 test_done "$testroot" "$ret"
1629                 return 1
1630         fi
1631
1632         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1633         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1634         cmp -s $testroot/stdout.expected $testroot/stdout
1635         ret=$?
1636         if [ $ret -ne 0 ]; then
1637                 diff -u $testroot/stdout.expected $testroot/stdout
1638                 test_done "$testroot" "$ret"
1639                 return 1
1640         fi
1641
1642         got tree -r $testroot/repo epsilon > $testroot/stdout
1643         echo "zeta" > $testroot/stdout.expected
1644         cmp -s $testroot/stdout.expected $testroot/stdout
1645         ret=$?
1646         if [ $ret -ne 0 ]; then
1647                 diff -u $testroot/stdout.expected $testroot/stdout
1648         fi
1649         test_done "$testroot" "$ret"
1650 }
1651
1652 # if a previous commit edits a file, and it is folded into a commit
1653 # that deletes the same file, the file will be deleted by histedit
1654 test_histedit_fold_edit_delete() {
1655         local testroot=`test_init histedit_fold_edit_delete`
1656
1657         local orig_commit=`git_show_head $testroot/repo`
1658
1659         echo "modify alpha" > $testroot/repo/alpha
1660         git -C $testroot/repo add alpha
1661         git_commit $testroot/repo -m "modified alpha"
1662         local old_commit1=`git_show_head $testroot/repo`
1663
1664         git_rm $testroot/repo alpha
1665         git_commit $testroot/repo -m "deleted alpha"
1666         local old_commit2=`git_show_head $testroot/repo`
1667
1668         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1669         ret=$?
1670         if [ $ret -ne 0 ]; then
1671                 test_done "$testroot" "$ret"
1672                 return 1
1673         fi
1674
1675         cat > $testroot/editor.sh <<EOF
1676 #!/bin/sh
1677 ed -s "\$1" <<-EOF
1678         ,s/.*/folded changes/
1679         w
1680         EOF
1681 EOF
1682         chmod +x $testroot/editor.sh
1683
1684         echo "fold $old_commit1" > $testroot/histedit-script
1685         echo "pick $old_commit2" >> $testroot/histedit-script
1686
1687         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1688                 VISUAL="$testroot/editor.sh" \
1689                 got histedit -F $testroot/histedit-script > $testroot/stdout)
1690
1691         local new_commit1=`git_show_head $testroot/repo`
1692
1693         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1694         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1695         local short_new_commit1=`trim_obj_id 12 $new_commit1`
1696
1697         echo "G  alpha" >> $testroot/stdout.expected
1698         echo "$short_old_commit1 ->  fold commit: modified alpha" \
1699                 >> $testroot/stdout.expected
1700         echo "D  alpha" >> $testroot/stdout.expected
1701         echo "$short_old_commit2 -> $short_new_commit1: folded changes" \
1702                 >> $testroot/stdout.expected
1703         echo "Switching work tree to refs/heads/master" \
1704                 >> $testroot/stdout.expected
1705
1706         cmp -s $testroot/stdout.expected $testroot/stdout
1707         ret=$?
1708         if [ $ret -ne 0 ]; then
1709                 diff -u $testroot/stdout.expected $testroot/stdout
1710                 test_done "$testroot" "$ret"
1711                 return 1
1712         fi
1713
1714         if [ -e $testroot/wt/alpha ]; then
1715                 echo "removed file alpha still exists on disk" >&2
1716                 test_done "$testroot" "1"
1717                 return 1
1718         fi
1719
1720         (cd $testroot/wt && got status > $testroot/stdout)
1721
1722         echo -n > $testroot/stdout.expected
1723         cmp -s $testroot/stdout.expected $testroot/stdout
1724         ret=$?
1725         if [ $ret -ne 0 ]; then
1726                 diff -u $testroot/stdout.expected $testroot/stdout
1727                 test_done "$testroot" "$ret"
1728                 return 1
1729         fi
1730
1731         (cd $testroot/wt && got log -l2 | grep ^commit > $testroot/stdout)
1732         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1733         echo "commit $orig_commit" >> $testroot/stdout.expected
1734         cmp -s $testroot/stdout.expected $testroot/stdout
1735         ret=$?
1736         if [ $ret -ne 0 ]; then
1737                 diff -u $testroot/stdout.expected $testroot/stdout
1738         fi
1739
1740         test_done "$testroot" "$ret"
1741 }
1742
1743 test_histedit_fold_delete_add() {
1744         local testroot=`test_init histedit_fold_delete_add`
1745
1746         local orig_commit=`git_show_head $testroot/repo`
1747
1748         git -C $testroot/repo rm -q alpha
1749         git_commit $testroot/repo -m "removing alpha"
1750         local old_commit1=`git_show_head $testroot/repo`
1751
1752         echo "modified alpha" >$testroot/repo/alpha
1753         git -C $testroot/repo add alpha
1754         git_commit $testroot/repo -m "add back modified alpha"
1755         local old_commit2=`git_show_head $testroot/repo`
1756
1757         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1758         ret=$?
1759         if [ $ret -ne 0 ]; then
1760                 test_done "$testroot" "$ret"
1761                 return 1
1762         fi
1763
1764         cat > $testroot/editor.sh <<EOF
1765 #!/bin/sh
1766 ed -s "\$1" <<-EOF
1767         ,s/.*/folded changes/
1768         w
1769         EOF
1770 EOF
1771         chmod +x $testroot/editor.sh
1772
1773         echo "fold $old_commit1" > $testroot/histedit-script
1774         echo "pick $old_commit2" >> $testroot/histedit-script
1775
1776         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1777                 VISUAL="$testroot/editor.sh" \
1778                 got histedit -F $testroot/histedit-script > $testroot/stdout)
1779
1780         local new_commit1=`git_show_head $testroot/repo`
1781
1782         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1783         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1784         local short_new_commit1=`trim_obj_id 12 $new_commit1`
1785
1786         echo "D  alpha" > $testroot/stdout.expected
1787         echo "$short_old_commit1 ->  fold commit: removing alpha" \
1788                 >> $testroot/stdout.expected
1789         echo "A  alpha" >> $testroot/stdout.expected
1790         echo "$short_old_commit2 -> $short_new_commit1: folded changes" \
1791                 >> $testroot/stdout.expected
1792         echo "Switching work tree to refs/heads/master" \
1793                 >> $testroot/stdout.expected
1794
1795         cmp -s $testroot/stdout.expected $testroot/stdout
1796         ret=$?
1797         if [ $ret -ne 0 ]; then
1798                 diff -u $testroot/stdout.expected $testroot/stdout
1799                 test_done "$testroot" "$ret"
1800                 return 1
1801         fi
1802
1803         if [ ! -e $testroot/wt/alpha ]; then
1804                 echo "file alpha is missing on disk" >&2
1805                 test_done "$testroot" "1"
1806                 return 1
1807         fi
1808
1809         echo "modified alpha" > $testroot/content.expected
1810         cat $testroot/wt/alpha > $testroot/content
1811         cmp -s $testroot/content.expected $testroot/content
1812         ret=$?
1813         if [ $ret -ne 0 ]; then
1814                 diff -u $testroot/content.expected $testroot/content
1815                 test_done "$testroot" "$ret"
1816                 return 1
1817         fi
1818         test_done "$testroot" "0"
1819 }
1820
1821 test_histedit_fold_only() {
1822         local testroot=`test_init histedit_fold_only`
1823
1824         local orig_commit=`git_show_head $testroot/repo`
1825
1826         echo "modified alpha on master" > $testroot/repo/alpha
1827         git -C $testroot/repo rm -q beta
1828         echo "new file on master" > $testroot/repo/epsilon/new
1829         git -C $testroot/repo add epsilon/new
1830         git_commit $testroot/repo -m "committing changes"
1831         local old_commit1=`git_show_head $testroot/repo`
1832
1833         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1834         git_commit $testroot/repo -m "committing to zeta on master"
1835         local old_commit2=`git_show_head $testroot/repo`
1836
1837         echo "modified delta on master" > $testroot/repo/gamma/delta
1838         git_commit $testroot/repo -m "committing to delta on master"
1839         local old_commit3=`git_show_head $testroot/repo`
1840
1841         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1842         ret=$?
1843         if [ $ret -ne 0 ]; then
1844                 test_done "$testroot" "$ret"
1845                 return 1
1846         fi
1847
1848         cat > $testroot/editor.sh <<EOF
1849 #!/bin/sh
1850 ed -s "\$1" <<-EOF
1851         ,s/.*/committing folded changes/
1852         w
1853         EOF
1854 EOF
1855         chmod +x $testroot/editor.sh
1856
1857         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1858                 VISUAL="$testroot/editor.sh" got histedit -f > $testroot/stdout)
1859
1860         local new_commit1=`git_show_head $testroot/repo`
1861
1862         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1863         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1864         local short_old_commit3=`trim_obj_id 12 $old_commit3`
1865         local short_new_commit1=`trim_obj_id 12 $new_commit1`
1866         local short_new_commit2=`trim_obj_id 12 $new_commit2`
1867
1868         echo "G  alpha" > $testroot/stdout.expected
1869         echo "D  beta" >> $testroot/stdout.expected
1870         echo "A  epsilon/new" >> $testroot/stdout.expected
1871         echo "$short_old_commit1 ->  fold commit: committing changes" \
1872                 >> $testroot/stdout.expected
1873         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1874         echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
1875         echo "fold commit: committing to zeta on master" \
1876                 >> $testroot/stdout.expected
1877         echo "G  gamma/delta" >> $testroot/stdout.expected
1878         echo -n "$short_old_commit3 -> $short_new_commit1: " \
1879                 >> $testroot/stdout.expected
1880         echo "committing folded changes" >> $testroot/stdout.expected
1881         echo "Switching work tree to refs/heads/master" \
1882                 >> $testroot/stdout.expected
1883
1884         cmp -s $testroot/stdout.expected $testroot/stdout
1885         ret=$?
1886         if [ $ret -ne 0 ]; then
1887                 diff -u $testroot/stdout.expected $testroot/stdout
1888                 test_done "$testroot" "$ret"
1889                 return 1
1890         fi
1891
1892         echo "modified alpha on master" > $testroot/content.expected
1893         cat $testroot/wt/alpha > $testroot/content
1894         cmp -s $testroot/content.expected $testroot/content
1895         ret=$?
1896         if [ $ret -ne 0 ]; then
1897                 diff -u $testroot/content.expected $testroot/content
1898                 test_done "$testroot" "$ret"
1899                 return 1
1900         fi
1901
1902         if [ -e $testroot/wt/beta ]; then
1903                 echo "removed file beta still exists on disk" >&2
1904                 test_done "$testroot" "1"
1905                 return 1
1906         fi
1907
1908         echo "new file on master" > $testroot/content.expected
1909         cat $testroot/wt/epsilon/new > $testroot/content
1910         cmp -s $testroot/content.expected $testroot/content
1911         ret=$?
1912         if [ $ret -ne 0 ]; then
1913                 diff -u $testroot/content.expected $testroot/content
1914                 test_done "$testroot" "$ret"
1915                 return 1
1916         fi
1917
1918         (cd $testroot/wt && got status > $testroot/stdout)
1919
1920         echo -n > $testroot/stdout.expected
1921         cmp -s $testroot/stdout.expected $testroot/stdout
1922         ret=$?
1923         if [ $ret -ne 0 ]; then
1924                 diff -u $testroot/stdout.expected $testroot/stdout
1925                 test_done "$testroot" "$ret"
1926                 return 1
1927         fi
1928
1929         (cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
1930         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1931         echo "commit $orig_commit" >> $testroot/stdout.expected
1932         cmp -s $testroot/stdout.expected $testroot/stdout
1933         ret=$?
1934         if [ $ret -ne 0 ]; then
1935                 diff -u $testroot/stdout.expected $testroot/stdout
1936         fi
1937         test_done "$testroot" "$ret"
1938 }
1939
1940 test_histedit_fold_only_empty_logmsg() {
1941         local testroot=`test_init histedit_fold_only_empty_logmsg`
1942
1943         local orig_commit=`git_show_head $testroot/repo`
1944
1945         echo "modified alpha on master" > $testroot/repo/alpha
1946         git -C $testroot/repo rm -q beta
1947         echo "new file on master" > $testroot/repo/epsilon/new
1948         git -C $testroot/repo add epsilon/new
1949         git_commit $testroot/repo -m "committing changes"
1950         local old_commit1=`git_show_head $testroot/repo`
1951
1952         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1953         git_commit $testroot/repo -m "committing to zeta on master"
1954         local old_commit2=`git_show_head $testroot/repo`
1955
1956         echo "modified delta on master" > $testroot/repo/gamma/delta
1957         git_commit $testroot/repo -m "committing to delta on master"
1958         local old_commit3=`git_show_head $testroot/repo`
1959
1960         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1961         ret=$?
1962         if [ $ret -ne 0 ]; then
1963                 test_done "$testroot" "$ret"
1964                 return 1
1965         fi
1966
1967         cat > $testroot/editor.sh <<EOF
1968 #!/bin/sh
1969 ed -s "\$1" <<-EOF
1970         ,d
1971         w
1972         EOF
1973 EOF
1974         chmod +x $testroot/editor.sh
1975
1976         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1977                 VISUAL="$testroot/editor.sh" got histedit -f > $testroot/stdout)
1978
1979         local new_commit1=`git_show_head $testroot/repo`
1980
1981         local short_old_commit1=`trim_obj_id 12 $old_commit1`
1982         local very_short_old_commit1=`trim_obj_id 11 $old_commit1`
1983         local short_old_commit2=`trim_obj_id 12 $old_commit2`
1984         local short_old_commit3=`trim_obj_id 12 $old_commit3`
1985         local short_new_commit1=`trim_obj_id 12 $new_commit1`
1986         local short_new_commit2=`trim_obj_id 12 $new_commit2`
1987
1988         echo "G  alpha" > $testroot/stdout.expected
1989         echo "D  beta" >> $testroot/stdout.expected
1990         echo "A  epsilon/new" >> $testroot/stdout.expected
1991         echo "$short_old_commit1 ->  fold commit: committing changes" \
1992                 >> $testroot/stdout.expected
1993         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1994         echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
1995         echo "fold commit: committing to zeta on master" \
1996                 >> $testroot/stdout.expected
1997         echo "G  gamma/delta" >> $testroot/stdout.expected
1998         echo -n "$short_old_commit3 -> $short_new_commit1: " \
1999                 >> $testroot/stdout.expected
2000         echo "# log message of folded commit $very_short_old_commit1" \
2001                 >> $testroot/stdout.expected
2002         echo "Switching work tree to refs/heads/master" \
2003                 >> $testroot/stdout.expected
2004
2005         cmp -s $testroot/stdout.expected $testroot/stdout
2006         ret=$?
2007         if [ $ret -ne 0 ]; then
2008                 diff -u $testroot/stdout.expected $testroot/stdout
2009                 test_done "$testroot" "$ret"
2010                 return 1
2011         fi
2012
2013         echo "modified alpha on master" > $testroot/content.expected
2014         cat $testroot/wt/alpha > $testroot/content
2015         cmp -s $testroot/content.expected $testroot/content
2016         ret=$?
2017         if [ $ret -ne 0 ]; then
2018                 diff -u $testroot/content.expected $testroot/content
2019                 test_done "$testroot" "$ret"
2020                 return 1
2021         fi
2022
2023         if [ -e $testroot/wt/beta ]; then
2024                 echo "removed file beta still exists on disk" >&2
2025                 test_done "$testroot" "1"
2026                 return 1
2027         fi
2028
2029         echo "new file on master" > $testroot/content.expected
2030         cat $testroot/wt/epsilon/new > $testroot/content
2031         cmp -s $testroot/content.expected $testroot/content
2032         ret=$?
2033         if [ $ret -ne 0 ]; then
2034                 diff -u $testroot/content.expected $testroot/content
2035                 test_done "$testroot" "$ret"
2036                 return 1
2037         fi
2038
2039         (cd $testroot/wt && got status > $testroot/stdout)
2040
2041         echo -n > $testroot/stdout.expected
2042         cmp -s $testroot/stdout.expected $testroot/stdout
2043         ret=$?
2044         if [ $ret -ne 0 ]; then
2045                 diff -u $testroot/stdout.expected $testroot/stdout
2046                 test_done "$testroot" "$ret"
2047                 return 1
2048         fi
2049
2050         (cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
2051         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
2052         echo "commit $orig_commit" >> $testroot/stdout.expected
2053         cmp -s $testroot/stdout.expected $testroot/stdout
2054         ret=$?
2055         if [ $ret -ne 0 ]; then
2056                 diff -u $testroot/stdout.expected $testroot/stdout
2057         fi
2058         test_done "$testroot" "$ret"
2059 }
2060
2061 test_histedit_edit_only() {
2062         local testroot=`test_init histedit_edit_only`
2063
2064         local orig_commit=`git_show_head $testroot/repo`
2065
2066         echo "modified alpha on master" > $testroot/repo/alpha
2067         git -C $testroot/repo rm -q beta
2068         echo "new file on master" > $testroot/repo/epsilon/new
2069         git -C $testroot/repo add epsilon/new
2070         git_commit $testroot/repo -m "committing changes"
2071         local old_commit1=`git_show_head $testroot/repo`
2072
2073         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
2074         git_commit $testroot/repo -m "committing to zeta on master"
2075         local old_commit2=`git_show_head $testroot/repo`
2076
2077         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2078         ret=$?
2079         if [ $ret -ne 0 ]; then
2080                 test_done "$testroot" "$ret"
2081                 return 1
2082         fi
2083
2084         (cd $testroot/wt && got histedit -e > $testroot/stdout)
2085
2086         local short_old_commit1=`trim_obj_id 12 $old_commit1`
2087         local short_old_commit2=`trim_obj_id 12 $old_commit2`
2088
2089         echo "G  alpha" > $testroot/stdout.expected
2090         echo "D  beta" >> $testroot/stdout.expected
2091         echo "A  epsilon/new" >> $testroot/stdout.expected
2092         echo "Stopping histedit for amending commit $old_commit1" \
2093                 >> $testroot/stdout.expected
2094         cmp -s $testroot/stdout.expected $testroot/stdout
2095         ret=$?
2096         if [ $ret -ne 0 ]; then
2097                 diff -u $testroot/stdout.expected $testroot/stdout
2098                 test_done "$testroot" "$ret"
2099                 return 1
2100         fi
2101
2102         echo "edited modified alpha on master" > $testroot/wt/alpha
2103
2104         cat > $testroot/editor.sh <<EOF
2105 #!/bin/sh
2106 ed -s "\$1" <<-EOF
2107         ,s/.*/committing edited changes 1/
2108         w
2109         EOF
2110 EOF
2111         chmod +x $testroot/editor.sh
2112
2113         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
2114                 VISUAL="$testroot/editor.sh" got histedit -c > $testroot/stdout)
2115
2116         local new_commit1=$(cd $testroot/wt && got info | \
2117                 grep '^work tree base commit: ' | cut -d: -f2 | tr -d ' ')
2118         local short_new_commit1=`trim_obj_id 12 $new_commit1`
2119
2120         echo -n "$short_old_commit1 -> $short_new_commit1: " \
2121                 > $testroot/stdout.expected
2122         echo "committing edited changes 1" >> $testroot/stdout.expected
2123         echo "G  epsilon/zeta" >> $testroot/stdout.expected
2124         echo "Stopping histedit for amending commit $old_commit2" \
2125                 >> $testroot/stdout.expected
2126         cmp -s $testroot/stdout.expected $testroot/stdout
2127         ret=$?
2128         if [ $ret -ne 0 ]; then
2129                 diff -u $testroot/stdout.expected $testroot/stdout
2130                 test_done "$testroot" "$ret"
2131                 return 1
2132         fi
2133
2134         echo "edited zeta on master" > $testroot/wt/epsilon/zeta
2135
2136         cat > $testroot/editor.sh <<EOF
2137 #!/bin/sh
2138 ed -s "\$1" <<-EOF
2139         ,s/.*/committing edited changes 2/
2140         w
2141         EOF
2142 EOF
2143         chmod +x $testroot/editor.sh
2144
2145         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
2146                 VISUAL="$testroot/editor.sh" got histedit -c > $testroot/stdout)
2147
2148         local new_commit2=`git_show_head $testroot/repo`
2149         local short_new_commit2=`trim_obj_id 12 $new_commit2`
2150
2151         echo -n "$short_old_commit2 -> $short_new_commit2: " \
2152                 > $testroot/stdout.expected
2153         echo "committing edited changes 2" >> $testroot/stdout.expected
2154         echo "Switching work tree to refs/heads/master" \
2155                 >> $testroot/stdout.expected
2156
2157         cmp -s $testroot/stdout.expected $testroot/stdout
2158         ret=$?
2159         if [ $ret -ne 0 ]; then
2160                 diff -u $testroot/stdout.expected $testroot/stdout
2161                 test_done "$testroot" "$ret"
2162                 return 1
2163         fi
2164
2165         echo "edited modified alpha on master" > $testroot/content.expected
2166         cat $testroot/wt/alpha > $testroot/content
2167         cmp -s $testroot/content.expected $testroot/content
2168         ret=$?
2169         if [ $ret -ne 0 ]; then
2170                 diff -u $testroot/content.expected $testroot/content
2171                 test_done "$testroot" "$ret"
2172                 return 1
2173         fi
2174
2175         if [ -e $testroot/wt/beta ]; then
2176                 echo "removed file beta still exists on disk" >&2
2177                 test_done "$testroot" "1"
2178                 return 1
2179         fi
2180
2181         echo "new file on master" > $testroot/content.expected
2182         cat $testroot/wt/epsilon/new > $testroot/content
2183         cmp -s $testroot/content.expected $testroot/content
2184         ret=$?
2185         if [ $ret -ne 0 ]; then
2186                 diff -u $testroot/content.expected $testroot/content
2187                 test_done "$testroot" "$ret"
2188                 return 1
2189         fi
2190
2191         (cd $testroot/wt && got status > $testroot/stdout)
2192
2193         echo -n > $testroot/stdout.expected
2194         cmp -s $testroot/stdout.expected $testroot/stdout
2195         ret=$?
2196         if [ $ret -ne 0 ]; then
2197                 diff -u $testroot/stdout.expected $testroot/stdout
2198                 test_done "$testroot" "$ret"
2199                 return 1
2200         fi
2201
2202         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
2203         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
2204         echo "commit $new_commit1" >> $testroot/stdout.expected
2205         echo "commit $orig_commit" >> $testroot/stdout.expected
2206         cmp -s $testroot/stdout.expected $testroot/stdout
2207         ret=$?
2208         if [ $ret -ne 0 ]; then
2209                 diff -u $testroot/stdout.expected $testroot/stdout
2210         fi
2211         test_done "$testroot" "$ret"
2212 }
2213
2214 test_histedit_prepend_line() {
2215         local testroot=`test_init histedit_prepend_line`
2216         local orig_commit=`git_show_head $testroot/repo`
2217
2218         got checkout $testroot/repo $testroot/wt > /dev/null
2219
2220         ed -s "$testroot/wt/alpha" <<EOF
2221 1i
2222 first line
2223 .
2224 wq
2225 EOF
2226
2227         cp $testroot/wt/alpha $testroot/content.expected
2228
2229         (cd $testroot/wt/ && got commit -m 'modified alpha on master' \
2230                 alpha > /dev/null)
2231         ret=$?
2232         if [ $ret -ne 0 ]; then
2233                 echo "got commit failed unexpectedly" >&2
2234                 test_done "$testroot" "$ret"
2235                 return 1
2236         fi
2237
2238         local top_commit=`git_show_head $testroot/repo`
2239         echo "pick $top_commit" > "$testroot/histedit-script"
2240
2241         (cd $testroot/wt/ && got update -c $orig_commit > /dev/null)
2242         ret=$?
2243         if [ $ret -ne 0 ]; then
2244                 echo "got update failed unexpectedly" >&2
2245                 test_done "$testroot" "$ret"
2246                 return 1
2247         fi
2248
2249         (cd $testroot/wt && got histedit -F "$testroot/histedit-script" \
2250                 > /dev/null)
2251         ret=$?
2252         if [ $ret -ne 0 ]; then
2253                 echo "got histedit failed unexpectedly" >&2
2254                 test_done "$testroot" "$ret"
2255                 return 1
2256         fi
2257
2258         cp $testroot/wt/alpha $testroot/content
2259         cmp -s $testroot/content.expected $testroot/content
2260         ret=$?
2261         if [ $ret -ne 0 ]; then
2262                 diff -u $testroot/content.expected $testroot/content
2263                 test_done "$testroot" "$ret"
2264                 return 1
2265         fi
2266
2267         test_done "$testroot" $ret
2268 }
2269
2270 test_histedit_resets_committer() {
2271         local testroot=`test_init histedit_resets_committer`
2272         local orig_commit=`git_show_head $testroot/repo`
2273         local committer="Flan Luck <flan_luck@openbsd.org>"
2274
2275         got checkout $testroot/repo $testroot/wt > /dev/null
2276
2277         echo "modified alpha" > $testroot/wt/alpha
2278
2279         (cd $testroot/wt/ && got commit -m 'modified alpha on master' \
2280                 alpha > /dev/null)
2281         ret=$?
2282         if [ $ret -ne 0 ]; then
2283                 echo "got commit failed unexpectedly" >&2
2284                 test_done "$testroot" "$ret"
2285                 return 1
2286         fi
2287
2288         local top_commit=`git_show_head $testroot/repo`
2289         echo "pick $top_commit" > "$testroot/histedit-script"
2290
2291         (cd $testroot/wt/ && got update -c $orig_commit > /dev/null)
2292         ret=$?
2293         if [ $ret -ne 0 ]; then
2294                 echo "got update failed unexpectedly" >&2
2295                 test_done "$testroot" "$ret"
2296                 return 1
2297         fi
2298
2299         (cd $testroot/wt && env GOT_AUTHOR="$committer" \
2300                 got histedit -F "$testroot/histedit-script" > /dev/null)
2301         ret=$?
2302         if [ $ret -ne 0 ]; then
2303                 echo "got histedit failed unexpectedly" >&2
2304                 test_done "$testroot" "$ret"
2305                 return 1
2306         fi
2307         local edited_commit=`git_show_head $testroot/repo`
2308
2309         # Original commit only had one author
2310         (cd $testroot/repo && got log -l1 -c $top_commit | \
2311                 egrep '^(from|via):' > $testroot/stdout)
2312         echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
2313         cmp -s $testroot/stdout.expected $testroot/stdout
2314         ret=$?
2315         if [ $ret -ne 0 ]; then
2316                 diff -u $testroot/stdout.expected $testroot/stdout
2317                 test_done "$testroot" "$ret"
2318                 return 1
2319         fi
2320
2321         # Edited commit should have new committer name added
2322         (cd $testroot/repo && got log -l1 -c $edited_commit | \
2323                 egrep '^(from|via):' > $testroot/stdout)
2324         echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
2325         echo "via: $committer" >> $testroot/stdout.expected
2326
2327         cmp -s $testroot/stdout.expected $testroot/stdout
2328         ret=$?
2329         if [ $ret -ne 0 ]; then
2330                 diff -u $testroot/stdout.expected $testroot/stdout
2331         fi
2332         test_done "$testroot" "$ret"
2333 }
2334
2335 test_histedit_umask() {
2336         local testroot=`test_init histedit_umask`
2337         local orig_commit=`git_show_head "$testroot/repo"`
2338
2339         got checkout "$testroot/repo" "$testroot/wt" >/dev/null
2340
2341         echo "modified alpha" > $testroot/wt/alpha
2342         (cd "$testroot/wt" && got commit -m 'edit #1') >/dev/null
2343         local commit1=`git_show_head "$testroot/repo"`
2344
2345         echo "modified again" > $testroot/wt/alpha
2346         (cd "$testroot/wt" && got commit -m 'edit #2') >/dev/null
2347         local commit2=`git_show_head "$testroot/repo"`
2348
2349         echo "modified again!" > $testroot/wt/alpha
2350         echo "modify beta too!" > $testroot/wt/beta
2351         (cd "$testroot/wt" && got commit -m 'edit #3') >/dev/null
2352         local commit3=`git_show_head "$testroot/repo"`
2353
2354         (cd "$testroot/wt" && got update -c "$orig_commit") >/dev/null
2355         ret=$?
2356         if [ $ret -ne 0 ]; then
2357                 echo "update to $orig_commit failed!" >&2
2358                 test_done "$testroot" 1
2359                 return 1
2360         fi
2361
2362         cat > $testroot/editor.sh <<EOF
2363 #!/bin/sh
2364 ed -s "\$1" <<-EOF
2365         ,s/.*/folding changes/
2366         w
2367         EOF
2368 EOF
2369         chmod +x $testroot/editor.sh
2370
2371         echo fold $commit1 >$testroot/histedit-script
2372         echo fold $commit2 >>$testroot/histedit-script
2373         echo pick $commit3 >>$testroot/histedit-script
2374
2375         # using a subshell to avoid clobbering global umask
2376         (umask 077 && cd "$testroot/wt" && \
2377                 env EDITOR="$testroot/editor.sh" VISUAL="$testroot/editor.sh" \
2378                 got histedit -F "$testroot/histedit-script") >/dev/null
2379         ret=$?
2380
2381         if [ $ret -ne 0 ]; then
2382                 echo "histedit operation failed" >&2
2383                 test_done "$testroot" $ret
2384                 return 1
2385         fi
2386
2387         for f in alpha beta; do
2388                 ls -l "$testroot/wt/$f" | grep -q ^-rw-------
2389                 if [ $? -ne 0 ]; then
2390                         echo "$f is not 0600 after histedi" >&2
2391                         ls -l "$testroot/wt/$f" >&2
2392                         test_done "$testroot" 1
2393                         return 1
2394                 fi
2395         done
2396
2397         test_done "$testroot" 0
2398 }
2399
2400 test_histedit_mesg_filemode_change() {
2401         local testroot=`test_init histedit_mode_change`
2402
2403         local orig_commit=`git_show_head $testroot/repo`
2404         local orig_author_time=`git_show_author_time $testroot/repo`
2405
2406         chmod +x $testroot/repo/alpha
2407         git_commit $testroot/repo -m "set x bit on alpha"
2408         local old_commit1=`git_show_head $testroot/repo`
2409         local old_author_time1=`git_show_author_time $testroot/repo`
2410
2411         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2412         ret=$?
2413         if [ $ret -ne 0 ]; then
2414                 test_done "$testroot" "$ret"
2415                 return 1
2416         fi
2417
2418         if [ -x $testroot/wt/alpha ]; then
2419                 echo "file alpha has unexpected executable bit" >&2
2420                 test_done "$testroot" "1"
2421                 return 1
2422         fi
2423
2424         cat > $testroot/editor.sh <<EOF
2425 #!/bin/sh
2426 ed -s "\$1" <<-EOF
2427         ,s/ x bit / executable bit /
2428         w
2429         EOF
2430 EOF
2431
2432         chmod +x $testroot/editor.sh
2433
2434         (cd $testroot/wt && env VISUAL="$testroot/editor.sh" \
2435                 got histedit -m > $testroot/stdout)
2436
2437         local new_commit1=`git_show_head $testroot/repo`
2438         local new_author_time1=`git_show_author_time $testroot/repo`
2439
2440         local short_old_commit1=`trim_obj_id 12 $old_commit1`
2441         local short_new_commit1=`trim_obj_id 12 $new_commit1`
2442
2443         echo "G  alpha" > $testroot/stdout.expected
2444         echo "$short_old_commit1 -> $short_new_commit1: set executable bit on alpha" \
2445                 >> $testroot/stdout.expected
2446         echo "Switching work tree to refs/heads/master" \
2447                 >> $testroot/stdout.expected
2448
2449         cmp -s $testroot/stdout.expected $testroot/stdout
2450         ret=$?
2451         if [ $ret -ne 0 ]; then
2452                 diff -u $testroot/stdout.expected $testroot/stdout
2453                 test_done "$testroot" "$ret"
2454                 return 1
2455         fi
2456
2457         echo "alpha" > $testroot/content.expected
2458         cmp -s $testroot/content.expected $testroot/wt/alpha
2459         ret=$?
2460         if [ $ret -ne 0 ]; then
2461                 diff -u $testroot/content.expected $testroot/wt/alpha
2462                 test_done "$testroot" "$ret"
2463                 return 1
2464         fi
2465
2466         if [ ! -x $testroot/wt/alpha ]; then
2467                 echo "file alpha lost its executable bit" >&2
2468                 test_done "$testroot" "1"
2469                 return 1
2470         fi
2471
2472         (cd $testroot/wt && got status > $testroot/stdout)
2473
2474         echo -n > $testroot/stdout.expected
2475         cmp -s $testroot/stdout.expected $testroot/stdout
2476         ret=$?
2477         if [ $ret -ne 0 ]; then
2478                 diff -u $testroot/stdout.expected $testroot/stdout
2479                 test_done "$testroot" "$ret"
2480                 return 1
2481         fi
2482
2483         (cd $testroot/wt && got log -l1 | grep ' set executable bit on alpha' \
2484                 > $testroot/stdout)
2485
2486         echo ' set executable bit on alpha' > $testroot/stdout.expected
2487         cmp -s $testroot/stdout.expected $testroot/stdout
2488         ret=$?
2489         if [ $ret -ne 0 ]; then
2490                 diff -u $testroot/stdout.expected $testroot/stdout
2491                 test_done "$testroot" "$ret"
2492                 return 1
2493         fi
2494
2495         test_done "$testroot" "$ret"
2496 }
2497
2498 test_histedit_drop_only() {
2499         local testroot=`test_init histedit_drop_only`
2500
2501         local orig_commit=`git_show_head $testroot/repo`
2502         local drop="->  drop commit:"
2503         local dropmsg="commit changes to drop"
2504
2505         echo "modified alpha on master" > $testroot/repo/alpha
2506         git -C $testroot/repo rm -q beta
2507         echo "new file on master" > $testroot/repo/epsilon/new
2508         git -C $testroot/repo add epsilon/new
2509
2510         git_commit $testroot/repo -m "$dropmsg 1"
2511         local drop_commit1=`git_show_head $testroot/repo`
2512
2513         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
2514
2515         git_commit $testroot/repo -m "$dropmsg 2"
2516         local drop_commit2=`git_show_head $testroot/repo`
2517
2518         echo "modified delta on master" > $testroot/repo/gamma/delta
2519
2520         git_commit $testroot/repo -m "$dropmsg 3"
2521         local drop_commit3=`git_show_head $testroot/repo`
2522
2523         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2524         ret=$?
2525         if [ $ret -ne 0 ]; then
2526                 test_done "$testroot" "$ret"
2527                 return 1
2528         fi
2529
2530         (cd $testroot/wt && got histedit -d > $testroot/stdout)
2531         local new_commit1=`git_show_head $testroot/repo`
2532
2533         local short_commit1=`trim_obj_id 12 $drop_commit1`
2534         local short_commit2=`trim_obj_id 12 $drop_commit2`
2535         local short_commit3=`trim_obj_id 12 $drop_commit3`
2536
2537         echo "$short_commit1 $drop $dropmsg 1" > $testroot/stdout.expected
2538         echo "$short_commit2 $drop $dropmsg 2" >> $testroot/stdout.expected
2539         echo "$short_commit3 $drop $dropmsg 3" >> $testroot/stdout.expected
2540         echo "Switching work tree to refs/heads/master" \
2541                 >> $testroot/stdout.expected
2542
2543         cmp -s $testroot/stdout.expected $testroot/stdout
2544         ret=$?
2545         if [ $ret -ne 0 ]; then
2546                 diff -u $testroot/stdout.expected $testroot/stdout
2547                 test_done "$testroot" "$ret"
2548                 return 1
2549         fi
2550
2551         echo "alpha" > $testroot/content.expected
2552         cat $testroot/wt/alpha > $testroot/content
2553         cmp -s $testroot/content.expected $testroot/content
2554         ret=$?
2555         if [ $ret -ne 0 ]; then
2556                 diff -u $testroot/content.expected $testroot/content
2557                 test_done "$testroot" "$ret"
2558                 return 1
2559         fi
2560
2561         echo "zeta" > $testroot/content.expected
2562         cat $testroot/wt/epsilon/zeta > $testroot/content
2563         cmp -s $testroot/content.expected $testroot/content
2564         ret=$?
2565         if [ $ret -ne 0 ]; then
2566                 diff -u $testroot/content.expected $testroot/content
2567                 test_done "$testroot" "$ret"
2568                 return 1
2569         fi
2570
2571         echo "delta" > $testroot/content.expected
2572         cat $testroot/wt/gamma/delta > $testroot/content
2573         cmp -s $testroot/content.expected $testroot/content
2574         ret=$?
2575         if [ $ret -ne 0 ]; then
2576                 diff -u $testroot/content.expected $testroot/content
2577                 test_done "$testroot" "$ret"
2578                 return 1
2579         fi
2580
2581         if [ ! -e $testroot/wt/beta ]; then
2582                 echo "removed file beta should be restored" >&2
2583                 test_done "$testroot" "1"
2584                 return 1
2585         fi
2586
2587         if [ -e $testroot/wt/new ]; then
2588                 echo "new file should no longer exist" >&2
2589                 test_done "$testroot" "$ret"
2590                 return 1
2591         fi
2592
2593         (cd $testroot/wt && got status > $testroot/stdout)
2594
2595         echo -n > $testroot/stdout.expected
2596         cmp -s $testroot/stdout.expected $testroot/stdout
2597         ret=$?
2598         if [ $ret -ne 0 ]; then
2599                 diff -u $testroot/stdout.expected $testroot/stdout
2600                 test_done "$testroot" "$ret"
2601                 return 1
2602         fi
2603
2604         (cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
2605         echo "commit $orig_commit (master)" > $testroot/stdout.expected
2606         cmp -s $testroot/stdout.expected $testroot/stdout
2607         ret=$?
2608         if [ $ret -ne 0 ]; then
2609                 diff -u $testroot/stdout.expected $testroot/stdout
2610         fi
2611         test_done "$testroot" "$ret"
2612 }
2613
2614 test_histedit_conflict_revert() {
2615         local testroot=`test_init histedit_conflict_revert`
2616         local orig_commit=`git_show_head $testroot/repo`
2617
2618         echo "first change of alpha" > $testroot/repo/alpha
2619         git_commit $testroot/repo -m "committing changes"
2620         local old_commit1=`git_show_head $testroot/repo`
2621         local short_old_commit1=`trim_obj_id 12 $old_commit1`
2622
2623         echo "second change of alpha" > $testroot/repo/alpha
2624         git_commit $testroot/repo -m "committing changes"
2625         local old_commit2=`git_show_head $testroot/repo`
2626         local short_old_commit2=`trim_obj_id 12 $old_commit2`
2627
2628         echo "third change of alpha" > $testroot/repo/alpha
2629         git_commit $testroot/repo -m "committing changes"
2630         local old_commit3=`git_show_head $testroot/repo`
2631         local short_old_commit3=`trim_obj_id 12 $old_commit3`
2632
2633         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2634         ret=$?
2635         if [ $ret -ne 0 ]; then
2636                 test_done "$testroot" "$ret"
2637                 return 1
2638         fi
2639
2640         echo "edit $old_commit1" > $testroot/histedit-script
2641         echo "edit $old_commit2" >> $testroot/histedit-script
2642         echo "pick $old_commit3" >> $testroot/histedit-script
2643
2644         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
2645                 > $testroot/stdout)
2646
2647         echo "G  alpha" > $testroot/stdout.expected
2648         echo "Stopping histedit for amending commit $old_commit1" \
2649                 >> $testroot/stdout.expected
2650         cmp -s $testroot/stdout.expected $testroot/stdout
2651         ret=$?
2652         if [ $ret -ne 0 ]; then
2653                 diff -u $testroot/stdout.expected $testroot/stdout
2654                 test_done "$testroot" "$ret"
2655                 return 1
2656         fi
2657
2658         echo "tweaked first change of alpha" > $testroot/wt/alpha
2659
2660         cat > $testroot/editor.sh <<EOF
2661 #!/bin/sh
2662 ed -s "\$1" <<-EOF
2663         ,s/.*/committing changes/
2664         w
2665         EOF
2666 EOF
2667         chmod +x $testroot/editor.sh
2668
2669         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
2670                 VISUAL="$testroot/editor.sh" \
2671                 got histedit -c > $testroot/stdout 2> $testroot/stderr)
2672
2673         local new_commit1=$(cd $testroot/wt && got info | \
2674                 grep 'work tree base commit:' | cut -d ' ' -f5)
2675         local short_new_commit1=`trim_obj_id 12 $new_commit1`
2676
2677         echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
2678                 > $testroot/stdout.expected
2679         echo "C  alpha" >> $testroot/stdout.expected
2680         echo "Files with new merge conflicts: 1" >> $testroot/stdout.expected
2681         echo "$short_old_commit2 -> merge conflict: committing changes" \
2682                 >> $testroot/stdout.expected
2683
2684         echo "got: conflicts must be resolved before histedit can continue" \
2685                 > $testroot/stderr.expected
2686
2687         cmp -s $testroot/stdout.expected $testroot/stdout
2688         ret=$?
2689         if [ $ret -ne 0 ]; then
2690                 diff -u $testroot/stdout.expected $testroot/stdout
2691                 test_done "$testroot" "$ret"
2692                 return 1
2693         fi
2694
2695         cmp -s $testroot/stderr.expected $testroot/stderr
2696         ret=$?
2697         if [ $ret -ne 0 ]; then
2698                 diff -u $testroot/stderr.expected $testroot/stderr
2699                 test_done "$testroot" "$ret"
2700                 return 1
2701         fi
2702
2703         (cd $testroot/wt && got revert alpha > /dev/null)
2704         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
2705                 VISUAL="$testroot/editor.sh" \
2706                 got histedit -c > $testroot/stdout 2> $testroot/stderr)
2707
2708         echo "$short_old_commit2 -> no-op change: committing changes" \
2709                 > $testroot/stdout.expected
2710         echo "C  alpha" >> $testroot/stdout.expected
2711         echo "Files with new merge conflicts: 1" >> $testroot/stdout.expected
2712         echo "$short_old_commit3 -> merge conflict: committing changes" \
2713                 >> $testroot/stdout.expected
2714
2715         cmp -s $testroot/stdout.expected $testroot/stdout
2716         ret=$?
2717         if [ $ret -ne 0 ]; then
2718                 diff -u $testroot/stdout.expected $testroot/stdout
2719                 test_done "$testroot" "$ret"
2720                 return 1
2721         fi
2722
2723         cmp -s $testroot/stderr.expected $testroot/stderr
2724         ret=$?
2725         if [ $ret -ne 0 ]; then
2726                 diff -u $testroot/stderr.expected $testroot/stderr
2727                 test_done "$testroot" "$ret"
2728                 return 1
2729         fi
2730
2731         (cd $testroot/wt && got revert alpha > /dev/null)
2732         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
2733                 VISUAL="$testroot/editor.sh" \
2734                 got histedit -c > $testroot/stdout 2> $testroot/stderr)
2735
2736         echo "$short_old_commit3 -> no-op change: committing changes" \
2737                 > $testroot/stdout.expected
2738         echo "Switching work tree to refs/heads/master" \
2739                 >> $testroot/stdout.expected
2740
2741         cmp -s $testroot/stdout.expected $testroot/stdout
2742         ret=$?
2743         if [ $ret -ne 0 ]; then
2744                 diff -u $testroot/stdout.expected $testroot/stdout
2745                 test_done "$testroot" "$ret"
2746                 return 1
2747         fi
2748
2749         echo -n > $testroot/stderr.expected
2750         cmp -s $testroot/stderr.expected $testroot/stderr
2751         ret=$?
2752         if [ $ret -ne 0 ]; then
2753                 diff -u $testroot/stderr.expected $testroot/stderr
2754                 test_done "$testroot" "$ret"
2755                 return 1
2756         fi
2757
2758         test_done "$testroot" "$ret"
2759 }
2760
2761 test_histedit_no_eof_newline() {
2762         local testroot=$(test_init histedit_no_eof_newline)
2763         local id_root=$(git_show_head "$testroot/repo")
2764
2765         got checkout "$testroot/repo" "$testroot/wt" > /dev/null
2766
2767         echo -n "fubar" >> $testroot/wt/alpha
2768
2769         (cd "$testroot/wt" && got commit -m 'no eof newline' > /dev/null)
2770         ret=$?
2771         if [ $ret -ne 0 ]; then
2772                 echo "got commit failed unexpectedly" >&2
2773                 test_done "$testroot" "$ret"
2774                 return 1
2775         fi
2776
2777         cp $testroot/wt/alpha $testroot/content.expected
2778
2779         (cd $testroot/wt && got update -c :base:- > /dev/null)
2780         ret=$?
2781         if [ $ret -ne 0 ]; then
2782                 echo "update to $id_root failed" >&2
2783                 test_done "$testroot" 1
2784                 return 1
2785         fi
2786
2787         cat > $testroot/editor.sh <<EOF
2788 #!/bin/sh
2789 ed -s "\$1" <<-EOF
2790         ,s/ eof / terminating /
2791         w
2792         EOF
2793 EOF
2794         chmod +x $testroot/editor.sh
2795
2796         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
2797             VISUAL="$testroot/editor.sh" got histedit -m > /dev/null)
2798
2799         ret=$?
2800         if [ $ret -ne 0 ]; then
2801                 echo "histedit -m failed" >&2
2802                 test_done "$testroot" $ret
2803                 return 1
2804         fi
2805
2806         cp $testroot/wt/alpha $testroot/content
2807
2808         cmp -s $testroot/content.expected $testroot/content
2809         ret=$?
2810         if [ $ret -ne 0 ]; then
2811                 diff -u $testroot/content.expected $testroot/content
2812                 test_done "$testroot" "$ret"
2813                 return 1
2814         fi
2815
2816         cat > $testroot/wt/beta <<-EOF
2817         beta
2818         2
2819         3
2820         4
2821
2822         6
2823         7
2824         8
2825         EOF
2826
2827         (cd "$testroot/wt" && got commit -m 'padding beta' > /dev/null)
2828         ret=$?
2829         if [ $ret -ne 0 ]; then
2830                 echo "got commit failed unexpectedly" >&2
2831                 test_done "$testroot" "$ret"
2832                 return 1
2833         fi
2834
2835         local id=$(git_show_head "$testroot/repo")
2836
2837         cat > $testroot/wt/beta <<-EOF
2838         betazoid
2839         3
2840         4
2841
2842         7
2843         8
2844         a
2845         b
2846         c
2847         d
2848         e
2849         f
2850         0
2851         1
2852         2
2853         3
2854         4
2855         5
2856         6
2857         7
2858         8
2859         9
2860         EOF
2861
2862         echo -n "fubar" >> $testroot/wt/beta
2863
2864         (cd "$testroot/wt" && got commit -m 'beta no eof newline' > /dev/null)
2865         ret=$?
2866         if [ $ret -ne 0 ]; then
2867                 echo "got commit failed unexpectedly" >&2
2868                 test_done "$testroot" "$ret"
2869                 return 1
2870         fi
2871
2872         cp $testroot/wt/beta $testroot/content.expected
2873
2874         (cd $testroot/wt && got update -c :base:- > /dev/null)
2875         ret=$?
2876         if [ $ret -ne 0 ]; then
2877                 echo "update to $id failed" >&2
2878                 test_done "$testroot" 1
2879                 return 1
2880         fi
2881
2882         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
2883             VISUAL="$testroot/editor.sh" got histedit -m > /dev/null)
2884
2885         ret=$?
2886         if [ $ret -ne 0 ]; then
2887                 echo "histedit -m failed" >&2
2888                 test_done "$testroot" $ret
2889                 return 1
2890         fi
2891
2892         cp $testroot/wt/beta $testroot/content
2893
2894         cmp -s $testroot/content.expected $testroot/content
2895         ret=$?
2896         if [ $ret -ne 0 ]; then
2897                 diff -u $testroot/content.expected $testroot/content
2898                 test_done "$testroot" "$ret"
2899                 return 1
2900         fi
2901
2902         test_done "$testroot" 0
2903 }
2904
2905 test_parseargs "$@"
2906 run_test test_histedit_no_op
2907 run_test test_histedit_swap
2908 run_test test_histedit_drop
2909 run_test test_histedit_fold
2910 run_test test_histedit_edit
2911 run_test test_histedit_fold_last_commit
2912 run_test test_histedit_missing_commit_pick
2913 run_test test_histedit_missing_commit_mesg
2914 run_test test_histedit_abort
2915 run_test test_histedit_path_prefix_drop
2916 run_test test_histedit_path_prefix_edit
2917 run_test test_histedit_outside_refs_heads
2918 run_test test_histedit_fold_last_commit_swap
2919 run_test test_histedit_split_commit
2920 run_test test_histedit_duplicate_commit_in_script
2921 run_test test_histedit_fold_add_delete
2922 run_test test_histedit_fold_edit_delete
2923 run_test test_histedit_fold_delete_add
2924 run_test test_histedit_fold_only
2925 run_test test_histedit_fold_only_empty_logmsg
2926 run_test test_histedit_edit_only
2927 run_test test_histedit_prepend_line
2928 run_test test_histedit_resets_committer
2929 run_test test_histedit_umask
2930 run_test test_histedit_mesg_filemode_change
2931 run_test test_histedit_drop_only
2932 run_test test_histedit_conflict_revert
2933 run_test test_histedit_no_eof_newline