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         (cd $testroot/repo && git rm -q beta)
  27         echo "new file on master" > $testroot/repo/epsilon/new
  28         (cd $testroot/repo && git 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 28 $old_commit1`
  59         local short_old_commit2=`trim_obj_id 28 $old_commit2`
  60         local short_new_commit1=`trim_obj_id 28 $new_commit1`
  61         local short_new_commit2=`trim_obj_id 28 $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         sed -i '' -e "s/$old_commit2/$new_commit2/" $testroot/diff.expected
 135         cmp -s $testroot/diff.expected $testroot/diff
 136         ret=$?
 137         if [ $ret -ne 0 ]; then
 138                 diff -u $testroot/diff.expected $testroot/diff
 139                 test_done "$testroot" "$ret"
 140                 return 1
 141         fi
 142
 143         (cd $testroot/wt && got update > $testroot/stdout)
 144
 145         echo 'Already up-to-date' > $testroot/stdout.expected
 146         cmp -s $testroot/stdout.expected $testroot/stdout
 147         ret=$?
 148         if [ $ret -ne 0 ]; then
 149                 diff -u $testroot/stdout.expected $testroot/stdout
 150                 test_done "$testroot" "$ret"
 151                 return 1
 152         fi
 153
 154         # We should have a backup of old commits
 155         (cd $testroot/repo && got histedit -l > $testroot/stdout)
 156         d_orig1=`date -u -d "@$old_author_time1" +"%G-%m-%d"`
 157
 158         local prev_LC_TIME="$LC_TIME"
 159         export LC_TIME=C
 160         d_orig2=`date -u -d "@$old_author_time2" +"%a %b %e %X %Y UTC"`
 161         export LC_TIME="$prev_LC_TIME"
 162         d_new2=`date -u -d "@$new_author_time2" +"%G-%m-%d"`
 163         d_orig=`date -u -d "@$orig_author_time" +"%G-%m-%d"`
 164         cat > $testroot/stdout.expected <<EOF
 165 -----------------------------------------------
 166 commit $old_commit2 (formerly master)
 167 from: $GOT_AUTHOR
 168 date: $d_orig2
 169
 170  committing to zeta on master
 171
 172 has become commit $new_commit2 (master)
 173  $d_new2 $GOT_AUTHOR_11  committing to zeta on master
 174 EOF
 175
 176         local is_forked=true d_fork fork_commit fork_commit_msg
 177
 178         if [ "$old_commit1" = "$new_commit1" ]; then
 179                 if [ "$old_commit2" = "$new_commit2" ]; then
 180                         is_forked=false
 181                 else
 182                         d_fork=$d_orig1
 183                         fork_commit=$new_commit1
 184                         fork_commit_msg="committing changes"
 185                 fi
 186         else
 187                 d_fork=$d_orig
 188                 fork_commit=$orig_commit
 189                 fork_commit_msg="adding the test tree"
 190         fi
 191
 192         $is_forked && cat >> $testroot/stdout.expected <<EOF
 193 history forked at $fork_commit
 194  $d_fork $GOT_AUTHOR_11  $fork_commit_msg
 195 EOF
 196
 197         cmp -s $testroot/stdout.expected $testroot/stdout
 198         ret=$?
 199         if [ $ret -ne 0 ]; then
 200                 diff -u $testroot/stdout.expected $testroot/stdout
 201                 test_done "$testroot" "$ret"
 202                 return 1
 203         fi
 204
 205         (cd $testroot/repo && got histedit -X master \
 206                 > $testroot/stdout 2> $testroot/stderr)
 207         echo -n "Deleted refs/got/backup/histedit/master/$new_commit2: " \
 208                 > $testroot/stdout.expected
 209         echo "$old_commit2" >> $testroot/stdout.expected
 210         echo -n > $testroot/stderr.expected
 211         cmp -s $testroot/stdout.expected $testroot/stdout
 212         ret=$?
 213         if [ $ret -ne 0 ]; then
 214                 diff -u $testroot/stdout.expected $testroot/stdout
 215                 test_done "$testroot" "$ret"
 216                 return 1
 217         fi
 218         cmp -s $testroot/stderr.expected $testroot/stderr
 219         ret=$?
 220         if [ $ret -ne 0 ]; then
 221                 diff -u $testroot/stderr.expected $testroot/stderr
 222                 test_done "$testroot" "$ret"
 223                 return 1
 224         fi
 225
 226         (cd $testroot/repo && got histedit -l > $testroot/stdout)
 227         echo -n > $testroot/stdout.expected
 228         cmp -s $testroot/stdout.expected $testroot/stdout
 229         ret=$?
 230         if [ $ret -ne 0 ]; then
 231                 diff -u $testroot/stdout.expected $testroot/stdout
 232         fi
 233         test_done "$testroot" "$ret"
 234 }
 235
 236 test_histedit_swap() {
 237         local testroot=`test_init histedit_swap`
 238
 239         local orig_commit=`git_show_head $testroot/repo`
 240
 241         echo "modified alpha on master" > $testroot/repo/alpha
 242         (cd $testroot/repo && git rm -q beta)
 243         echo "new file on master" > $testroot/repo/epsilon/new
 244         (cd $testroot/repo && git add epsilon/new)
 245         git_commit $testroot/repo -m "committing changes"
 246         local old_commit1=`git_show_head $testroot/repo`
 247
 248         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 249         git_commit $testroot/repo -m "committing to zeta on master"
 250         local old_commit2=`git_show_head $testroot/repo`
 251
 252         got diff -r $testroot/repo $orig_commit $old_commit2 \
 253                 > $testroot/diff.expected
 254
 255         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 256         ret=$?
 257         if [ $ret -ne 0 ]; then
 258                 test_done "$testroot" "$ret"
 259                 return 1
 260         fi
 261
 262         echo "pick $old_commit2" > $testroot/histedit-script
 263         echo "pick $old_commit1" >> $testroot/histedit-script
 264
 265         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 266                 > $testroot/stdout)
 267
 268         local new_commit2=`git_show_parent_commit $testroot/repo`
 269         local new_commit1=`git_show_head $testroot/repo`
 270
 271         local short_old_commit1=`trim_obj_id 28 $old_commit1`
 272         local short_old_commit2=`trim_obj_id 28 $old_commit2`
 273         local short_new_commit1=`trim_obj_id 28 $new_commit1`
 274         local short_new_commit2=`trim_obj_id 28 $new_commit2`
 275
 276         echo "G  epsilon/zeta" > $testroot/stdout.expected
 277         echo -n "$short_old_commit2 -> $short_new_commit2: " \
 278                 >> $testroot/stdout.expected
 279         echo "committing to zeta on master" >> $testroot/stdout.expected
 280         echo "G  alpha" >> $testroot/stdout.expected
 281         echo "D  beta" >> $testroot/stdout.expected
 282         echo "A  epsilon/new" >> $testroot/stdout.expected
 283         echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
 284                 >> $testroot/stdout.expected
 285         echo "Switching work tree to refs/heads/master" \
 286                 >> $testroot/stdout.expected
 287
 288         cmp -s $testroot/stdout.expected $testroot/stdout
 289         ret=$?
 290         if [ $ret -ne 0 ]; then
 291                 diff -u $testroot/stdout.expected $testroot/stdout
 292                 test_done "$testroot" "$ret"
 293                 return 1
 294         fi
 295
 296         echo "modified alpha on master" > $testroot/content.expected
 297         cat $testroot/wt/alpha > $testroot/content
 298         cmp -s $testroot/content.expected $testroot/content
 299         ret=$?
 300         if [ $ret -ne 0 ]; then
 301                 diff -u $testroot/content.expected $testroot/content
 302                 test_done "$testroot" "$ret"
 303                 return 1
 304         fi
 305
 306         if [ -e $testroot/wt/beta ]; then
 307                 echo "removed file beta still exists on disk" >&2
 308                 test_done "$testroot" "1"
 309                 return 1
 310         fi
 311
 312         echo "new file on master" > $testroot/content.expected
 313         cat $testroot/wt/epsilon/new > $testroot/content
 314         cmp -s $testroot/content.expected $testroot/content
 315         ret=$?
 316         if [ $ret -ne 0 ]; then
 317                 diff -u $testroot/content.expected $testroot/content
 318                 test_done "$testroot" "$ret"
 319                 return 1
 320         fi
 321
 322         (cd $testroot/wt && got status > $testroot/stdout)
 323
 324         echo -n > $testroot/stdout.expected
 325         cmp -s $testroot/stdout.expected $testroot/stdout
 326         ret=$?
 327         if [ $ret -ne 0 ]; then
 328                 diff -u $testroot/stdout.expected $testroot/stdout
 329                 test_done "$testroot" "$ret"
 330                 return 1
 331         fi
 332
 333         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 334         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
 335         echo "commit $new_commit2" >> $testroot/stdout.expected
 336         echo "commit $orig_commit" >> $testroot/stdout.expected
 337         cmp -s $testroot/stdout.expected $testroot/stdout
 338         ret=$?
 339         if [ $ret -ne 0 ]; then
 340                 diff -u $testroot/stdout.expected $testroot/stdout
 341                 test_done "$testroot" "$ret"
 342                 return 1
 343         fi
 344
 345         got diff -r $testroot/repo $orig_commit $new_commit1 \
 346                 > $testroot/diff
 347         sed -i '' -e "s/$old_commit2/$new_commit1/" $testroot/diff.expected
 348         cmp -s $testroot/diff.expected $testroot/diff
 349         ret=$?
 350         if [ $ret -ne 0 ]; then
 351                 diff -u $testroot/diff.expected $testroot/diff
 352         fi
 353         test_done "$testroot" "$ret"
 354 }
 355
 356 test_histedit_drop() {
 357         local testroot=`test_init histedit_drop`
 358         local orig_commit=`git_show_head $testroot/repo`
 359
 360         echo "modified alpha on master" > $testroot/repo/alpha
 361         (cd $testroot/repo && git rm -q beta)
 362         echo "new file on master" > $testroot/repo/epsilon/new
 363         (cd $testroot/repo && git add epsilon/new)
 364         git_commit $testroot/repo -m "committing changes"
 365         local old_commit1=`git_show_head $testroot/repo`
 366
 367         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 368         git_commit $testroot/repo -m "committing to zeta on master"
 369         local old_commit2=`git_show_head $testroot/repo`
 370
 371         got diff -r $testroot/repo $old_commit1 $old_commit2 \
 372                 > $testroot/diff.expected
 373
 374         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 375         ret=$?
 376         if [ $ret -ne 0 ]; then
 377                 test_done "$testroot" "$ret"
 378                 return 1
 379         fi
 380
 381         echo "drop $old_commit1" > $testroot/histedit-script
 382         echo "pick $old_commit2" >> $testroot/histedit-script
 383
 384         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 385                 > $testroot/stdout)
 386
 387         local new_commit2=`git_show_head $testroot/repo`
 388
 389         local short_old_commit1=`trim_obj_id 28 $old_commit1`
 390         local short_old_commit2=`trim_obj_id 28 $old_commit2`
 391         local short_new_commit2=`trim_obj_id 28 $new_commit2`
 392
 393         echo "$short_old_commit1 ->  drop commit: committing changes" \
 394                 > $testroot/stdout.expected
 395         echo "G  epsilon/zeta" >> $testroot/stdout.expected
 396         echo -n "$short_old_commit2 -> $short_new_commit2: " \
 397                 >> $testroot/stdout.expected
 398         echo "committing to zeta on master" >> $testroot/stdout.expected
 399         echo "Switching work tree to refs/heads/master" \
 400                 >> $testroot/stdout.expected
 401
 402         cmp -s $testroot/stdout.expected $testroot/stdout
 403         ret=$?
 404         if [ $ret -ne 0 ]; then
 405                 diff -u $testroot/stdout.expected $testroot/stdout
 406                 test_done "$testroot" "$ret"
 407                 return 1
 408         fi
 409
 410         for f in alpha beta; do
 411                 echo "$f" > $testroot/content.expected
 412                 cat $testroot/wt/$f > $testroot/content
 413                 cmp -s $testroot/content.expected $testroot/content
 414                 ret=$?
 415                 if [ $ret -ne 0 ]; then
 416                         diff -u $testroot/content.expected $testroot/content
 417                         test_done "$testroot" "$ret"
 418                         return 1
 419                 fi
 420         done
 421
 422         if [ -e $testroot/wt/new ]; then
 423                 echo "file new exists on disk but should not" >&2
 424                 test_done "$testroot" "1"
 425                 return 1
 426         fi
 427
 428         (cd $testroot/wt && got status > $testroot/stdout)
 429
 430         echo -n > $testroot/stdout.expected
 431         cmp -s $testroot/stdout.expected $testroot/stdout
 432         ret=$?
 433         if [ $ret -ne 0 ]; then
 434                 diff -u $testroot/stdout.expected $testroot/stdout
 435                 test_done "$testroot" "$ret"
 436                 return 1
 437         fi
 438
 439         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 440         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 441         echo "commit $orig_commit" >> $testroot/stdout.expected
 442         cmp -s $testroot/stdout.expected $testroot/stdout
 443         ret=$?
 444         if [ $ret -ne 0 ]; then
 445                 diff -u $testroot/stdout.expected $testroot/stdout
 446                 test_done "$testroot" "$ret"
 447                 return 1
 448         fi
 449
 450         got diff -r $testroot/repo $orig_commit $new_commit2 \
 451                 > $testroot/diff
 452         sed -i '' -e "s/$old_commit1/$orig_commit/" $testroot/diff.expected
 453         sed -i '' -e "s/$old_commit2/$new_commit2/" $testroot/diff.expected
 454         cmp -s $testroot/diff.expected $testroot/diff
 455         ret=$?
 456         if [ $ret -ne 0 ]; then
 457                 diff -u $testroot/diff.expected $testroot/diff
 458         fi
 459         test_done "$testroot" "$ret"
 460 }
 461
 462 test_histedit_fold() {
 463         local testroot=`test_init histedit_fold`
 464
 465         local orig_commit=`git_show_head $testroot/repo`
 466
 467         echo "modified alpha on master" > $testroot/repo/alpha
 468         (cd $testroot/repo && git rm -q beta)
 469         echo "new file on master" > $testroot/repo/epsilon/new
 470         (cd $testroot/repo && git add epsilon/new)
 471         git_commit $testroot/repo -m "committing changes"
 472         local old_commit1=`git_show_head $testroot/repo`
 473
 474         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 475         git_commit $testroot/repo -m "committing to zeta on master"
 476         local old_commit2=`git_show_head $testroot/repo`
 477
 478         echo "modified delta on master" > $testroot/repo/gamma/delta
 479         git_commit $testroot/repo -m "committing to delta on master"
 480         local old_commit3=`git_show_head $testroot/repo`
 481
 482         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 483         ret=$?
 484         if [ $ret -ne 0 ]; then
 485                 test_done "$testroot" "$ret"
 486                 return 1
 487         fi
 488
 489         echo "fold $old_commit1" > $testroot/histedit-script
 490         echo "drop $old_commit2" >> $testroot/histedit-script
 491         echo "pick $old_commit3" >> $testroot/histedit-script
 492         echo "mesg committing folded changes" >> $testroot/histedit-script
 493
 494         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 495                 > $testroot/stdout)
 496
 497         local new_commit1=`git_show_parent_commit $testroot/repo`
 498         local new_commit2=`git_show_head $testroot/repo`
 499
 500         local short_old_commit1=`trim_obj_id 28 $old_commit1`
 501         local short_old_commit2=`trim_obj_id 28 $old_commit2`
 502         local short_old_commit3=`trim_obj_id 28 $old_commit3`
 503         local short_new_commit1=`trim_obj_id 28 $new_commit1`
 504         local short_new_commit2=`trim_obj_id 28 $new_commit2`
 505
 506         echo "G  alpha" > $testroot/stdout.expected
 507         echo "D  beta" >> $testroot/stdout.expected
 508         echo "A  epsilon/new" >> $testroot/stdout.expected
 509         echo "$short_old_commit1 ->  fold commit: committing changes" \
 510                 >> $testroot/stdout.expected
 511         echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
 512         echo "drop commit: committing to zeta on master" \
 513                 >> $testroot/stdout.expected
 514         echo "G  gamma/delta" >> $testroot/stdout.expected
 515         echo -n "$short_old_commit3 -> $short_new_commit2: " \
 516                 >> $testroot/stdout.expected
 517         echo "committing folded changes" >> $testroot/stdout.expected
 518         echo "Switching work tree to refs/heads/master" \
 519                 >> $testroot/stdout.expected
 520
 521         cmp -s $testroot/stdout.expected $testroot/stdout
 522         ret=$?
 523         if [ $ret -ne 0 ]; then
 524                 diff -u $testroot/stdout.expected $testroot/stdout
 525                 test_done "$testroot" "$ret"
 526                 return 1
 527         fi
 528
 529         echo "modified alpha on master" > $testroot/content.expected
 530         cat $testroot/wt/alpha > $testroot/content
 531         cmp -s $testroot/content.expected $testroot/content
 532         ret=$?
 533         if [ $ret -ne 0 ]; then
 534                 diff -u $testroot/content.expected $testroot/content
 535                 test_done "$testroot" "$ret"
 536                 return 1
 537         fi
 538
 539         if [ -e $testroot/wt/beta ]; then
 540                 echo "removed file beta still exists on disk" >&2
 541                 test_done "$testroot" "1"
 542                 return 1
 543         fi
 544
 545         echo "new file on master" > $testroot/content.expected
 546         cat $testroot/wt/epsilon/new > $testroot/content
 547         cmp -s $testroot/content.expected $testroot/content
 548         ret=$?
 549         if [ $ret -ne 0 ]; then
 550                 diff -u $testroot/content.expected $testroot/content
 551                 test_done "$testroot" "$ret"
 552                 return 1
 553         fi
 554
 555         (cd $testroot/wt && got status > $testroot/stdout)
 556
 557         echo -n > $testroot/stdout.expected
 558         cmp -s $testroot/stdout.expected $testroot/stdout
 559         ret=$?
 560         if [ $ret -ne 0 ]; then
 561                 diff -u $testroot/stdout.expected $testroot/stdout
 562                 test_done "$testroot" "$ret"
 563                 return 1
 564         fi
 565
 566         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 567         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 568         echo "commit $orig_commit" >> $testroot/stdout.expected
 569         cmp -s $testroot/stdout.expected $testroot/stdout
 570         ret=$?
 571         if [ $ret -ne 0 ]; then
 572                 diff -u $testroot/stdout.expected $testroot/stdout
 573         fi
 574         test_done "$testroot" "$ret"
 575 }
 576
 577 test_histedit_edit() {
 578         local testroot=`test_init histedit_edit`
 579
 580         local orig_commit=`git_show_head $testroot/repo`
 581
 582         echo "modified alpha on master" > $testroot/repo/alpha
 583         (cd $testroot/repo && git rm -q beta)
 584         echo "new file on master" > $testroot/repo/epsilon/new
 585         (cd $testroot/repo && git add epsilon/new)
 586         git_commit $testroot/repo -m "committing changes"
 587         local old_commit1=`git_show_head $testroot/repo`
 588
 589         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 590         git_commit $testroot/repo -m "committing to zeta on master"
 591         local old_commit2=`git_show_head $testroot/repo`
 592
 593         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 594         ret=$?
 595         if [ $ret -ne 0 ]; then
 596                 test_done "$testroot" "$ret"
 597                 return 1
 598         fi
 599
 600         echo "edit $old_commit1" > $testroot/histedit-script
 601         echo "mesg committing changes" >> $testroot/histedit-script
 602         echo "pick $old_commit2" >> $testroot/histedit-script
 603
 604         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 605                 > $testroot/stdout)
 606
 607         local short_old_commit1=`trim_obj_id 28 $old_commit1`
 608         local short_old_commit2=`trim_obj_id 28 $old_commit2`
 609
 610         echo "G  alpha" > $testroot/stdout.expected
 611         echo "D  beta" >> $testroot/stdout.expected
 612         echo "A  epsilon/new" >> $testroot/stdout.expected
 613         echo "Stopping histedit for amending commit $old_commit1" \
 614                 >> $testroot/stdout.expected
 615         cmp -s $testroot/stdout.expected $testroot/stdout
 616         ret=$?
 617         if [ $ret -ne 0 ]; then
 618                 diff -u $testroot/stdout.expected $testroot/stdout
 619                 test_done "$testroot" "$ret"
 620                 return 1
 621         fi
 622
 623         echo "edited modified alpha on master" > $testroot/wt/alpha
 624
 625         # test interaction of 'got stage' and histedit -c
 626         (cd $testroot/wt && got stage alpha > /dev/null)
 627         (cd $testroot/wt && got histedit -c > $testroot/stdout \
 628                 2> $testroot/stderr)
 629         ret=$?
 630         if [ $ret -eq 0 ]; then
 631                 echo "histedit succeeded unexpectedly" >&2
 632                 test_done "$testroot" "1"
 633                 return 1
 634         fi
 635         echo -n "got: work tree contains files with staged changes; " \
 636                 > $testroot/stderr.expected
 637         echo "these changes must be committed or unstaged first" \
 638                 >> $testroot/stderr.expected
 639         cmp -s $testroot/stderr.expected $testroot/stderr
 640         ret=$?
 641         if [ $ret -ne 0 ]; then
 642                 diff -u $testroot/stderr.expected $testroot/stderr
 643                 test_done "$testroot" "$ret"
 644                 return 1
 645         fi
 646
 647         (cd $testroot/wt && got unstage alpha > /dev/null)
 648         (cd $testroot/wt && got histedit -c > $testroot/stdout)
 649
 650         local new_commit1=`git_show_parent_commit $testroot/repo`
 651         local new_commit2=`git_show_head $testroot/repo`
 652
 653         local short_new_commit1=`trim_obj_id 28 $new_commit1`
 654         local short_new_commit2=`trim_obj_id 28 $new_commit2`
 655
 656         echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
 657                 > $testroot/stdout.expected
 658         echo "G  epsilon/zeta" >> $testroot/stdout.expected
 659         echo -n "$short_old_commit2 -> $short_new_commit2: " \
 660                 >> $testroot/stdout.expected
 661         echo "committing to zeta on master" >> $testroot/stdout.expected
 662         echo "Switching work tree to refs/heads/master" \
 663                 >> $testroot/stdout.expected
 664
 665         cmp -s $testroot/stdout.expected $testroot/stdout
 666         ret=$?
 667         if [ $ret -ne 0 ]; then
 668                 diff -u $testroot/stdout.expected $testroot/stdout
 669                 test_done "$testroot" "$ret"
 670                 return 1
 671         fi
 672
 673         echo "edited modified alpha on master" > $testroot/content.expected
 674         cat $testroot/wt/alpha > $testroot/content
 675         cmp -s $testroot/content.expected $testroot/content
 676         ret=$?
 677         if [ $ret -ne 0 ]; then
 678                 diff -u $testroot/content.expected $testroot/content
 679                 test_done "$testroot" "$ret"
 680                 return 1
 681         fi
 682
 683         if [ -e $testroot/wt/beta ]; then
 684                 echo "removed file beta still exists on disk" >&2
 685                 test_done "$testroot" "1"
 686                 return 1
 687         fi
 688
 689         echo "new file on master" > $testroot/content.expected
 690         cat $testroot/wt/epsilon/new > $testroot/content
 691         cmp -s $testroot/content.expected $testroot/content
 692         ret=$?
 693         if [ $ret -ne 0 ]; then
 694                 diff -u $testroot/content.expected $testroot/content
 695                 test_done "$testroot" "$ret"
 696                 return 1
 697         fi
 698
 699         (cd $testroot/wt && got status > $testroot/stdout)
 700
 701         echo -n > $testroot/stdout.expected
 702         cmp -s $testroot/stdout.expected $testroot/stdout
 703         ret=$?
 704         if [ $ret -ne 0 ]; then
 705                 diff -u $testroot/stdout.expected $testroot/stdout
 706                 test_done "$testroot" "$ret"
 707                 return 1
 708         fi
 709
 710         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 711         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 712         echo "commit $new_commit1" >> $testroot/stdout.expected
 713         echo "commit $orig_commit" >> $testroot/stdout.expected
 714         cmp -s $testroot/stdout.expected $testroot/stdout
 715         ret=$?
 716         if [ $ret -ne 0 ]; then
 717                 diff -u $testroot/stdout.expected $testroot/stdout
 718         fi
 719         test_done "$testroot" "$ret"
 720 }
 721
 722 test_histedit_fold_last_commit() {
 723         local testroot=`test_init histedit_fold_last_commit`
 724
 725         local orig_commit=`git_show_head $testroot/repo`
 726
 727         echo "modified alpha on master" > $testroot/repo/alpha
 728         (cd $testroot/repo && git rm -q beta)
 729         echo "new file on master" > $testroot/repo/epsilon/new
 730         (cd $testroot/repo && git add epsilon/new)
 731         git_commit $testroot/repo -m "committing changes"
 732         local old_commit1=`git_show_head $testroot/repo`
 733
 734         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 735         git_commit $testroot/repo -m "committing to zeta on master"
 736         local old_commit2=`git_show_head $testroot/repo`
 737
 738         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 739         ret=$?
 740         if [ $ret -ne 0 ]; then
 741                 test_done "$testroot" "$ret"
 742                 return 1
 743         fi
 744
 745         echo "pick $old_commit1" > $testroot/histedit-script
 746         echo "fold $old_commit2" >> $testroot/histedit-script
 747
 748         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 749                 > $testroot/stdout 2> $testroot/stderr)
 750
 751         ret=$?
 752         if [ $ret -eq 0 ]; then
 753                 echo "histedit succeeded unexpectedly" >&2
 754                 test_done "$testroot" "1"
 755                 return 1
 756         fi
 757
 758         echo "got: last commit in histedit script cannot be folded" \
 759                 > $testroot/stderr.expected
 760
 761         cmp -s $testroot/stderr.expected $testroot/stderr
 762         ret=$?
 763         if [ $ret -ne 0 ]; then
 764                 diff -u $testroot/stderr.expected $testroot/stderr
 765         fi
 766         test_done "$testroot" "$ret"
 767 }
 768
 769 test_histedit_missing_commit() {
 770         local testroot=`test_init histedit_missing_commit`
 771
 772         local orig_commit=`git_show_head $testroot/repo`
 773
 774         echo "modified alpha on master" > $testroot/repo/alpha
 775         (cd $testroot/repo && git rm -q beta)
 776         echo "new file on master" > $testroot/repo/epsilon/new
 777         (cd $testroot/repo && git add epsilon/new)
 778         git_commit $testroot/repo -m "committing changes"
 779         local old_commit1=`git_show_head $testroot/repo`
 780
 781         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 782         git_commit $testroot/repo -m "committing to zeta on master"
 783         local old_commit2=`git_show_head $testroot/repo`
 784
 785         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 786         ret=$?
 787         if [ $ret -ne 0 ]; then
 788                 test_done "$testroot" "$ret"
 789                 return 1
 790         fi
 791
 792         echo "pick $old_commit1" > $testroot/histedit-script
 793         echo "mesg committing changes" >> $testroot/histedit-script
 794
 795         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 796                 > $testroot/stdout 2> $testroot/stderr)
 797
 798         ret=$?
 799         if [ $ret -eq 0 ]; then
 800                 echo "histedit succeeded unexpectedly" >&2
 801                 test_done "$testroot" "1"
 802                 return 1
 803         fi
 804
 805         echo "got: commit $old_commit2 missing from histedit script" \
 806                 > $testroot/stderr.expected
 807
 808         cmp -s $testroot/stderr.expected $testroot/stderr
 809         ret=$?
 810         if [ $ret -ne 0 ]; then
 811                 diff -u $testroot/stderr.expected $testroot/stderr
 812         fi
 813         test_done "$testroot" "$ret"
 814 }
 815
 816 test_histedit_abort() {
 817         local testroot=`test_init histedit_abort`
 818
 819         local orig_commit=`git_show_head $testroot/repo`
 820
 821         echo "modified alpha on master" > $testroot/repo/alpha
 822         (cd $testroot/repo && git rm -q beta)
 823         echo "new file on master" > $testroot/repo/epsilon/new
 824         (cd $testroot/repo && git add epsilon/new)
 825         git_commit $testroot/repo -m "committing changes"
 826         local old_commit1=`git_show_head $testroot/repo`
 827
 828         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
 829         git_commit $testroot/repo -m "committing to zeta on master"
 830         local old_commit2=`git_show_head $testroot/repo`
 831
 832         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
 833         ret=$?
 834         if [ $ret -ne 0 ]; then
 835                 test_done "$testroot" "$ret"
 836                 return 1
 837         fi
 838
 839         # unrelated unversioned file in work tree
 840         touch $testroot/wt/unversioned-file
 841
 842         echo "edit $old_commit1" > $testroot/histedit-script
 843         echo "mesg committing changes" >> $testroot/histedit-script
 844         echo "pick $old_commit2" >> $testroot/histedit-script
 845
 846         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 847                 > $testroot/stdout)
 848
 849         local short_old_commit1=`trim_obj_id 28 $old_commit1`
 850         local short_old_commit2=`trim_obj_id 28 $old_commit2`
 851
 852         echo "G  alpha" > $testroot/stdout.expected
 853         echo "D  beta" >> $testroot/stdout.expected
 854         echo "A  epsilon/new" >> $testroot/stdout.expected
 855         echo "Stopping histedit for amending commit $old_commit1" \
 856                 >> $testroot/stdout.expected
 857         cmp -s $testroot/stdout.expected $testroot/stdout
 858         ret=$?
 859         if [ $ret -ne 0 ]; then
 860                 diff -u $testroot/stdout.expected $testroot/stdout
 861                 test_done "$testroot" "$ret"
 862                 return 1
 863         fi
 864
 865         echo "edited modified alpha on master" > $testroot/wt/alpha
 866
 867         (cd $testroot/wt && got histedit -a > $testroot/stdout)
 868
 869         local new_commit1=`git_show_parent_commit $testroot/repo`
 870         local new_commit2=`git_show_head $testroot/repo`
 871
 872         echo "Switching work tree to refs/heads/master" \
 873                 > $testroot/stdout.expected
 874         echo "R  alpha" >> $testroot/stdout.expected
 875         echo "R  beta" >> $testroot/stdout.expected
 876         echo "R  epsilon/new" >> $testroot/stdout.expected
 877         echo "Histedit of refs/heads/master aborted" \
 878                 >> $testroot/stdout.expected
 879
 880         cmp -s $testroot/stdout.expected $testroot/stdout
 881         ret=$?
 882         if [ $ret -ne 0 ]; then
 883                 diff -u $testroot/stdout.expected $testroot/stdout
 884                 test_done "$testroot" "$ret"
 885                 return 1
 886         fi
 887
 888         for f in alpha beta; do
 889                 echo "$f" > $testroot/content.expected
 890                 cat $testroot/wt/$f > $testroot/content
 891                 cmp -s $testroot/content.expected $testroot/content
 892                 ret=$?
 893                 if [ $ret -ne 0 ]; then
 894                         diff -u $testroot/content.expected $testroot/content
 895                         test_done "$testroot" "$ret"
 896                         return 1
 897                 fi
 898         done
 899
 900         echo "new file on master" > $testroot/content.expected
 901         cat $testroot/wt/epsilon/new > $testroot/content
 902         cmp -s $testroot/content.expected $testroot/content
 903         ret=$?
 904         if [ $ret -ne 0 ]; then
 905                 diff -u $testroot/content.expected $testroot/content
 906                 test_done "$testroot" "$ret"
 907                 return 1
 908         fi
 909
 910         (cd $testroot/wt && got status > $testroot/stdout)
 911
 912         echo "?  epsilon/new" > $testroot/stdout.expected
 913         echo "?  unversioned-file" >> $testroot/stdout.expected
 914         cmp -s $testroot/stdout.expected $testroot/stdout
 915         ret=$?
 916         if [ $ret -ne 0 ]; then
 917                 diff -u $testroot/stdout.expected $testroot/stdout
 918                 test_done "$testroot" "$ret"
 919                 return 1
 920         fi
 921
 922         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
 923         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
 924         echo "commit $new_commit1" >> $testroot/stdout.expected
 925         echo "commit $orig_commit" >> $testroot/stdout.expected
 926         cmp -s $testroot/stdout.expected $testroot/stdout
 927         ret=$?
 928         if [ $ret -ne 0 ]; then
 929                 diff -u $testroot/stdout.expected $testroot/stdout
 930         fi
 931         test_done "$testroot" "$ret"
 932 }
 933
 934 test_histedit_path_prefix_drop() {
 935         local testroot=`test_init histedit_path_prefix_drop`
 936         local orig_commit=`git_show_head $testroot/repo`
 937
 938         echo "modified zeta" > $testroot/repo/epsilon/zeta
 939         git_commit $testroot/repo -m "changing zeta"
 940         local old_commit1=`git_show_head $testroot/repo`
 941
 942         got checkout -c $orig_commit -p gamma $testroot/repo \
 943                 $testroot/wt > /dev/null
 944         ret=$?
 945         if [ $ret -ne 0 ]; then
 946                 test_done "$testroot" "$ret"
 947                 return 1
 948         fi
 949
 950         echo "drop $old_commit1" > $testroot/histedit-script
 951
 952         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 953                 > $testroot/stdout 2> $testroot/stderr)
 954
 955         ret=$?
 956         if [ $ret -eq 0 ]; then
 957                 echo "histedit succeeded unexpectedly" >&2
 958                 test_done "$testroot" "1"
 959                 return 1
 960         fi
 961
 962         echo -n "got: cannot edit branch history which contains changes " \
 963                 > $testroot/stderr.expected
 964         echo "outside of this work tree's path prefix" \
 965                 >> $testroot/stderr.expected
 966
 967         cmp -s $testroot/stderr.expected $testroot/stderr
 968         ret=$?
 969         if [ $ret -ne 0 ]; then
 970                 diff -u $testroot/stderr.expected $testroot/stderr
 971                 test_done "$testroot" "$ret"
 972                 return 1
 973         fi
 974
 975         rm -rf $testroot/wt
 976         got checkout -c $orig_commit -p epsilon $testroot/repo \
 977                 $testroot/wt > /dev/null
 978         ret=$?
 979         if [ $ret -ne 0 ]; then
 980                 test_done "$testroot" "$ret"
 981                 return 1
 982         fi
 983         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
 984                 > $testroot/stdout)
 985
 986         local short_old_commit1=`trim_obj_id 28 $old_commit1`
 987         local short_old_commit2=`trim_obj_id 28 $old_commit2`
 988
 989         echo "$short_old_commit1 ->  drop commit: changing zeta" \
 990                 > $testroot/stdout.expected
 991         echo "Switching work tree to refs/heads/master" \
 992                 >> $testroot/stdout.expected
 993
 994         cmp -s $testroot/stdout.expected $testroot/stdout
 995         ret=$?
 996         if [ $ret -ne 0 ]; then
 997                 diff -u $testroot/stdout.expected $testroot/stdout
 998                 test_done "$testroot" "$ret"
 999                 return 1
1000         fi
1001
1002         echo "zeta" > $testroot/content.expected
1003         cat $testroot/wt/zeta > $testroot/content
1004         cmp -s $testroot/content.expected $testroot/content
1005         ret=$?
1006         if [ $ret -ne 0 ]; then
1007                 diff -u $testroot/content.expected $testroot/content
1008                 test_done "$testroot" "$ret"
1009                 return 1
1010         fi
1011
1012
1013         (cd $testroot/wt && got status > $testroot/stdout)
1014
1015         echo -n > $testroot/stdout.expected
1016         cmp -s $testroot/stdout.expected $testroot/stdout
1017         ret=$?
1018         if [ $ret -ne 0 ]; then
1019                 diff -u $testroot/stdout.expected $testroot/stdout
1020                 test_done "$testroot" "$ret"
1021                 return 1
1022         fi
1023
1024         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1025         echo "commit $orig_commit (master)" > $testroot/stdout.expected
1026         cmp -s $testroot/stdout.expected $testroot/stdout
1027         ret=$?
1028         if [ $ret -ne 0 ]; then
1029                 diff -u $testroot/stdout.expected $testroot/stdout
1030         fi
1031         test_done "$testroot" "$ret"
1032 }
1033
1034 test_histedit_path_prefix_edit() {
1035         local testroot=`test_init histedit_path_prefix_edit`
1036         local orig_commit=`git_show_head $testroot/repo`
1037
1038         echo "modified zeta" > $testroot/repo/epsilon/zeta
1039         git_commit $testroot/repo -m "changing zeta"
1040         local old_commit1=`git_show_head $testroot/repo`
1041
1042         got diff -r $testroot/repo $orig_commit $old_commit1 \
1043                 > $testroot/diff.expected
1044
1045         got checkout -c $orig_commit -p gamma $testroot/repo \
1046                 $testroot/wt > /dev/null
1047         ret=$?
1048         if [ $ret -ne 0 ]; then
1049                 test_done "$testroot" "$ret"
1050                 return 1
1051         fi
1052
1053         echo "edit $old_commit1" > $testroot/histedit-script
1054         echo "mesg modified zeta" >> $testroot/histedit-script
1055
1056         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1057                 > $testroot/stdout 2> $testroot/stderr)
1058
1059         ret=$?
1060         if [ $ret -eq 0 ]; then
1061                 echo "histedit succeeded unexpectedly" >&2
1062                 test_done "$testroot" "1"
1063                 return 1
1064         fi
1065
1066         echo -n "got: cannot edit branch history which contains changes " \
1067                 > $testroot/stderr.expected
1068         echo "outside of this work tree's path prefix" \
1069                 >> $testroot/stderr.expected
1070
1071         cmp -s $testroot/stderr.expected $testroot/stderr
1072         ret=$?
1073         if [ $ret -ne 0 ]; then
1074                 diff -u $testroot/stderr.expected $testroot/stderr
1075                 test_done "$testroot" "$ret"
1076                 return 1
1077         fi
1078
1079         rm -rf $testroot/wt
1080         got checkout -c $orig_commit -p epsilon $testroot/repo \
1081                 $testroot/wt > /dev/null
1082         ret=$?
1083         if [ $ret -ne 0 ]; then
1084                 test_done "$testroot" "$ret"
1085                 return 1
1086         fi
1087         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1088                 > $testroot/stdout)
1089
1090         local short_old_commit1=`trim_obj_id 28 $old_commit1`
1091
1092         echo "G  zeta" > $testroot/stdout.expected
1093         echo "Stopping histedit for amending commit $old_commit1" \
1094                 >> $testroot/stdout.expected
1095         cmp -s $testroot/stdout.expected $testroot/stdout
1096         ret=$?
1097         if [ $ret -ne 0 ]; then
1098                 diff -u $testroot/stdout.expected $testroot/stdout
1099                 test_done "$testroot" "$ret"
1100                 return 1
1101         fi
1102
1103         echo "modified zeta" > $testroot/content.expected
1104         cat $testroot/wt/zeta > $testroot/content
1105         cmp -s $testroot/content.expected $testroot/content
1106         ret=$?
1107         if [ $ret -ne 0 ]; then
1108                 diff -u $testroot/content.expected $testroot/content
1109                 test_done "$testroot" "$ret"
1110                 return 1
1111         fi
1112
1113         (cd $testroot/wt && got status > $testroot/stdout)
1114
1115         echo "M  zeta"> $testroot/stdout.expected
1116         cmp -s $testroot/stdout.expected $testroot/stdout
1117         ret=$?
1118         if [ $ret -ne 0 ]; then
1119                 diff -u $testroot/stdout.expected $testroot/stdout
1120                 test_done "$testroot" "$ret"
1121                 return 1
1122         fi
1123
1124         (cd $testroot/wt && got histedit -c > $testroot/stdout)
1125
1126         local new_commit1=`git_show_head $testroot/repo`
1127         local short_new_commit1=`trim_obj_id 28 $new_commit1`
1128
1129         echo -n "$short_old_commit1 -> $short_new_commit1: " \
1130                 > $testroot/stdout.expected
1131         echo "modified zeta" >> $testroot/stdout.expected
1132         echo "Switching work tree to refs/heads/master" \
1133                 >> $testroot/stdout.expected
1134
1135         cmp -s $testroot/stdout.expected $testroot/stdout
1136         ret=$?
1137         if [ $ret -ne 0 ]; then
1138                 diff -u $testroot/stdout.expected $testroot/stdout
1139                 test_done "$testroot" "$ret"
1140                 return 1
1141         fi
1142
1143         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1144         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1145         echo "commit $orig_commit" >> $testroot/stdout.expected
1146         cmp -s $testroot/stdout.expected $testroot/stdout
1147         ret=$?
1148         if [ $ret -ne 0 ]; then
1149                 diff -u $testroot/stdout.expected $testroot/stdout
1150                 test_done "$testroot" "$ret"
1151                 return 1
1152         fi
1153
1154         got diff -r $testroot/repo $orig_commit $new_commit1 \
1155                 > $testroot/diff
1156         sed -i '' -e "s/$old_commit1/$new_commit1/" $testroot/diff.expected
1157         cmp -s $testroot/diff.expected $testroot/diff
1158         ret=$?
1159         if [ $ret -ne 0 ]; then
1160                 diff -u $testroot/diff.expected $testroot/diff
1161         fi
1162         test_done "$testroot" "$ret"
1163 }
1164
1165 test_histedit_outside_refs_heads() {
1166         local testroot=`test_init histedit_outside_refs_heads`
1167         local commit1=`git_show_head $testroot/repo`
1168
1169         got checkout $testroot/repo $testroot/wt > /dev/null
1170         ret=$?
1171         if [ $ret -ne 0 ]; then
1172                 echo "got checkout failed unexpectedly"
1173                 test_done "$testroot" "$ret"
1174                 return 1
1175         fi
1176
1177         echo "modified alpha" > $testroot/wt/alpha
1178
1179         (cd $testroot/wt && got commit -m 'change alpha' \
1180                 > $testroot/stdout 2> $testroot/stderr)
1181         ret=$?
1182         if [ $ret -ne 0 ]; then
1183                 echo "got commit failed unexpectedly" >&2
1184                 test_done "$testroot" "1"
1185                 return 1
1186         fi
1187         local commit2=`git_show_head $testroot/repo`
1188
1189         got ref -r $testroot/repo -c master refs/remotes/origin/master
1190         ret=$?
1191         if [ $ret -ne 0 ]; then
1192                 echo "got ref failed unexpectedly" >&2
1193                 test_done "$testroot" "1"
1194                 return 1
1195         fi
1196
1197         (cd $testroot/wt && got update -b origin/master -c $commit1 >/dev/null)
1198         ret=$?
1199         if [ $ret -ne 0 ]; then
1200                 echo "got update failed unexpectedly"
1201                 test_done "$testroot" "$ret"
1202                 return 1
1203         fi
1204
1205         echo "edit $commit2" > $testroot/histedit-script
1206         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1207                 2> $testroot/stderr)
1208
1209         echo -n "got: will not edit commit history of a branch outside the " \
1210                 > $testroot/stderr.expected
1211         echo '"refs/heads/" reference namespace' \
1212                 >> $testroot/stderr.expected
1213         cmp -s $testroot/stderr.expected $testroot/stderr
1214         ret=$?
1215         if [ $ret -ne 0 ]; then
1216                 diff -u $testroot/stderr.expected $testroot/stderr
1217         fi
1218         test_done "$testroot" "$ret"
1219 }
1220
1221 test_histedit_fold_last_commit_swap() {
1222         local testroot=`test_init histedit_fold_last_commit_swap`
1223
1224         local orig_commit=`git_show_head $testroot/repo`
1225
1226         echo "modified alpha on master" > $testroot/repo/alpha
1227         (cd $testroot/repo && git rm -q beta)
1228         echo "new file on master" > $testroot/repo/epsilon/new
1229         (cd $testroot/repo && git add epsilon/new)
1230         git_commit $testroot/repo -m "committing changes"
1231         local old_commit1=`git_show_head $testroot/repo`
1232
1233         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1234         git_commit $testroot/repo -m "committing to zeta on master"
1235         local old_commit2=`git_show_head $testroot/repo`
1236
1237         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1238         ret=$?
1239         if [ $ret -ne 0 ]; then
1240                 test_done "$testroot" "$ret"
1241                 return 1
1242         fi
1243
1244         # fold commit2 into commit1 (requires swapping commits)
1245         echo "fold $old_commit2" > $testroot/histedit-script
1246         echo "pick $old_commit1" >> $testroot/histedit-script
1247         echo "mesg committing folded changes" >> $testroot/histedit-script
1248
1249         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1250                 > $testroot/stdout 2> $testroot/stderr)
1251
1252         ret=$?
1253         if [ $ret -ne 0 ]; then
1254                 echo "histedit failed unexpectedly" >&2
1255                 test_done "$testroot" "$ret"
1256                 return 1
1257         fi
1258
1259         local new_commit=`git_show_head $testroot/repo`
1260
1261         local short_old_commit1=`trim_obj_id 28 $old_commit1`
1262         local short_old_commit2=`trim_obj_id 28 $old_commit2`
1263         local short_new_commit=`trim_obj_id 28 $new_commit`
1264
1265         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1266         echo -n "$short_old_commit2 ->  fold commit: committing to zeta " \
1267                 >> $testroot/stdout.expected
1268         echo "on master" >> $testroot/stdout.expected
1269         echo "G  alpha" >> $testroot/stdout.expected
1270         echo "D  beta" >> $testroot/stdout.expected
1271         echo "A  epsilon/new" >> $testroot/stdout.expected
1272         echo -n "$short_old_commit1 -> $short_new_commit: " \
1273                 >> $testroot/stdout.expected
1274         echo "committing folded changes" >> $testroot/stdout.expected
1275         echo "Switching work tree to refs/heads/master" \
1276                 >> $testroot/stdout.expected
1277
1278         cmp -s $testroot/stdout.expected $testroot/stdout
1279         ret=$?
1280         if [ $ret -ne 0 ]; then
1281                 diff -u $testroot/stdout.expected $testroot/stdout
1282         fi
1283         test_done "$testroot" "$ret"
1284 }
1285
1286 test_histedit_split_commit() {
1287         local testroot=`test_init histedit_split_commit`
1288
1289         local orig_commit=`git_show_head $testroot/repo`
1290
1291         echo "modified alpha on master" > $testroot/repo/alpha
1292         (cd $testroot/repo && git rm -q beta)
1293         echo "new file on master" > $testroot/repo/epsilon/new
1294         (cd $testroot/repo && git add epsilon/new)
1295         git_commit $testroot/repo -m "committing changes 1"
1296         local old_commit1=`git_show_head $testroot/repo`
1297         local short_old_commit1=`trim_obj_id 28 $old_commit1`
1298
1299         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1300         git_commit $testroot/repo -m "committing changes 2"
1301         local old_commit2=`git_show_head $testroot/repo`
1302         local short_old_commit2=`trim_obj_id 28 $old_commit2`
1303
1304         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1305         ret=$?
1306         if [ $ret -ne 0 ]; then
1307                 test_done "$testroot" "$ret"
1308                 return 1
1309         fi
1310
1311         # split commit1 into commitA and commitB and commitC
1312         echo "e $old_commit1" > $testroot/histedit-script
1313         echo "p $old_commit2" >> $testroot/histedit-script
1314
1315         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1316                 > $testroot/stdout 2> $testroot/stderr)
1317         ret=$?
1318         if [ $ret -ne 0 ]; then
1319                 echo "histedit failed unexpectedly:" >&2
1320                 cat $testroot/stderr >&2
1321                 test_done "$testroot" "$ret"
1322                 return 1
1323         fi
1324
1325         echo "G  alpha" > $testroot/stdout.expected
1326         echo "D  beta" >> $testroot/stdout.expected
1327         echo "A  epsilon/new" >> $testroot/stdout.expected
1328         echo "Stopping histedit for amending commit $old_commit1" \
1329                 >> $testroot/stdout.expected
1330
1331         cmp -s $testroot/stdout.expected $testroot/stdout
1332         ret=$?
1333         if [ $ret -ne 0 ]; then
1334                 diff -u $testroot/stdout.expected $testroot/stdout
1335                 test_done "$testroot" "$ret"
1336                 return 1
1337         fi
1338
1339         (cd $testroot/wt && got ci -m "commitA" alpha >/dev/null)
1340         ret=$?
1341         if [ $ret -ne 0 ]; then
1342                 echo "commit failed unexpectedly" >&2
1343                 test_done "$testroot" "$ret"
1344                 return 1
1345         fi
1346
1347         (cd $testroot/wt && got ci -m "commitB" beta >/dev/null)
1348         ret=$?
1349         if [ $ret -ne 0 ]; then
1350                 echo "commit failed unexpectedly" >&2
1351                 test_done "$testroot" "$ret"
1352                 return 1
1353         fi
1354
1355         (cd $testroot/wt && got ci -m "commitC" epsilon/new >/dev/null)
1356         ret=$?
1357         if [ $ret -ne 0 ]; then
1358                 echo "commit failed unexpectedly" >&2
1359                 test_done "$testroot" "$ret"
1360                 return 1
1361         fi
1362
1363         (cd $testroot/wt && got histedit -c \
1364                 > $testroot/stdout 2> $testroot/stderr)
1365         ret=$?
1366         if [ $ret -ne 0 ]; then
1367                 echo "histedit failed unexpectedly:" >&2
1368                 cat $testroot/stderr >&2
1369                 test_done "$testroot" "$ret"
1370                 return 1
1371         fi
1372         local new_commit2=`git_show_head $testroot/repo`
1373         local short_new_commit2=`trim_obj_id 28 $new_commit2`
1374
1375         echo "$short_old_commit1 -> no-op change: committing changes 1" \
1376                 > $testroot/stdout.expected
1377         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1378         echo "$short_old_commit2 -> $short_new_commit2: committing changes 2" \
1379                 >> $testroot/stdout.expected
1380         echo "Switching work tree to refs/heads/master" \
1381                 >> $testroot/stdout.expected
1382
1383         cmp -s $testroot/stdout.expected $testroot/stdout
1384         ret=$?
1385         if [ $ret -ne 0 ]; then
1386                 diff -u $testroot/stdout.expected $testroot/stdout
1387         fi
1388         test_done "$testroot" "$ret"
1389
1390 }
1391
1392 test_histedit_duplicate_commit_in_script() {
1393         local testroot=`test_init histedit_duplicate_commit_in_script`
1394
1395         local orig_commit=`git_show_head $testroot/repo`
1396
1397         echo "modified alpha on master" > $testroot/repo/alpha
1398         (cd $testroot/repo && git rm -q beta)
1399         echo "new file on master" > $testroot/repo/epsilon/new
1400         (cd $testroot/repo && git add epsilon/new)
1401         git_commit $testroot/repo -m "committing changes 1"
1402         local old_commit1=`git_show_head $testroot/repo`
1403
1404         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1405         git_commit $testroot/repo -m "committing changes 2"
1406         local old_commit2=`git_show_head $testroot/repo`
1407
1408         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1409         ret=$?
1410         if [ $ret -ne 0 ]; then
1411                 test_done "$testroot" "$ret"
1412                 return 1
1413         fi
1414
1415         # This histedit script lists commit1 more than once
1416         echo "p $old_commit1" > $testroot/histedit-script
1417         echo "p $old_commit1" >> $testroot/histedit-script
1418         echo "p $old_commit2" >> $testroot/histedit-script
1419
1420         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1421                 > $testroot/stdout 2> $testroot/stderr)
1422         ret=$?
1423         if [ $ret -eq 0 ]; then
1424                 echo "histedit succeeded unexpectedly:" >&2
1425                 cat $testroot/stdout >&2
1426                 test_done "$testroot" "$ret"
1427                 return 1
1428         fi
1429
1430         echo -n "got: commit $old_commit1 is listed more than once " \
1431                 > $testroot/stderr.expected
1432         echo "in histedit script" >> $testroot/stderr.expected
1433
1434         cmp -s $testroot/stderr.expected $testroot/stderr
1435         ret=$?
1436         if [ $ret -ne 0 ]; then
1437                 diff -u $testroot/stderr.expected $testroot/stderr
1438         fi
1439         test_done "$testroot" "$ret"
1440
1441 }
1442
1443 # if a previous commit introduces a new file, and it is folded into a commit
1444 # that deletes the same file, the file still exists after the histedit
1445 test_histedit_fold_add_delete() {
1446         local testroot=`test_init histedit_fold_add_delete`
1447
1448         local orig_commit=`git_show_head $testroot/repo`
1449
1450         echo "added new file epsilon/psi" > $testroot/repo/epsilon/psi
1451         (cd $testroot/repo && git add epsilon/psi)
1452         git_commit $testroot/repo -m "committing changes"
1453         local old_commit1=`git_show_head $testroot/repo`
1454
1455         echo "modified epsilon/psi" > $testroot/repo/epsilon/psi
1456         git_commit $testroot/repo -m "editing psi"
1457         local old_commit2=`git_show_head $testroot/repo`
1458
1459         (cd $testroot/repo && git rm -q epsilon/psi)
1460         git_commit $testroot/repo -m "removing psi"
1461         local old_commit3=`git_show_head $testroot/repo`
1462
1463         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1464         ret=$?
1465         if [ $ret -ne 0 ]; then
1466                 test_done "$testroot" "$ret"
1467                 return 1
1468         fi
1469
1470         echo "fold $old_commit1" > $testroot/histedit-script
1471         echo "fold $old_commit2" >> $testroot/histedit-script
1472         echo "pick $old_commit3" >> $testroot/histedit-script
1473         echo "mesg folded changes" >> $testroot/histedit-script
1474
1475         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
1476                 > $testroot/stdout)
1477
1478         local new_commit1=`git_show_head $testroot/repo`
1479
1480         local short_old_commit1=`trim_obj_id 28 $old_commit1`
1481         local short_old_commit2=`trim_obj_id 28 $old_commit2`
1482         local short_old_commit3=`trim_obj_id 28 $old_commit3`
1483         local short_new_commit1=`trim_obj_id 28 $new_commit1`
1484
1485         echo "A  epsilon/psi" >> $testroot/stdout.expected
1486         echo "$short_old_commit1 ->  fold commit: committing changes" \
1487                 >> $testroot/stdout.expected
1488         echo "G  epsilon/psi" >> $testroot/stdout.expected
1489         echo "$short_old_commit2 ->  fold commit: editing psi" \
1490                 >> $testroot/stdout.expected
1491         echo "D  epsilon/psi" >> $testroot/stdout.expected
1492         echo "$short_old_commit3 -> no-op change: folded changes" \
1493                 >> $testroot/stdout.expected
1494         echo "Switching work tree to refs/heads/master" \
1495                 >> $testroot/stdout.expected
1496
1497         cmp -s $testroot/stdout.expected $testroot/stdout
1498         ret=$?
1499         if [ $ret -ne 0 ]; then
1500                 diff -u $testroot/stdout.expected $testroot/stdout
1501                 test_done "$testroot" "$ret"
1502                 return 1
1503         fi
1504
1505         if [ -e $testroot/wt/epsilon/psi ]; then
1506                 echo "removed file psi still exists on disk" >&2
1507                 test_done "$testroot" "1"
1508                 return 1
1509         fi
1510
1511         (cd $testroot/wt && got status > $testroot/stdout)
1512
1513         echo -n > $testroot/stdout.expected
1514         cmp -s $testroot/stdout.expected $testroot/stdout
1515         ret=$?
1516         if [ $ret -ne 0 ]; then
1517                 diff -u $testroot/stdout.expected $testroot/stdout
1518                 test_done "$testroot" "$ret"
1519                 return 1
1520         fi
1521
1522         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1523         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1524         cmp -s $testroot/stdout.expected $testroot/stdout
1525         ret=$?
1526         if [ $ret -ne 0 ]; then
1527                 diff -u $testroot/stdout.expected $testroot/stdout
1528                 test_done "$testroot" "$ret"
1529                 return 1
1530         fi
1531
1532         got tree -r $testroot/repo epsilon > $testroot/stdout
1533         echo "zeta" > $testroot/stdout.expected
1534         cmp -s $testroot/stdout.expected $testroot/stdout
1535         ret=$?
1536         if [ $ret -ne 0 ]; then
1537                 diff -u $testroot/stdout.expected $testroot/stdout
1538         fi
1539         test_done "$testroot" "$ret"
1540 }
1541
1542 test_histedit_fold_only() {
1543         local testroot=`test_init histedit_fold_only`
1544
1545         local orig_commit=`git_show_head $testroot/repo`
1546
1547         echo "modified alpha on master" > $testroot/repo/alpha
1548         (cd $testroot/repo && git rm -q beta)
1549         echo "new file on master" > $testroot/repo/epsilon/new
1550         (cd $testroot/repo && git add epsilon/new)
1551         git_commit $testroot/repo -m "committing changes"
1552         local old_commit1=`git_show_head $testroot/repo`
1553
1554         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1555         git_commit $testroot/repo -m "committing to zeta on master"
1556         local old_commit2=`git_show_head $testroot/repo`
1557
1558         echo "modified delta on master" > $testroot/repo/gamma/delta
1559         git_commit $testroot/repo -m "committing to delta on master"
1560         local old_commit3=`git_show_head $testroot/repo`
1561
1562         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1563         ret=$?
1564         if [ $ret -ne 0 ]; then
1565                 test_done "$testroot" "$ret"
1566                 return 1
1567         fi
1568
1569         cat > $testroot/editor.sh <<EOF
1570 #!/bin/sh
1571 SOPTS='-i ""'
1572 [ "\$OSTYPE" = "linux-gnu" ] && SOPTS="-i"
1573 sed "\$SOPTS" -e 's/.*/committing folded changes/' "\$1"
1574 EOF
1575         chmod +x $testroot/editor.sh
1576
1577         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1578                 VISUAL="$testroot/editor.sh" got histedit -f > $testroot/stdout)
1579
1580         local new_commit1=`git_show_head $testroot/repo`
1581
1582         local short_old_commit1=`trim_obj_id 28 $old_commit1`
1583         local short_old_commit2=`trim_obj_id 28 $old_commit2`
1584         local short_old_commit3=`trim_obj_id 28 $old_commit3`
1585         local short_new_commit1=`trim_obj_id 28 $new_commit1`
1586         local short_new_commit2=`trim_obj_id 28 $new_commit2`
1587
1588         echo "G  alpha" > $testroot/stdout.expected
1589         echo "D  beta" >> $testroot/stdout.expected
1590         echo "A  epsilon/new" >> $testroot/stdout.expected
1591         echo "$short_old_commit1 ->  fold commit: committing changes" \
1592                 >> $testroot/stdout.expected
1593         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1594         echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
1595         echo "fold commit: committing to zeta on master" \
1596                 >> $testroot/stdout.expected
1597         echo "G  gamma/delta" >> $testroot/stdout.expected
1598         echo -n "$short_old_commit3 -> $short_new_commit1: " \
1599                 >> $testroot/stdout.expected
1600         echo "committing folded changes" >> $testroot/stdout.expected
1601         echo "Switching work tree to refs/heads/master" \
1602                 >> $testroot/stdout.expected
1603
1604         cmp -s $testroot/stdout.expected $testroot/stdout
1605         ret=$?
1606         if [ $ret -ne 0 ]; then
1607                 diff -u $testroot/stdout.expected $testroot/stdout
1608                 test_done "$testroot" "$ret"
1609                 return 1
1610         fi
1611
1612         echo "modified alpha on master" > $testroot/content.expected
1613         cat $testroot/wt/alpha > $testroot/content
1614         cmp -s $testroot/content.expected $testroot/content
1615         ret=$?
1616         if [ $ret -ne 0 ]; then
1617                 diff -u $testroot/content.expected $testroot/content
1618                 test_done "$testroot" "$ret"
1619                 return 1
1620         fi
1621
1622         if [ -e $testroot/wt/beta ]; then
1623                 echo "removed file beta still exists on disk" >&2
1624                 test_done "$testroot" "1"
1625                 return 1
1626         fi
1627
1628         echo "new file on master" > $testroot/content.expected
1629         cat $testroot/wt/epsilon/new > $testroot/content
1630         cmp -s $testroot/content.expected $testroot/content
1631         ret=$?
1632         if [ $ret -ne 0 ]; then
1633                 diff -u $testroot/content.expected $testroot/content
1634                 test_done "$testroot" "$ret"
1635                 return 1
1636         fi
1637
1638         (cd $testroot/wt && got status > $testroot/stdout)
1639
1640         echo -n > $testroot/stdout.expected
1641         cmp -s $testroot/stdout.expected $testroot/stdout
1642         ret=$?
1643         if [ $ret -ne 0 ]; then
1644                 diff -u $testroot/stdout.expected $testroot/stdout
1645                 test_done "$testroot" "$ret"
1646                 return 1
1647         fi
1648
1649         (cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
1650         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1651         echo "commit $orig_commit" >> $testroot/stdout.expected
1652         cmp -s $testroot/stdout.expected $testroot/stdout
1653         ret=$?
1654         if [ $ret -ne 0 ]; then
1655                 diff -u $testroot/stdout.expected $testroot/stdout
1656         fi
1657         test_done "$testroot" "$ret"
1658 }
1659
1660 test_histedit_fold_only_empty_logmsg() {
1661         local testroot=`test_init histedit_fold_only_empty_logmsg`
1662
1663         local orig_commit=`git_show_head $testroot/repo`
1664
1665         echo "modified alpha on master" > $testroot/repo/alpha
1666         (cd $testroot/repo && git rm -q beta)
1667         echo "new file on master" > $testroot/repo/epsilon/new
1668         (cd $testroot/repo && git add epsilon/new)
1669         git_commit $testroot/repo -m "committing changes"
1670         local old_commit1=`git_show_head $testroot/repo`
1671
1672         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1673         git_commit $testroot/repo -m "committing to zeta on master"
1674         local old_commit2=`git_show_head $testroot/repo`
1675
1676         echo "modified delta on master" > $testroot/repo/gamma/delta
1677         git_commit $testroot/repo -m "committing to delta on master"
1678         local old_commit3=`git_show_head $testroot/repo`
1679
1680         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1681         ret=$?
1682         if [ $ret -ne 0 ]; then
1683                 test_done "$testroot" "$ret"
1684                 return 1
1685         fi
1686
1687         cat > $testroot/editor.sh <<EOF
1688 #!/bin/sh
1689 SOPTS='-i ""'
1690 [ "\$OSTYPE" = "linux-gnu" ] && SOPTS="-i"
1691 sed "\$SOPTS" -e 'd' "\$1"
1692 EOF
1693         chmod +x $testroot/editor.sh
1694
1695         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1696                 VISUAL="$testroot/editor.sh" got histedit -f > $testroot/stdout)
1697
1698         local new_commit1=`git_show_head $testroot/repo`
1699
1700         local short_old_commit1=`trim_obj_id 28 $old_commit1`
1701         local very_short_old_commit1=`trim_obj_id 29 $old_commit1`
1702         local short_old_commit2=`trim_obj_id 28 $old_commit2`
1703         local short_old_commit3=`trim_obj_id 28 $old_commit3`
1704         local short_new_commit1=`trim_obj_id 28 $new_commit1`
1705         local short_new_commit2=`trim_obj_id 28 $new_commit2`
1706
1707         echo "G  alpha" > $testroot/stdout.expected
1708         echo "D  beta" >> $testroot/stdout.expected
1709         echo "A  epsilon/new" >> $testroot/stdout.expected
1710         echo "$short_old_commit1 ->  fold commit: committing changes" \
1711                 >> $testroot/stdout.expected
1712         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1713         echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
1714         echo "fold commit: committing to zeta on master" \
1715                 >> $testroot/stdout.expected
1716         echo "G  gamma/delta" >> $testroot/stdout.expected
1717         echo -n "$short_old_commit3 -> $short_new_commit1: " \
1718                 >> $testroot/stdout.expected
1719         echo "# log message of folded commit $very_short_old_commit1" \
1720                 >> $testroot/stdout.expected
1721         echo "Switching work tree to refs/heads/master" \
1722                 >> $testroot/stdout.expected
1723
1724         cmp -s $testroot/stdout.expected $testroot/stdout
1725         ret=$?
1726         if [ $ret -ne 0 ]; then
1727                 diff -u $testroot/stdout.expected $testroot/stdout
1728                 test_done "$testroot" "$ret"
1729                 return 1
1730         fi
1731
1732         echo "modified alpha on master" > $testroot/content.expected
1733         cat $testroot/wt/alpha > $testroot/content
1734         cmp -s $testroot/content.expected $testroot/content
1735         ret=$?
1736         if [ $ret -ne 0 ]; then
1737                 diff -u $testroot/content.expected $testroot/content
1738                 test_done "$testroot" "$ret"
1739                 return 1
1740         fi
1741
1742         if [ -e $testroot/wt/beta ]; then
1743                 echo "removed file beta still exists on disk" >&2
1744                 test_done "$testroot" "1"
1745                 return 1
1746         fi
1747
1748         echo "new file on master" > $testroot/content.expected
1749         cat $testroot/wt/epsilon/new > $testroot/content
1750         cmp -s $testroot/content.expected $testroot/content
1751         ret=$?
1752         if [ $ret -ne 0 ]; then
1753                 diff -u $testroot/content.expected $testroot/content
1754                 test_done "$testroot" "$ret"
1755                 return 1
1756         fi
1757
1758         (cd $testroot/wt && got status > $testroot/stdout)
1759
1760         echo -n > $testroot/stdout.expected
1761         cmp -s $testroot/stdout.expected $testroot/stdout
1762         ret=$?
1763         if [ $ret -ne 0 ]; then
1764                 diff -u $testroot/stdout.expected $testroot/stdout
1765                 test_done "$testroot" "$ret"
1766                 return 1
1767         fi
1768
1769         (cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
1770         echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1771         echo "commit $orig_commit" >> $testroot/stdout.expected
1772         cmp -s $testroot/stdout.expected $testroot/stdout
1773         ret=$?
1774         if [ $ret -ne 0 ]; then
1775                 diff -u $testroot/stdout.expected $testroot/stdout
1776         fi
1777         test_done "$testroot" "$ret"
1778 }
1779
1780 test_histedit_edit_only() {
1781         local testroot=`test_init histedit_edit_only`
1782
1783         local orig_commit=`git_show_head $testroot/repo`
1784
1785         echo "modified alpha on master" > $testroot/repo/alpha
1786         (cd $testroot/repo && git rm -q beta)
1787         echo "new file on master" > $testroot/repo/epsilon/new
1788         (cd $testroot/repo && git add epsilon/new)
1789         git_commit $testroot/repo -m "committing changes"
1790         local old_commit1=`git_show_head $testroot/repo`
1791
1792         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1793         git_commit $testroot/repo -m "committing to zeta on master"
1794         local old_commit2=`git_show_head $testroot/repo`
1795
1796         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1797         ret=$?
1798         if [ $ret -ne 0 ]; then
1799                 test_done "$testroot" "$ret"
1800                 return 1
1801         fi
1802
1803         (cd $testroot/wt && got histedit -e > $testroot/stdout)
1804
1805         local short_old_commit1=`trim_obj_id 28 $old_commit1`
1806         local short_old_commit2=`trim_obj_id 28 $old_commit2`
1807
1808         echo "G  alpha" > $testroot/stdout.expected
1809         echo "D  beta" >> $testroot/stdout.expected
1810         echo "A  epsilon/new" >> $testroot/stdout.expected
1811         echo "Stopping histedit for amending commit $old_commit1" \
1812                 >> $testroot/stdout.expected
1813         cmp -s $testroot/stdout.expected $testroot/stdout
1814         ret=$?
1815         if [ $ret -ne 0 ]; then
1816                 diff -u $testroot/stdout.expected $testroot/stdout
1817                 test_done "$testroot" "$ret"
1818                 return 1
1819         fi
1820
1821         echo "edited modified alpha on master" > $testroot/wt/alpha
1822
1823         cat > $testroot/editor.sh <<EOF
1824 #!/bin/sh
1825 sed -i 's/.*/committing edited changes 1/' "\$1"
1826 EOF
1827         chmod +x $testroot/editor.sh
1828
1829         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1830                 VISUAL="$testroot/editor.sh" got histedit -c > $testroot/stdout)
1831
1832         local new_commit1=$(cd $testroot/wt && got info | \
1833                 grep '^work tree base commit: ' | cut -d: -f2 | tr -d ' ')
1834         local short_new_commit1=`trim_obj_id 28 $new_commit1`
1835
1836         echo -n "$short_old_commit1 -> $short_new_commit1: " \
1837                 > $testroot/stdout.expected
1838         echo "committing edited changes 1" >> $testroot/stdout.expected
1839         echo "G  epsilon/zeta" >> $testroot/stdout.expected
1840         echo "Stopping histedit for amending commit $old_commit2" \
1841                 >> $testroot/stdout.expected
1842         cmp -s $testroot/stdout.expected $testroot/stdout
1843         ret=$?
1844         if [ $ret -ne 0 ]; then
1845                 diff -u $testroot/stdout.expected $testroot/stdout
1846                 test_done "$testroot" "$ret"
1847                 return 1
1848         fi
1849
1850         echo "edited zeta on master" > $testroot/wt/epsilon/zeta
1851
1852         cat > $testroot/editor.sh <<EOF
1853 #!/bin/sh
1854 sed -i 's/.*/committing edited changes 2/' "\$1"
1855 EOF
1856         chmod +x $testroot/editor.sh
1857
1858         (cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1859                 VISUAL="$testroot/editor.sh" got histedit -c > $testroot/stdout)
1860
1861         local new_commit2=`git_show_head $testroot/repo`
1862         local short_new_commit2=`trim_obj_id 28 $new_commit2`
1863
1864         echo -n "$short_old_commit2 -> $short_new_commit2: " \
1865                 > $testroot/stdout.expected
1866         echo "committing edited changes 2" >> $testroot/stdout.expected
1867         echo "Switching work tree to refs/heads/master" \
1868                 >> $testroot/stdout.expected
1869
1870         cmp -s $testroot/stdout.expected $testroot/stdout
1871         ret=$?
1872         if [ $ret -ne 0 ]; then
1873                 diff -u $testroot/stdout.expected $testroot/stdout
1874                 test_done "$testroot" "$ret"
1875                 return 1
1876         fi
1877
1878         echo "edited modified alpha on master" > $testroot/content.expected
1879         cat $testroot/wt/alpha > $testroot/content
1880         cmp -s $testroot/content.expected $testroot/content
1881         ret=$?
1882         if [ $ret -ne 0 ]; then
1883                 diff -u $testroot/content.expected $testroot/content
1884                 test_done "$testroot" "$ret"
1885                 return 1
1886         fi
1887
1888         if [ -e $testroot/wt/beta ]; then
1889                 echo "removed file beta still exists on disk" >&2
1890                 test_done "$testroot" "1"
1891                 return 1
1892         fi
1893
1894         echo "new file on master" > $testroot/content.expected
1895         cat $testroot/wt/epsilon/new > $testroot/content
1896         cmp -s $testroot/content.expected $testroot/content
1897         ret=$?
1898         if [ $ret -ne 0 ]; then
1899                 diff -u $testroot/content.expected $testroot/content
1900                 test_done "$testroot" "$ret"
1901                 return 1
1902         fi
1903
1904         (cd $testroot/wt && got status > $testroot/stdout)
1905
1906         echo -n > $testroot/stdout.expected
1907         cmp -s $testroot/stdout.expected $testroot/stdout
1908         ret=$?
1909         if [ $ret -ne 0 ]; then
1910                 diff -u $testroot/stdout.expected $testroot/stdout
1911                 test_done "$testroot" "$ret"
1912                 return 1
1913         fi
1914
1915         (cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1916         echo "commit $new_commit2 (master)" > $testroot/stdout.expected
1917         echo "commit $new_commit1" >> $testroot/stdout.expected
1918         echo "commit $orig_commit" >> $testroot/stdout.expected
1919         cmp -s $testroot/stdout.expected $testroot/stdout
1920         ret=$?
1921         if [ $ret -ne 0 ]; then
1922                 diff -u $testroot/stdout.expected $testroot/stdout
1923         fi
1924         test_done "$testroot" "$ret"
1925 }
1926
1927 test_histedit_prepend_line() {
1928         local testroot=`test_init histedit_prepend_line`
1929         local orig_commit=`git_show_head $testroot/repo`
1930
1931         got checkout $testroot/repo $testroot/wt > /dev/null
1932
1933         ed -s "$testroot/wt/alpha" <<EOF
1934 1i
1935 first line
1936 .
1937 wq
1938 EOF
1939
1940         cp $testroot/wt/alpha $testroot/content.expected
1941
1942         (cd $testroot/wt/ && got commit -m 'modified alpha on master' \
1943                 alpha > /dev/null)
1944         ret=$?
1945         if [ "$?" != 0 ]; then
1946                 echo "got commit failed unexpectedly" >&2
1947                 test_done "$testroot" "$ret"
1948                 return 1
1949         fi
1950
1951         local top_commit=`git_show_head $testroot/repo`
1952         echo "pick $top_commit" > "$testroot/histedit-script"
1953
1954         (cd $testroot/wt/ && got update -c $orig_commit > /dev/null)
1955         ret=$?
1956         if [ "$?" != 0 ]; then
1957                 echo "got update failed unexpectedly" >&2
1958                 test_done "$testroot" "$ret"
1959                 return 1
1960         fi
1961
1962         (cd $testroot/wt && got histedit -F "$testroot/histedit-script" \
1963                 > /dev/null)
1964         ret=$?
1965         if [ "$?" != 0 ]; then
1966                 echo "got histedit failed unexpectedly" >&2
1967                 test_done "$testroot" "$ret"
1968                 return 1
1969         fi
1970
1971         cp $testroot/wt/alpha $testroot/content
1972         cmp -s $testroot/content.expected $testroot/content
1973         ret=$?
1974         if [ $ret -ne 0 ]; then
1975                 diff -u $testroot/content.expected $testroot/content
1976                 test_done "$testroot" "$ret"
1977                 return 1
1978         fi
1979
1980         test_done "$testroot" $ret
1981 }
1982
1983 test_histedit_mesg_invalid() {
1984         local testroot=`test_init mesg_invalid`
1985
1986         local orig_commit=`git_show_head $testroot/repo`
1987
1988         echo "modified alpha on master" > $testroot/repo/alpha
1989         (cd $testroot/repo && git rm -q beta)
1990         echo "new file on master" > $testroot/repo/epsilon/new
1991         (cd $testroot/repo && git add epsilon/new)
1992         git_commit $testroot/repo -m 'committing changes'
1993         local old_commit1=`git_show_head $testroot/repo`
1994
1995         echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1996         git_commit $testroot/repo -m 'committing to zeto on master'
1997         local old_commit2=`git_show_head $testroot/repo`
1998
1999         got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2000         ret=$?
2001         if [ $ret -ne 0 ]; then
2002                 test_done "$testroot" $ret
2003                 return 1
2004         fi
2005
2006         # try with a leading mesg
2007
2008         echo "mesg something something" > $testroot/histedit-script
2009         echo "pick $old_commit1" >> $testroot/histedit-script
2010         echo "pick $old_commit2" >> $testroot/histedit-script
2011
2012         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
2013                 > $testroot/stdout 2> $testroot/stderr)
2014         ret=$?
2015         if [ $ret -eq 0 ]; then
2016                 echo "histedit succeeded unexpectedly" >&2
2017                 test_done "$testroot" 1
2018                 return 1
2019         fi
2020
2021         echo "got: bad histedit command" > $testroot/stderr.expected
2022         cmp -s $testroot/stderr.expected $testroot/stderr
2023         ret=$?
2024         if [ $ret -ne 0 ]; then
2025                 diff -u $testroot/stderr.expected $testroot/stderr
2026                 test_done "$testroot" $ret
2027                 return 1
2028         fi
2029
2030         # try again with mesg -> mesg
2031
2032         echo "pick $old_commit1" > $testroot/histedit-script
2033         echo "mesg something something" >> $testroot/histedit-script
2034         echo "mesg something something else" >> $testroot/histedit-script
2035         echo "pick $old_commit2" >> $testroot/histedit-script
2036
2037         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
2038                 > $testroot/stdout 2> $testroot/stderr)
2039         ret=$?
2040         if [ $ret -eq 0 ]; then
2041                 echo "histedit succeeded unexpectedly" >&2
2042                 test_done "$testroot" 1
2043                 return 1
2044         fi
2045
2046         echo "got: bad histedit command" > $testroot/stderr.expected
2047         cmp -s $testroot/stderr.expected $testroot/stderr
2048         ret=$?
2049         if [ $ret -ne 0 ]; then
2050                 diff -u $testroot/stderr.expected $testroot/stderr
2051                 test_done "$testroot" $ret
2052                 return 1
2053         fi
2054
2055         # try again with drop -> mesg
2056
2057         echo "drop $old_commit1" > $testroot/histedit-script
2058         echo "mesg something something" >> $testroot/histedit-script
2059         echo "pick $old_commit2" >> $testroot/histedit-script
2060
2061         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
2062                 > $testroot/stdout 2> $testroot/stderr)
2063         ret=$?
2064         if [ $ret -eq 0 ]; then
2065                 echo "histedit succeeded unexpectedly" >&2
2066                 test_done "$testroot" 1
2067                 return 1
2068         fi
2069
2070         echo "got: bad histedit command" > $testroot/stderr.expected
2071         cmp -s $testroot/stderr.expected $testroot/stderr
2072         ret=$?
2073         if [ $ret -ne 0 ]; then
2074                 diff -u $testroot/stderr.expected $testroot/stderr
2075                 test_done "$testroot" $ret
2076                 return 1
2077         fi
2078
2079         # try again with fold -> mesg
2080
2081         echo "fold $old_commit1" > $testroot/histedit-script
2082         echo "mesg something something" >> $testroot/histedit-script
2083         echo "pick $old_commit2" >> $testroot/histedit-script
2084
2085         (cd $testroot/wt && got histedit -F $testroot/histedit-script \
2086                 > $testroot/stdout 2> $testroot/stderr)
2087         ret=$?
2088         if [ $ret -eq 0 ]; then
2089                 echo "histedit succeeded unexpectedly" >&2
2090                 test_done "$testroot" 1
2091                 return 1
2092         fi
2093
2094         echo "got: bad histedit command" > $testroot/stderr.expected
2095         cmp -s $testroot/stderr.expected $testroot/stderr
2096         ret=$?
2097         if [ $ret -ne 0 ]; then
2098                 diff -u $testroot/stderr.expected $testroot/stderr
2099         fi
2100         test_done "$testroot" $ret
2101 }
2102
2103 test_histedit_resets_committer() {
2104         local testroot=`test_init histedit_resets_committer`
2105         local orig_commit=`git_show_head $testroot/repo`
2106         local committer="Flan Luck <flan_luck@openbsd.org>"
2107
2108         got checkout $testroot/repo $testroot/wt > /dev/null
2109
2110         echo "modified alpha" > $testroot/wt/alpha
2111
2112         (cd $testroot/wt/ && got commit -m 'modified alpha on master' \
2113                 alpha > /dev/null)
2114         ret=$?
2115         if [ "$?" != 0 ]; then
2116                 echo "got commit failed unexpectedly" >&2
2117                 test_done "$testroot" "$ret"
2118                 return 1
2119         fi
2120
2121         local top_commit=`git_show_head $testroot/repo`
2122         echo "pick $top_commit" > "$testroot/histedit-script"
2123
2124         (cd $testroot/wt/ && got update -c $orig_commit > /dev/null)
2125         ret=$?
2126         if [ "$?" != 0 ]; then
2127                 echo "got update failed unexpectedly" >&2
2128                 test_done "$testroot" "$ret"
2129                 return 1
2130         fi
2131
2132         (cd $testroot/wt && env GOT_AUTHOR="$committer" \
2133                 got histedit -F "$testroot/histedit-script" > /dev/null)
2134         ret=$?
2135         if [ "$?" != 0 ]; then
2136                 echo "got histedit failed unexpectedly" >&2
2137                 test_done "$testroot" "$ret"
2138                 return 1
2139         fi
2140         local edited_commit=`git_show_head $testroot/repo`
2141
2142         # Original commit only had one author
2143         (cd $testroot/repo && got log -l1 -c $top_commit | \
2144                 egrep '^(from|via):' > $testroot/stdout)
2145         echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
2146         cmp -s $testroot/stdout.expected $testroot/stdout
2147         ret=$?
2148         if [ $ret -ne 0 ]; then
2149                 diff -u $testroot/stdout.expected $testroot/stdout
2150                 test_done "$testroot" "$ret"
2151                 return 1
2152         fi
2153
2154         # Edited commit should have new committer name added
2155         (cd $testroot/repo && got log -l1 -c $edited_commit | \
2156                 egrep '^(from|via):' > $testroot/stdout)
2157         echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
2158         echo "via: $committer" >> $testroot/stdout.expected
2159
2160         cmp -s $testroot/stdout.expected $testroot/stdout
2161         ret=$?
2162         if [ $ret -ne 0 ]; then
2163                 diff -u $testroot/stdout.expected $testroot/stdout
2164         fi
2165         test_done "$testroot" "$ret"
2166 }
2167
2168 test_histedit_umask() {
2169         local testroot=`test_init histedit_umask`
2170         local orig_commit=`git_show_head "$testroot/repo"`
2171
2172         got checkout "$testroot/repo" "$testroot/wt" >/dev/null
2173
2174         echo "modified alpha" > $testroot/wt/alpha
2175         (cd "$testroot/wt" && got commit -m 'edit #1') >/dev/null
2176         local commit1=`git_show_head "$testroot/repo"`
2177
2178         echo "modified again" > $testroot/wt/alpha
2179         (cd "$testroot/wt" && got commit -m 'edit #2') >/dev/null
2180         local commit2=`git_show_head "$testroot/repo"`
2181
2182         echo "modified again!" > $testroot/wt/alpha
2183         echo "modify beta too!" > $testroot/wt/beta
2184         (cd "$testroot/wt" && got commit -m 'edit #3') >/dev/null
2185         local commit3=`git_show_head "$testroot/repo"`
2186
2187         (cd "$testroot/wt" && got update -c "$orig_commit") >/dev/null
2188         ret=$?
2189         if [ $ret -ne 0 ]; then
2190                 echo "update to $orig_commit failed!" >&2
2191                 test_done "$testroot" 1
2192                 return 1
2193         fi
2194
2195         echo fold $commit1 >$testroot/histedit-script
2196         echo fold $commit2 >>$testroot/histedit-script
2197         echo pick $commit3 >>$testroot/histedit-script
2198         echo mesg folding changes >>$testroot/histedit-script
2199
2200         # using a subshell to avoid clobbering global umask
2201         (umask 077 && cd "$testroot/wt" && \
2202                 got histedit -F "$testroot/histedit-script") >/dev/null
2203         ret=$?
2204
2205         if [ $ret -ne 0 ]; then
2206                 echo "histedit operation failed" >&2
2207                 test_done "$testroot" $ret
2208                 return 1
2209         fi
2210
2211         for f in alpha beta; do
2212                 ls -l "$testroot/wt/$f" | grep -q ^-rw-------
2213                 if [ $? -ne 0 ]; then
2214                         echo "$f is not 0600 after histedi" >&2
2215                         ls -l "$testroot/wt/$f" >&2
2216                         test_done "$testroot" 1
2217                         return 1
2218                 fi
2219         done
2220
2221         test_done "$testroot" 0
2222 }
2223
2224 test_parseargs "$@"
2225 run_test test_histedit_no_op
2226 run_test test_histedit_swap
2227 run_test test_histedit_drop
2228 run_test test_histedit_fold
2229 run_test test_histedit_edit
2230 run_test test_histedit_fold_last_commit
2231 run_test test_histedit_missing_commit
2232 run_test test_histedit_abort
2233 run_test test_histedit_path_prefix_drop
2234 run_test test_histedit_path_prefix_edit
2235 run_test test_histedit_outside_refs_heads
2236 run_test test_histedit_fold_last_commit_swap
2237 run_test test_histedit_split_commit
2238 run_test test_histedit_duplicate_commit_in_script
2239 run_test test_histedit_fold_add_delete
2240 run_test test_histedit_fold_only
2241 run_test test_histedit_fold_only_empty_logmsg
2242 run_test test_histedit_edit_only
2243 run_test test_histedit_prepend_line
2244 run_test test_histedit_mesg_invalid
2245 run_test test_histedit_resets_committer
2246 run_test test_histedit_umask