git.oblomov.eu Git - git/blob - t/t9300-fast-import.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2007 Shawn Pearce
   4 #
   5
   6 test_description='test git fast-import utility'
   7 . ./test-lib.sh
   8 . "$TEST_DIRECTORY"/diff-lib.sh ;# test-lib chdir's into trash
   9
  10 verify_packs () {
  11         for p in .git/objects/pack/*.pack
  12         do
  13                 git verify-pack "$@" "$p" || return
  14         done
  15 }
  16
  17 file2_data='file2
  18 second line of EOF'
  19
  20 file3_data='EOF
  21 in 3rd file
  22  END'
  23
  24 file4_data=abcd
  25 file4_len=4
  26
  27 file5_data='an inline file.
  28   we should see it later.'
  29
  30 file6_data='#!/bin/sh
  31 echo "$@"'
  32
  33 ###
  34 ### series A
  35 ###
  36
  37 test_expect_success 'empty stream succeeds' '
  38         git config fastimport.unpackLimit 0 &&
  39         git fast-import </dev/null
  40 '
  41
  42 test_expect_success 'truncated stream complains' '
  43         echo "tag foo" | test_must_fail git fast-import
  44 '
  45
  46 test_expect_success 'A: create pack from stdin' '
  47         test_tick &&
  48         cat >input <<-INPUT_END &&
  49         blob
  50         mark :2
  51         data <<EOF
  52         $file2_data
  53         EOF
  54
  55         blob
  56         mark :3
  57         data <<END
  58         $file3_data
  59         END
  60
  61         blob
  62         mark :4
  63         data $file4_len
  64         $file4_data
  65         commit refs/heads/master
  66         mark :5
  67         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
  68         data <<COMMIT
  69         initial
  70         COMMIT
  71
  72         M 644 :2 file2
  73         M 644 :3 file3
  74         M 755 :4 file4
  75
  76         tag series-A
  77         from :5
  78         data <<EOF
  79         An annotated tag without a tagger
  80         EOF
  81
  82         tag series-A-blob
  83         from :3
  84         data <<EOF
  85         An annotated tag that annotates a blob.
  86         EOF
  87
  88         tag to-be-deleted
  89         from :3
  90         data <<EOF
  91         Another annotated tag that annotates a blob.
  92         EOF
  93
  94         reset refs/tags/to-be-deleted
  95         from 0000000000000000000000000000000000000000
  96
  97         tag nested
  98         mark :6
  99         from :4
 100         data <<EOF
 101         Tag of our lovely commit
 102         EOF
 103
 104         reset refs/tags/nested
 105         from 0000000000000000000000000000000000000000
 106
 107         tag nested
 108         mark :7
 109         from :6
 110         data <<EOF
 111         Tag of tag of our lovely commit
 112         EOF
 113
 114         alias
 115         mark :8
 116         to :5
 117
 118         INPUT_END
 119         git fast-import --export-marks=marks.out <input &&
 120         git whatchanged master
 121 '
 122
 123 test_expect_success 'A: verify pack' '
 124         verify_packs
 125 '
 126
 127 test_expect_success 'A: verify commit' '
 128         cat >expect <<-EOF &&
 129         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 130         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 131
 132         initial
 133         EOF
 134         git cat-file commit master | sed 1d >actual &&
 135         test_cmp expect actual
 136 '
 137
 138 test_expect_success 'A: verify tree' '
 139         cat >expect <<-EOF &&
 140         100644 blob file2
 141         100644 blob file3
 142         100755 blob file4
 143         EOF
 144         git cat-file -p master^{tree} | sed "s/ [0-9a-f]*       / /" >actual &&
 145         test_cmp expect actual
 146 '
 147
 148 test_expect_success 'A: verify file2' '
 149         echo "$file2_data" >expect &&
 150         git cat-file blob master:file2 >actual &&
 151         test_cmp expect actual
 152 '
 153
 154 test_expect_success 'A: verify file3' '
 155         echo "$file3_data" >expect &&
 156         git cat-file blob master:file3 >actual &&
 157         test_cmp expect actual
 158 '
 159
 160 test_expect_success 'A: verify file4' '
 161         printf "$file4_data" >expect &&
 162         git cat-file blob master:file4 >actual &&
 163         test_cmp expect actual
 164 '
 165
 166 test_expect_success 'A: verify tag/series-A' '
 167         cat >expect <<-EOF &&
 168         object $(git rev-parse refs/heads/master)
 169         type commit
 170         tag series-A
 171
 172         An annotated tag without a tagger
 173         EOF
 174         git cat-file tag tags/series-A >actual &&
 175         test_cmp expect actual
 176 '
 177
 178 test_expect_success 'A: verify tag/series-A-blob' '
 179         cat >expect <<-EOF &&
 180         object $(git rev-parse refs/heads/master:file3)
 181         type blob
 182         tag series-A-blob
 183
 184         An annotated tag that annotates a blob.
 185         EOF
 186         git cat-file tag tags/series-A-blob >actual &&
 187         test_cmp expect actual
 188 '
 189
 190 test_expect_success 'A: verify tag deletion is successful' '
 191         test_must_fail git rev-parse --verify refs/tags/to-be-deleted
 192 '
 193
 194 test_expect_success 'A: verify marks output' '
 195         cat >expect <<-EOF &&
 196         :2 $(git rev-parse --verify master:file2)
 197         :3 $(git rev-parse --verify master:file3)
 198         :4 $(git rev-parse --verify master:file4)
 199         :5 $(git rev-parse --verify master^0)
 200         :6 $(git cat-file tag nested | grep object | cut -d" " -f 2)
 201         :7 $(git rev-parse --verify nested)
 202         :8 $(git rev-parse --verify master^0)
 203         EOF
 204         test_cmp expect marks.out
 205 '
 206
 207 test_expect_success 'A: verify marks import' '
 208         git fast-import \
 209                 --import-marks=marks.out \
 210                 --export-marks=marks.new \
 211                 </dev/null &&
 212         test_cmp expect marks.new
 213 '
 214
 215 test_expect_success 'A: tag blob by sha1' '
 216         test_tick &&
 217         new_blob=$(echo testing | git hash-object --stdin) &&
 218         cat >input <<-INPUT_END &&
 219         tag series-A-blob-2
 220         from $(git rev-parse refs/heads/master:file3)
 221         data <<EOF
 222         Tag blob by sha1.
 223         EOF
 224
 225         blob
 226         mark :6
 227         data <<EOF
 228         testing
 229         EOF
 230
 231         commit refs/heads/new_blob
 232         committer  <> 0 +0000
 233         data 0
 234         M 644 :6 new_blob
 235         #pretend we got sha1 from fast-import
 236         ls "new_blob"
 237
 238         tag series-A-blob-3
 239         from $new_blob
 240         data <<EOF
 241         Tag new_blob.
 242         EOF
 243         INPUT_END
 244
 245         cat >expect <<-EOF &&
 246         object $(git rev-parse refs/heads/master:file3)
 247         type blob
 248         tag series-A-blob-2
 249
 250         Tag blob by sha1.
 251         object $new_blob
 252         type blob
 253         tag series-A-blob-3
 254
 255         Tag new_blob.
 256         EOF
 257
 258         git fast-import <input &&
 259         git cat-file tag tags/series-A-blob-2 >actual &&
 260         git cat-file tag tags/series-A-blob-3 >>actual &&
 261         test_cmp expect actual
 262 '
 263
 264 test_expect_success 'A: verify marks import does not crash' '
 265         test_tick &&
 266         cat >input <<-INPUT_END &&
 267         commit refs/heads/verify--import-marks
 268         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 269         data <<COMMIT
 270         recreate from :5
 271         COMMIT
 272
 273         from :5
 274         M 755 :2 copy-of-file2
 275
 276         INPUT_END
 277
 278         git fast-import --import-marks=marks.out <input &&
 279         git whatchanged verify--import-marks
 280 '
 281
 282 test_expect_success 'A: verify pack' '
 283         verify_packs
 284 '
 285
 286 test_expect_success 'A: verify diff' '
 287         cat >expect <<-EOF &&
 288         :000000 100755 0000000000000000000000000000000000000000 7123f7f44e39be127c5eb701e5968176ee9d78b1 A      copy-of-file2
 289         EOF
 290         git diff-tree -M -r master verify--import-marks >actual &&
 291         compare_diff_raw expect actual &&
 292         test $(git rev-parse --verify master:file2) \
 293             = $(git rev-parse --verify verify--import-marks:copy-of-file2)
 294 '
 295
 296 test_expect_success 'A: export marks with large values' '
 297         test_tick &&
 298         mt=$(git hash-object --stdin < /dev/null) &&
 299         >input.blob &&
 300         >marks.exp &&
 301         >tree.exp &&
 302
 303         cat >input.commit <<-EOF &&
 304         commit refs/heads/verify--dump-marks
 305         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 306         data <<COMMIT
 307         test the sparse array dumping routines with exponentially growing marks
 308         COMMIT
 309         EOF
 310
 311         i=0 l=4 m=6 n=7 &&
 312         while test "$i" -lt 27
 313         do
 314                 cat >>input.blob <<-EOF &&
 315                 blob
 316                 mark :$l
 317                 data 0
 318                 blob
 319                 mark :$m
 320                 data 0
 321                 blob
 322                 mark :$n
 323                 data 0
 324                 EOF
 325                 echo "M 100644 :$l l$i" >>input.commit &&
 326                 echo "M 100644 :$m m$i" >>input.commit &&
 327                 echo "M 100644 :$n n$i" >>input.commit &&
 328
 329                 echo ":$l $mt" >>marks.exp &&
 330                 echo ":$m $mt" >>marks.exp &&
 331                 echo ":$n $mt" >>marks.exp &&
 332
 333                 printf "100644 blob $mt\tl$i\n" >>tree.exp &&
 334                 printf "100644 blob $mt\tm$i\n" >>tree.exp &&
 335                 printf "100644 blob $mt\tn$i\n" >>tree.exp &&
 336
 337                 l=$(($l + $l)) &&
 338                 m=$(($m + $m)) &&
 339                 n=$(($l + $n)) &&
 340
 341                 i=$((1 + $i)) || return 1
 342         done &&
 343
 344         sort tree.exp > tree.exp_s &&
 345
 346         cat input.blob input.commit | git fast-import --export-marks=marks.large &&
 347         git ls-tree refs/heads/verify--dump-marks >tree.out &&
 348         test_cmp tree.exp_s tree.out &&
 349         test_cmp marks.exp marks.large
 350 '
 351
 352 ###
 353 ### series B
 354 ###
 355
 356 test_expect_success 'B: fail on invalid blob sha1' '
 357         test_tick &&
 358         cat >input <<-INPUT_END &&
 359         commit refs/heads/branch
 360         mark :1
 361         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 362         data <<COMMIT
 363         corrupt
 364         COMMIT
 365
 366         from refs/heads/master
 367         M 755 0000000000000000000000000000000000000001 zero1
 368
 369         INPUT_END
 370
 371         test_when_finished "rm -f .git/objects/pack_* .git/objects/index_*" &&
 372         test_must_fail git fast-import <input
 373 '
 374
 375 test_expect_success 'B: accept branch name "TEMP_TAG"' '
 376         cat >input <<-INPUT_END &&
 377         commit TEMP_TAG
 378         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 379         data <<COMMIT
 380         tag base
 381         COMMIT
 382
 383         from refs/heads/master
 384
 385         INPUT_END
 386
 387         test_when_finished "rm -f .git/TEMP_TAG
 388                 git gc
 389                 git prune" &&
 390         git fast-import <input &&
 391         test -f .git/TEMP_TAG &&
 392         test $(git rev-parse master) = $(git rev-parse TEMP_TAG^)
 393 '
 394
 395 test_expect_success 'B: accept empty committer' '
 396         cat >input <<-INPUT_END &&
 397         commit refs/heads/empty-committer-1
 398         committer  <> $GIT_COMMITTER_DATE
 399         data <<COMMIT
 400         empty commit
 401         COMMIT
 402         INPUT_END
 403
 404         test_when_finished "git update-ref -d refs/heads/empty-committer-1
 405                 git gc
 406                 git prune" &&
 407         git fast-import <input &&
 408         out=$(git fsck) &&
 409         echo "$out" &&
 410         test -z "$out"
 411 '
 412
 413 test_expect_success 'B: accept and fixup committer with no name' '
 414         cat >input <<-INPUT_END &&
 415         commit refs/heads/empty-committer-2
 416         committer <a@b.com> $GIT_COMMITTER_DATE
 417         data <<COMMIT
 418         empty commit
 419         COMMIT
 420         INPUT_END
 421
 422         test_when_finished "git update-ref -d refs/heads/empty-committer-2
 423                 git gc
 424                 git prune" &&
 425         git fast-import <input &&
 426         out=$(git fsck) &&
 427         echo "$out" &&
 428         test -z "$out"
 429 '
 430
 431 test_expect_success 'B: fail on invalid committer (1)' '
 432         cat >input <<-INPUT_END &&
 433         commit refs/heads/invalid-committer
 434         committer Name email> $GIT_COMMITTER_DATE
 435         data <<COMMIT
 436         empty commit
 437         COMMIT
 438         INPUT_END
 439
 440         test_when_finished "git update-ref -d refs/heads/invalid-committer" &&
 441         test_must_fail git fast-import <input
 442 '
 443
 444 test_expect_success 'B: fail on invalid committer (2)' '
 445         cat >input <<-INPUT_END &&
 446         commit refs/heads/invalid-committer
 447         committer Name <e<mail> $GIT_COMMITTER_DATE
 448         data <<COMMIT
 449         empty commit
 450         COMMIT
 451         INPUT_END
 452
 453         test_when_finished "git update-ref -d refs/heads/invalid-committer" &&
 454         test_must_fail git fast-import <input
 455 '
 456
 457 test_expect_success 'B: fail on invalid committer (3)' '
 458         cat >input <<-INPUT_END &&
 459         commit refs/heads/invalid-committer
 460         committer Name <email>> $GIT_COMMITTER_DATE
 461         data <<COMMIT
 462         empty commit
 463         COMMIT
 464         INPUT_END
 465
 466         test_when_finished "git update-ref -d refs/heads/invalid-committer" &&
 467         test_must_fail git fast-import <input
 468 '
 469
 470 test_expect_success 'B: fail on invalid committer (4)' '
 471         cat >input <<-INPUT_END &&
 472         commit refs/heads/invalid-committer
 473         committer Name <email $GIT_COMMITTER_DATE
 474         data <<COMMIT
 475         empty commit
 476         COMMIT
 477         INPUT_END
 478
 479         test_when_finished "git update-ref -d refs/heads/invalid-committer" &&
 480         test_must_fail git fast-import <input
 481 '
 482
 483 test_expect_success 'B: fail on invalid committer (5)' '
 484         cat >input <<-INPUT_END &&
 485         commit refs/heads/invalid-committer
 486         committer Name<email> $GIT_COMMITTER_DATE
 487         data <<COMMIT
 488         empty commit
 489         COMMIT
 490         INPUT_END
 491
 492         test_when_finished "git update-ref -d refs/heads/invalid-committer" &&
 493         test_must_fail git fast-import <input
 494 '
 495
 496 ###
 497 ### series C
 498 ###
 499
 500 test_expect_success 'C: incremental import create pack from stdin' '
 501         newf=$(echo hi newf | git hash-object -w --stdin) &&
 502         oldf=$(git rev-parse --verify master:file2) &&
 503         test_tick &&
 504         cat >input <<-INPUT_END &&
 505         commit refs/heads/branch
 506         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 507         data <<COMMIT
 508         second
 509         COMMIT
 510
 511         from refs/heads/master
 512         M 644 $oldf file2/oldf
 513         M 755 $newf file2/newf
 514         D file3
 515
 516         INPUT_END
 517
 518         git fast-import <input &&
 519         git whatchanged branch
 520 '
 521
 522 test_expect_success 'C: verify pack' '
 523         verify_packs
 524 '
 525
 526 test_expect_success 'C: validate reuse existing blob' '
 527         test $newf = $(git rev-parse --verify branch:file2/newf) &&
 528         test $oldf = $(git rev-parse --verify branch:file2/oldf)
 529 '
 530
 531 test_expect_success 'C: verify commit' '
 532         cat >expect <<-EOF &&
 533         parent $(git rev-parse --verify master^0)
 534         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 535         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 536
 537         second
 538         EOF
 539
 540         git cat-file commit branch | sed 1d >actual &&
 541         test_cmp expect actual
 542 '
 543
 544 test_expect_success 'C: validate rename result' '
 545         cat >expect <<-EOF &&
 546         :000000 100755 0000000000000000000000000000000000000000 f1fb5da718392694d0076d677d6d0e364c79b0bc A      file2/newf
 547         :100644 100644 7123f7f44e39be127c5eb701e5968176ee9d78b1 7123f7f44e39be127c5eb701e5968176ee9d78b1 R100   file2   file2/oldf
 548         :100644 000000 0d92e9f3374ae2947c23aa477cbc68ce598135f1 0000000000000000000000000000000000000000 D      file3
 549         EOF
 550         git diff-tree -M -r master branch >actual &&
 551         compare_diff_raw expect actual
 552 '
 553
 554 ###
 555 ### series D
 556 ###
 557
 558 test_expect_success 'D: inline data in commit' '
 559         test_tick &&
 560         cat >input <<-INPUT_END &&
 561         commit refs/heads/branch
 562         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 563         data <<COMMIT
 564         third
 565         COMMIT
 566
 567         from refs/heads/branch^0
 568         M 644 inline newdir/interesting
 569         data <<EOF
 570         $file5_data
 571         EOF
 572
 573         M 755 inline newdir/exec.sh
 574         data <<EOF
 575         $file6_data
 576         EOF
 577
 578         INPUT_END
 579
 580         git fast-import <input &&
 581         git whatchanged branch
 582 '
 583
 584 test_expect_success 'D: verify pack' '
 585         verify_packs
 586 '
 587
 588 test_expect_success 'D: validate new files added' '
 589         cat >expect <<-EOF &&
 590         :000000 100755 0000000000000000000000000000000000000000 e74b7d465e52746be2b4bae983670711e6e66657 A      newdir/exec.sh
 591         :000000 100644 0000000000000000000000000000000000000000 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 A      newdir/interesting
 592         EOF
 593         git diff-tree -M -r branch^ branch >actual &&
 594         compare_diff_raw expect actual
 595 '
 596
 597 test_expect_success 'D: verify file5' '
 598         echo "$file5_data" >expect &&
 599         git cat-file blob branch:newdir/interesting >actual &&
 600         test_cmp expect actual
 601 '
 602
 603 test_expect_success 'D: verify file6' '
 604         echo "$file6_data" >expect &&
 605         git cat-file blob branch:newdir/exec.sh >actual &&
 606         test_cmp expect actual
 607 '
 608
 609 ###
 610 ### series E
 611 ###
 612
 613 test_expect_success 'E: rfc2822 date, --date-format=raw' '
 614         cat >input <<-INPUT_END &&
 615         commit refs/heads/branch
 616         author $GIT_AUTHOR_NAME <$GIT_AUTHOR_EMAIL> Tue Feb 6 11:22:18 2007 -0500
 617         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> Tue Feb 6 12:35:02 2007 -0500
 618         data <<COMMIT
 619         RFC 2822 type date
 620         COMMIT
 621
 622         from refs/heads/branch^0
 623
 624         INPUT_END
 625
 626         test_must_fail git fast-import --date-format=raw <input
 627 '
 628 test_expect_success 'E: rfc2822 date, --date-format=rfc2822' '
 629         git fast-import --date-format=rfc2822 <input
 630 '
 631
 632 test_expect_success 'E: verify pack' '
 633         verify_packs
 634 '
 635
 636 test_expect_success 'E: verify commit' '
 637         cat >expect <<-EOF &&
 638         author $GIT_AUTHOR_NAME <$GIT_AUTHOR_EMAIL> 1170778938 -0500
 639         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1170783302 -0500
 640
 641         RFC 2822 type date
 642         EOF
 643         git cat-file commit branch | sed 1,2d >actual &&
 644         test_cmp expect actual
 645 '
 646
 647 ###
 648 ### series F
 649 ###
 650
 651 test_expect_success 'F: non-fast-forward update skips' '
 652         old_branch=$(git rev-parse --verify branch^0) &&
 653         test_tick &&
 654         cat >input <<-INPUT_END &&
 655         commit refs/heads/branch
 656         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 657         data <<COMMIT
 658         losing things already?
 659         COMMIT
 660
 661         from refs/heads/branch~1
 662
 663         reset refs/heads/other
 664         from refs/heads/branch
 665
 666         INPUT_END
 667
 668         test_must_fail git fast-import <input &&
 669         # branch must remain unaffected
 670         test $old_branch = $(git rev-parse --verify branch^0)
 671 '
 672
 673 test_expect_success 'F: verify pack' '
 674         verify_packs
 675 '
 676
 677 test_expect_success 'F: verify other commit' '
 678         cat >expect <<-EOF &&
 679         tree $(git rev-parse branch~1^{tree})
 680         parent $(git rev-parse branch~1)
 681         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 682         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 683
 684         losing things already?
 685         EOF
 686         git cat-file commit other >actual &&
 687         test_cmp expect actual
 688 '
 689
 690 ###
 691 ### series G
 692 ###
 693
 694 test_expect_success 'G: non-fast-forward update forced' '
 695         old_branch=$(git rev-parse --verify branch^0) &&
 696         test_tick &&
 697         cat >input <<-INPUT_END &&
 698         commit refs/heads/branch
 699         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 700         data <<COMMIT
 701         losing things already?
 702         COMMIT
 703
 704         from refs/heads/branch~1
 705
 706         INPUT_END
 707         git fast-import --force <input
 708 '
 709
 710 test_expect_success 'G: verify pack' '
 711         verify_packs
 712 '
 713
 714 test_expect_success 'G: branch changed, but logged' '
 715         test $old_branch != $(git rev-parse --verify branch^0) &&
 716         test $old_branch = $(git rev-parse --verify branch@{1})
 717 '
 718
 719 ###
 720 ### series H
 721 ###
 722
 723 test_expect_success 'H: deletall, add 1' '
 724         test_tick &&
 725         cat >input <<-INPUT_END &&
 726         commit refs/heads/H
 727         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 728         data <<COMMIT
 729         third
 730         COMMIT
 731
 732         from refs/heads/branch^0
 733         M 644 inline i-will-die
 734         data <<EOF
 735         this file will never exist.
 736         EOF
 737
 738         deleteall
 739         M 644 inline h/e/l/lo
 740         data <<EOF
 741         $file5_data
 742         EOF
 743
 744         INPUT_END
 745         git fast-import <input &&
 746         git whatchanged H
 747 '
 748
 749 test_expect_success 'H: verify pack' '
 750         verify_packs
 751 '
 752
 753 test_expect_success 'H: validate old files removed, new files added' '
 754         cat >expect <<-EOF &&
 755         :100755 000000 f1fb5da718392694d0076d677d6d0e364c79b0bc 0000000000000000000000000000000000000000 D      file2/newf
 756         :100644 000000 7123f7f44e39be127c5eb701e5968176ee9d78b1 0000000000000000000000000000000000000000 D      file2/oldf
 757         :100755 000000 85df50785d62d3b05ab03d9cbf7e4a0b49449730 0000000000000000000000000000000000000000 D      file4
 758         :100644 100644 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 R100   newdir/interesting      h/e/l/lo
 759         :100755 000000 e74b7d465e52746be2b4bae983670711e6e66657 0000000000000000000000000000000000000000 D      newdir/exec.sh
 760         EOF
 761         git diff-tree -M -r H^ H >actual &&
 762         compare_diff_raw expect actual
 763 '
 764
 765 test_expect_success 'H: verify file' '
 766         echo "$file5_data" >expect &&
 767         git cat-file blob H:h/e/l/lo >actual &&
 768         test_cmp expect actual
 769 '
 770
 771 ###
 772 ### series I
 773 ###
 774
 775 test_expect_success 'I: export-pack-edges' '
 776         cat >input <<-INPUT_END &&
 777         commit refs/heads/export-boundary
 778         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 779         data <<COMMIT
 780         we have a border.  its only 40 characters wide.
 781         COMMIT
 782
 783         from refs/heads/branch
 784
 785         INPUT_END
 786         git fast-import --export-pack-edges=edges.list <input
 787 '
 788
 789 test_expect_success 'I: verify edge list' '
 790         cat >expect <<-EOF &&
 791         .git/objects/pack/pack-.pack: $(git rev-parse --verify export-boundary)
 792         EOF
 793         sed -e s/pack-.*pack/pack-.pack/ edges.list >actual &&
 794         test_cmp expect actual
 795 '
 796
 797 ###
 798 ### series J
 799 ###
 800
 801 test_expect_success 'J: reset existing branch creates empty commit' '
 802         cat >input <<-INPUT_END &&
 803         commit refs/heads/J
 804         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 805         data <<COMMIT
 806         create J
 807         COMMIT
 808
 809         from refs/heads/branch
 810
 811         reset refs/heads/J
 812
 813         commit refs/heads/J
 814         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 815         data <<COMMIT
 816         initialize J
 817         COMMIT
 818
 819         INPUT_END
 820         git fast-import <input
 821 '
 822 test_expect_success 'J: branch has 1 commit, empty tree' '
 823         test 1 = $(git rev-list J | wc -l) &&
 824         test 0 = $(git ls-tree J | wc -l)
 825 '
 826
 827 test_expect_success 'J: tag must fail on empty branch' '
 828         cat >input <<-INPUT_END &&
 829         reset refs/heads/J2
 830
 831         tag wrong_tag
 832         from refs/heads/J2
 833         data <<EOF
 834         Tag branch that was reset.
 835         EOF
 836         INPUT_END
 837         test_must_fail git fast-import <input
 838 '
 839
 840 ###
 841 ### series K
 842 ###
 843
 844 test_expect_success 'K: reinit branch with from' '
 845         cat >input <<-INPUT_END &&
 846         commit refs/heads/K
 847         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 848         data <<COMMIT
 849         create K
 850         COMMIT
 851
 852         from refs/heads/branch
 853
 854         commit refs/heads/K
 855         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 856         data <<COMMIT
 857         redo K
 858         COMMIT
 859
 860         from refs/heads/branch^1
 861
 862         INPUT_END
 863         git fast-import <input
 864 '
 865 test_expect_success 'K: verify K^1 = branch^1' '
 866         test $(git rev-parse --verify branch^1) \
 867                 = $(git rev-parse --verify K^1)
 868 '
 869
 870 ###
 871 ### series L
 872 ###
 873
 874 test_expect_success 'L: verify internal tree sorting' '
 875         cat >input <<-INPUT_END &&
 876         blob
 877         mark :1
 878         data <<EOF
 879         some data
 880         EOF
 881
 882         blob
 883         mark :2
 884         data <<EOF
 885         other data
 886         EOF
 887
 888         commit refs/heads/L
 889         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 890         data <<COMMIT
 891         create L
 892         COMMIT
 893
 894         M 644 :1 b.
 895         M 644 :1 b/other
 896         M 644 :1 ba
 897
 898         commit refs/heads/L
 899         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 900         data <<COMMIT
 901         update L
 902         COMMIT
 903
 904         M 644 :2 b.
 905         M 644 :2 b/other
 906         M 644 :2 ba
 907         INPUT_END
 908
 909         cat >expect <<-EXPECT_END &&
 910         :100644 100644 4268632... 55d3a52... M  b.
 911         :040000 040000 0ae5cac... 443c768... M  b
 912         :100644 100644 4268632... 55d3a52... M  ba
 913         EXPECT_END
 914
 915         git fast-import <input &&
 916         GIT_PRINT_SHA1_ELLIPSIS="yes" git diff-tree --abbrev --raw L^ L >output &&
 917         test_cmp expect output
 918 '
 919
 920 test_expect_success 'L: nested tree copy does not corrupt deltas' '
 921         cat >input <<-INPUT_END &&
 922         blob
 923         mark :1
 924         data <<EOF
 925         the data
 926         EOF
 927
 928         commit refs/heads/L2
 929         committer C O Mitter <committer@example.com> 1112912473 -0700
 930         data <<COMMIT
 931         init L2
 932         COMMIT
 933         M 644 :1 a/b/c
 934         M 644 :1 a/b/d
 935         M 644 :1 a/e/f
 936
 937         commit refs/heads/L2
 938         committer C O Mitter <committer@example.com> 1112912473 -0700
 939         data <<COMMIT
 940         update L2
 941         COMMIT
 942         C a g
 943         C a/e g/b
 944         M 644 :1 g/b/h
 945         INPUT_END
 946
 947         cat >expect <<-\EOF &&
 948         g/b/f
 949         g/b/h
 950         EOF
 951
 952         test_when_finished "git update-ref -d refs/heads/L2" &&
 953         git fast-import <input &&
 954         git ls-tree L2 g/b/ >tmp &&
 955         cat tmp | cut -f 2 >actual &&
 956         test_cmp expect actual &&
 957         git fsck $(git rev-parse L2)
 958 '
 959
 960 ###
 961 ### series M
 962 ###
 963
 964 test_expect_success 'M: rename file in same subdirectory' '
 965         test_tick &&
 966         cat >input <<-INPUT_END &&
 967         commit refs/heads/M1
 968         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 969         data <<COMMIT
 970         file rename
 971         COMMIT
 972
 973         from refs/heads/branch^0
 974         R file2/newf file2/n.e.w.f
 975
 976         INPUT_END
 977
 978         cat >expect <<-EOF &&
 979         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc R100   file2/newf      file2/n.e.w.f
 980         EOF
 981         git fast-import <input &&
 982         git diff-tree -M -r M1^ M1 >actual &&
 983         compare_diff_raw expect actual
 984 '
 985
 986 test_expect_success 'M: rename file to new subdirectory' '
 987         cat >input <<-INPUT_END &&
 988         commit refs/heads/M2
 989         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
 990         data <<COMMIT
 991         file rename
 992         COMMIT
 993
 994         from refs/heads/branch^0
 995         R file2/newf i/am/new/to/you
 996
 997         INPUT_END
 998
 999         cat >expect <<-EOF &&
1000         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc R100   file2/newf      i/am/new/to/you
1001         EOF
1002         git fast-import <input &&
1003         git diff-tree -M -r M2^ M2 >actual &&
1004         compare_diff_raw expect actual
1005 '
1006
1007 test_expect_success 'M: rename subdirectory to new subdirectory' '
1008         cat >input <<-INPUT_END &&
1009         commit refs/heads/M3
1010         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1011         data <<COMMIT
1012         file rename
1013         COMMIT
1014
1015         from refs/heads/M2^0
1016         R i other/sub
1017
1018         INPUT_END
1019
1020         cat >expect <<-EOF &&
1021         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc R100   i/am/new/to/you other/sub/am/new/to/you
1022         EOF
1023         git fast-import <input &&
1024         git diff-tree -M -r M3^ M3 >actual &&
1025         compare_diff_raw expect actual
1026 '
1027
1028 test_expect_success 'M: rename root to subdirectory' '
1029         cat >input <<-INPUT_END &&
1030         commit refs/heads/M4
1031         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1032         data <<COMMIT
1033         rename root
1034         COMMIT
1035
1036         from refs/heads/M2^0
1037         R "" sub
1038
1039         INPUT_END
1040
1041         cat >expect <<-EOF &&
1042         :100644 100644 7123f7f44e39be127c5eb701e5968176ee9d78b1 7123f7f44e39be127c5eb701e5968176ee9d78b1 R100   file2/oldf      sub/file2/oldf
1043         :100755 100755 85df50785d62d3b05ab03d9cbf7e4a0b49449730 85df50785d62d3b05ab03d9cbf7e4a0b49449730 R100   file4   sub/file4
1044         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc R100   i/am/new/to/you sub/i/am/new/to/you
1045         :100755 100755 e74b7d465e52746be2b4bae983670711e6e66657 e74b7d465e52746be2b4bae983670711e6e66657 R100   newdir/exec.sh  sub/newdir/exec.sh
1046         :100644 100644 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 R100   newdir/interesting      sub/newdir/interesting
1047         EOF
1048         git fast-import <input &&
1049         git diff-tree -M -r M4^ M4 >actual &&
1050         compare_diff_raw expect actual
1051 '
1052
1053 ###
1054 ### series N
1055 ###
1056
1057 test_expect_success 'N: copy file in same subdirectory' '
1058         test_tick &&
1059         cat >input <<-INPUT_END &&
1060         commit refs/heads/N1
1061         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1062         data <<COMMIT
1063         file copy
1064         COMMIT
1065
1066         from refs/heads/branch^0
1067         C file2/newf file2/n.e.w.f
1068
1069         INPUT_END
1070
1071         cat >expect <<-EOF &&
1072         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc C100   file2/newf      file2/n.e.w.f
1073         EOF
1074         git fast-import <input &&
1075         git diff-tree -C --find-copies-harder -r N1^ N1 >actual &&
1076         compare_diff_raw expect actual
1077 '
1078
1079 test_expect_success 'N: copy then modify subdirectory' '
1080         cat >input <<-INPUT_END &&
1081         commit refs/heads/N2
1082         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1083         data <<COMMIT
1084         clean directory copy
1085         COMMIT
1086
1087         from refs/heads/branch^0
1088         C file2 file3
1089
1090         commit refs/heads/N2
1091         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1092         data <<COMMIT
1093         modify directory copy
1094         COMMIT
1095
1096         M 644 inline file3/file5
1097         data <<EOF
1098         $file5_data
1099         EOF
1100
1101         INPUT_END
1102
1103         cat >expect <<-EOF &&
1104         :100644 100644 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 C100   newdir/interesting      file3/file5
1105         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc C100   file2/newf      file3/newf
1106         :100644 100644 7123f7f44e39be127c5eb701e5968176ee9d78b1 7123f7f44e39be127c5eb701e5968176ee9d78b1 C100   file2/oldf      file3/oldf
1107         EOF
1108         git fast-import <input &&
1109         git diff-tree -C --find-copies-harder -r N2^^ N2 >actual &&
1110         compare_diff_raw expect actual
1111 '
1112
1113 test_expect_success 'N: copy dirty subdirectory' '
1114         cat >input <<-INPUT_END &&
1115         commit refs/heads/N3
1116         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1117         data <<COMMIT
1118         dirty directory copy
1119         COMMIT
1120
1121         from refs/heads/branch^0
1122         M 644 inline file2/file5
1123         data <<EOF
1124         $file5_data
1125         EOF
1126
1127         C file2 file3
1128         D file2/file5
1129
1130         INPUT_END
1131
1132         git fast-import <input &&
1133         test $(git rev-parse N2^{tree}) = $(git rev-parse N3^{tree})
1134 '
1135
1136 test_expect_success 'N: copy directory by id' '
1137         cat >expect <<-\EOF &&
1138         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc C100   file2/newf      file3/newf
1139         :100644 100644 7123f7f44e39be127c5eb701e5968176ee9d78b1 7123f7f44e39be127c5eb701e5968176ee9d78b1 C100   file2/oldf      file3/oldf
1140         EOF
1141         subdir=$(git rev-parse refs/heads/branch^0:file2) &&
1142         cat >input <<-INPUT_END &&
1143         commit refs/heads/N4
1144         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1145         data <<COMMIT
1146         copy by tree hash
1147         COMMIT
1148
1149         from refs/heads/branch^0
1150         M 040000 $subdir file3
1151         INPUT_END
1152         git fast-import <input &&
1153         git diff-tree -C --find-copies-harder -r N4^ N4 >actual &&
1154         compare_diff_raw expect actual
1155 '
1156
1157 test_expect_success PIPE 'N: read and copy directory' '
1158         cat >expect <<-\EOF &&
1159         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc C100   file2/newf      file3/newf
1160         :100644 100644 7123f7f44e39be127c5eb701e5968176ee9d78b1 7123f7f44e39be127c5eb701e5968176ee9d78b1 C100   file2/oldf      file3/oldf
1161         EOF
1162         git update-ref -d refs/heads/N4 &&
1163         rm -f backflow &&
1164         mkfifo backflow &&
1165         (
1166                 exec <backflow &&
1167                 cat <<-EOF &&
1168                 commit refs/heads/N4
1169                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1170                 data <<COMMIT
1171                 copy by tree hash, part 2
1172                 COMMIT
1173
1174                 from refs/heads/branch^0
1175                 ls "file2"
1176                 EOF
1177                 read mode type tree filename &&
1178                 echo "M 040000 $tree file3"
1179         ) |
1180         git fast-import --cat-blob-fd=3 3>backflow &&
1181         git diff-tree -C --find-copies-harder -r N4^ N4 >actual &&
1182         compare_diff_raw expect actual
1183 '
1184
1185 test_expect_success PIPE 'N: empty directory reads as missing' '
1186         cat <<-\EOF >expect &&
1187         OBJNAME
1188         :000000 100644 OBJNAME OBJNAME A        unrelated
1189         EOF
1190         echo "missing src" >expect.response &&
1191         git update-ref -d refs/heads/read-empty &&
1192         rm -f backflow &&
1193         mkfifo backflow &&
1194         (
1195                 exec <backflow &&
1196                 cat <<-EOF &&
1197                 commit refs/heads/read-empty
1198                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1199                 data <<COMMIT
1200                 read "empty" (missing) directory
1201                 COMMIT
1202
1203                 M 100644 inline src/greeting
1204                 data <<BLOB
1205                 hello
1206                 BLOB
1207                 C src/greeting dst1/non-greeting
1208                 C src/greeting unrelated
1209                 # leave behind "empty" src directory
1210                 D src/greeting
1211                 ls "src"
1212                 EOF
1213                 read -r line &&
1214                 printf "%s\n" "$line" >response &&
1215                 cat <<-\EOF
1216                 D dst1
1217                 D dst2
1218                 EOF
1219         ) |
1220         git fast-import --cat-blob-fd=3 3>backflow &&
1221         test_cmp expect.response response &&
1222         git rev-list read-empty |
1223         git diff-tree -r --root --stdin |
1224         sed "s/$OID_REGEX/OBJNAME/g" >actual &&
1225         test_cmp expect actual
1226 '
1227
1228 test_expect_success 'N: copy root directory by tree hash' '
1229         cat >expect <<-\EOF &&
1230         :100755 000000 f1fb5da718392694d0076d677d6d0e364c79b0bc 0000000000000000000000000000000000000000 D      file3/newf
1231         :100644 000000 7123f7f44e39be127c5eb701e5968176ee9d78b1 0000000000000000000000000000000000000000 D      file3/oldf
1232         EOF
1233         root=$(git rev-parse refs/heads/branch^0^{tree}) &&
1234         cat >input <<-INPUT_END &&
1235         commit refs/heads/N6
1236         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1237         data <<COMMIT
1238         copy root directory by tree hash
1239         COMMIT
1240
1241         from refs/heads/branch^0
1242         M 040000 $root ""
1243         INPUT_END
1244         git fast-import <input &&
1245         git diff-tree -C --find-copies-harder -r N4 N6 >actual &&
1246         compare_diff_raw expect actual
1247 '
1248
1249 test_expect_success 'N: copy root by path' '
1250         cat >expect <<-\EOF &&
1251         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc C100   file2/newf      oldroot/file2/newf
1252         :100644 100644 7123f7f44e39be127c5eb701e5968176ee9d78b1 7123f7f44e39be127c5eb701e5968176ee9d78b1 C100   file2/oldf      oldroot/file2/oldf
1253         :100755 100755 85df50785d62d3b05ab03d9cbf7e4a0b49449730 85df50785d62d3b05ab03d9cbf7e4a0b49449730 C100   file4   oldroot/file4
1254         :100755 100755 e74b7d465e52746be2b4bae983670711e6e66657 e74b7d465e52746be2b4bae983670711e6e66657 C100   newdir/exec.sh  oldroot/newdir/exec.sh
1255         :100644 100644 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 C100   newdir/interesting      oldroot/newdir/interesting
1256         EOF
1257         cat >input <<-INPUT_END &&
1258         commit refs/heads/N-copy-root-path
1259         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1260         data <<COMMIT
1261         copy root directory by (empty) path
1262         COMMIT
1263
1264         from refs/heads/branch^0
1265         C "" oldroot
1266         INPUT_END
1267         git fast-import <input &&
1268         git diff-tree -C --find-copies-harder -r branch N-copy-root-path >actual &&
1269         compare_diff_raw expect actual
1270 '
1271
1272 test_expect_success 'N: delete directory by copying' '
1273         cat >expect <<-\EOF &&
1274         OBJID
1275         :100644 000000 OBJID OBJID D    foo/bar/qux
1276         OBJID
1277         :000000 100644 OBJID OBJID A    foo/bar/baz
1278         :000000 100644 OBJID OBJID A    foo/bar/qux
1279         EOF
1280         empty_tree=$(git mktree </dev/null) &&
1281         cat >input <<-INPUT_END &&
1282         commit refs/heads/N-delete
1283         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1284         data <<COMMIT
1285         collect data to be deleted
1286         COMMIT
1287
1288         deleteall
1289         M 100644 inline foo/bar/baz
1290         data <<DATA_END
1291         hello
1292         DATA_END
1293         C "foo/bar/baz" "foo/bar/qux"
1294         C "foo/bar/baz" "foo/bar/quux/1"
1295         C "foo/bar/baz" "foo/bar/quuux"
1296         M 040000 $empty_tree foo/bar/quux
1297         M 040000 $empty_tree foo/bar/quuux
1298
1299         commit refs/heads/N-delete
1300         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1301         data <<COMMIT
1302         delete subdirectory
1303         COMMIT
1304
1305         M 040000 $empty_tree foo/bar/qux
1306         INPUT_END
1307         git fast-import <input &&
1308         git rev-list N-delete |
1309                 git diff-tree -r --stdin --root --always |
1310                 sed -e "s/$OID_REGEX/OBJID/g" >actual &&
1311         test_cmp expect actual
1312 '
1313
1314 test_expect_success 'N: modify copied tree' '
1315         cat >expect <<-\EOF &&
1316         :100644 100644 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 fcf778cda181eaa1cbc9e9ce3a2e15ee9f9fe791 C100   newdir/interesting      file3/file5
1317         :100755 100755 f1fb5da718392694d0076d677d6d0e364c79b0bc f1fb5da718392694d0076d677d6d0e364c79b0bc C100   file2/newf      file3/newf
1318         :100644 100644 7123f7f44e39be127c5eb701e5968176ee9d78b1 7123f7f44e39be127c5eb701e5968176ee9d78b1 C100   file2/oldf      file3/oldf
1319         EOF
1320         subdir=$(git rev-parse refs/heads/branch^0:file2) &&
1321         cat >input <<-INPUT_END &&
1322         commit refs/heads/N5
1323         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1324         data <<COMMIT
1325         copy by tree hash
1326         COMMIT
1327
1328         from refs/heads/branch^0
1329         M 040000 $subdir file3
1330
1331         commit refs/heads/N5
1332         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1333         data <<COMMIT
1334         modify directory copy
1335         COMMIT
1336
1337         M 644 inline file3/file5
1338         data <<EOF
1339         $file5_data
1340         EOF
1341         INPUT_END
1342         git fast-import <input &&
1343         git diff-tree -C --find-copies-harder -r N5^^ N5 >actual &&
1344         compare_diff_raw expect actual
1345 '
1346
1347 test_expect_success 'N: reject foo/ syntax' '
1348         subdir=$(git rev-parse refs/heads/branch^0:file2) &&
1349         test_must_fail git fast-import <<-INPUT_END
1350         commit refs/heads/N5B
1351         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1352         data <<COMMIT
1353         copy with invalid syntax
1354         COMMIT
1355
1356         from refs/heads/branch^0
1357         M 040000 $subdir file3/
1358         INPUT_END
1359 '
1360
1361 test_expect_success 'N: reject foo/ syntax in copy source' '
1362         test_must_fail git fast-import <<-INPUT_END
1363         commit refs/heads/N5C
1364         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1365         data <<COMMIT
1366         copy with invalid syntax
1367         COMMIT
1368
1369         from refs/heads/branch^0
1370         C file2/ file3
1371         INPUT_END
1372 '
1373
1374 test_expect_success 'N: reject foo/ syntax in rename source' '
1375         test_must_fail git fast-import <<-INPUT_END
1376         commit refs/heads/N5D
1377         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1378         data <<COMMIT
1379         rename with invalid syntax
1380         COMMIT
1381
1382         from refs/heads/branch^0
1383         R file2/ file3
1384         INPUT_END
1385 '
1386
1387 test_expect_success 'N: reject foo/ syntax in ls argument' '
1388         test_must_fail git fast-import <<-INPUT_END
1389         commit refs/heads/N5E
1390         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1391         data <<COMMIT
1392         copy with invalid syntax
1393         COMMIT
1394
1395         from refs/heads/branch^0
1396         ls "file2/"
1397         INPUT_END
1398 '
1399
1400 test_expect_success 'N: copy to root by id and modify' '
1401         echo "hello, world" >expect.foo &&
1402         echo hello >expect.bar &&
1403         git fast-import <<-SETUP_END &&
1404         commit refs/heads/N7
1405         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1406         data <<COMMIT
1407         hello, tree
1408         COMMIT
1409
1410         deleteall
1411         M 644 inline foo/bar
1412         data <<EOF
1413         hello
1414         EOF
1415         SETUP_END
1416
1417         tree=$(git rev-parse --verify N7:) &&
1418         git fast-import <<-INPUT_END &&
1419         commit refs/heads/N8
1420         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1421         data <<COMMIT
1422         copy to root by id and modify
1423         COMMIT
1424
1425         M 040000 $tree ""
1426         M 644 inline foo/foo
1427         data <<EOF
1428         hello, world
1429         EOF
1430         INPUT_END
1431         git show N8:foo/foo >actual.foo &&
1432         git show N8:foo/bar >actual.bar &&
1433         test_cmp expect.foo actual.foo &&
1434         test_cmp expect.bar actual.bar
1435 '
1436
1437 test_expect_success 'N: extract subtree' '
1438         branch=$(git rev-parse --verify refs/heads/branch^{tree}) &&
1439         cat >input <<-INPUT_END &&
1440         commit refs/heads/N9
1441         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1442         data <<COMMIT
1443         extract subtree branch:newdir
1444         COMMIT
1445
1446         M 040000 $branch ""
1447         C "newdir" ""
1448         INPUT_END
1449         git fast-import <input &&
1450         git diff --exit-code branch:newdir N9
1451 '
1452
1453 test_expect_success 'N: modify subtree, extract it, and modify again' '
1454         echo hello >expect.baz &&
1455         echo hello, world >expect.qux &&
1456         git fast-import <<-SETUP_END &&
1457         commit refs/heads/N10
1458         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1459         data <<COMMIT
1460         hello, tree
1461         COMMIT
1462
1463         deleteall
1464         M 644 inline foo/bar/baz
1465         data <<EOF
1466         hello
1467         EOF
1468         SETUP_END
1469
1470         tree=$(git rev-parse --verify N10:) &&
1471         git fast-import <<-INPUT_END &&
1472         commit refs/heads/N11
1473         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1474         data <<COMMIT
1475         copy to root by id and modify
1476         COMMIT
1477
1478         M 040000 $tree ""
1479         M 100644 inline foo/bar/qux
1480         data <<EOF
1481         hello, world
1482         EOF
1483         R "foo" ""
1484         C "bar/qux" "bar/quux"
1485         INPUT_END
1486         git show N11:bar/baz >actual.baz &&
1487         git show N11:bar/qux >actual.qux &&
1488         git show N11:bar/quux >actual.quux &&
1489         test_cmp expect.baz actual.baz &&
1490         test_cmp expect.qux actual.qux &&
1491         test_cmp expect.qux actual.quux'
1492
1493 ###
1494 ### series O
1495 ###
1496
1497 test_expect_success 'O: comments are all skipped' '
1498         cat >input <<-INPUT_END &&
1499         #we will
1500         commit refs/heads/O1
1501         # -- ignore all of this text
1502         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1503         # $GIT_COMMITTER_NAME has inserted here for his benefit.
1504         data <<COMMIT
1505         dirty directory copy
1506         COMMIT
1507
1508         # do not forget the import blank line!
1509         #
1510         # yes, we started from our usual base of branch^0.
1511         # i like branch^0.
1512         from refs/heads/branch^0
1513         # and we need to reuse file2/file5 from N3 above.
1514         M 644 inline file2/file5
1515         # otherwise the tree will be different
1516         data <<EOF
1517         $file5_data
1518         EOF
1519
1520         # do not forget to copy file2 to file3
1521         C file2 file3
1522         #
1523         # or to delete file5 from file2.
1524         D file2/file5
1525         # are we done yet?
1526
1527         INPUT_END
1528
1529         git fast-import <input &&
1530         test $(git rev-parse N3) = $(git rev-parse O1)
1531 '
1532
1533 test_expect_success 'O: blank lines not necessary after data commands' '
1534         cat >input <<-INPUT_END &&
1535         commit refs/heads/O2
1536         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1537         data <<COMMIT
1538         dirty directory copy
1539         COMMIT
1540         from refs/heads/branch^0
1541         M 644 inline file2/file5
1542         data <<EOF
1543         $file5_data
1544         EOF
1545         C file2 file3
1546         D file2/file5
1547
1548         INPUT_END
1549
1550         git fast-import <input &&
1551         test $(git rev-parse N3) = $(git rev-parse O2)
1552 '
1553
1554 test_expect_success 'O: repack before next test' '
1555         git repack -a -d
1556 '
1557
1558 test_expect_success 'O: blank lines not necessary after other commands' '
1559         cat >input <<-INPUT_END &&
1560         commit refs/heads/O3
1561         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1562         data <<COMMIT
1563         zstring
1564         COMMIT
1565         commit refs/heads/O3
1566         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1567         data <<COMMIT
1568         zof
1569         COMMIT
1570         checkpoint
1571         commit refs/heads/O3
1572         mark :5
1573         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1574         data <<COMMIT
1575         zempty
1576         COMMIT
1577         checkpoint
1578         commit refs/heads/O3
1579         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1580         data <<COMMIT
1581         zcommits
1582         COMMIT
1583         reset refs/tags/O3-2nd
1584         from :5
1585         reset refs/tags/O3-3rd
1586         from :5
1587         INPUT_END
1588
1589         cat >expect <<-INPUT_END &&
1590         string
1591         of
1592         empty
1593         commits
1594         INPUT_END
1595
1596         git fast-import <input &&
1597         test 8 = $(find .git/objects/pack -type f | grep -v multi-pack-index | wc -l) &&
1598         test $(git rev-parse refs/tags/O3-2nd) = $(git rev-parse O3^) &&
1599         git log --reverse --pretty=oneline O3 | sed s/^.*z// >actual &&
1600         test_cmp expect actual
1601 '
1602
1603 test_expect_success 'O: progress outputs as requested by input' '
1604         cat >input <<-INPUT_END &&
1605         commit refs/heads/O4
1606         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1607         data <<COMMIT
1608         zstring
1609         COMMIT
1610         commit refs/heads/O4
1611         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1612         data <<COMMIT
1613         zof
1614         COMMIT
1615         progress Two commits down, 2 to go!
1616         commit refs/heads/O4
1617         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1618         data <<COMMIT
1619         zempty
1620         COMMIT
1621         progress Three commits down, 1 to go!
1622         commit refs/heads/O4
1623         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1624         data <<COMMIT
1625         zcommits
1626         COMMIT
1627         progress done!
1628         INPUT_END
1629         git fast-import <input >actual &&
1630         grep "progress " <input >expect &&
1631         test_cmp expect actual
1632 '
1633
1634 ###
1635 ### series P (gitlinks)
1636 ###
1637
1638 test_expect_success 'P: superproject & submodule mix' '
1639         cat >input <<-INPUT_END &&
1640         blob
1641         mark :1
1642         data 10
1643         test file
1644
1645         reset refs/heads/sub
1646         commit refs/heads/sub
1647         mark :2
1648         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1649         data 12
1650         sub_initial
1651         M 100644 :1 file
1652
1653         blob
1654         mark :3
1655         data <<DATAEND
1656         [submodule "sub"]
1657                 path = sub
1658                 url = "$(pwd)/sub"
1659         DATAEND
1660
1661         commit refs/heads/subuse1
1662         mark :4
1663         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1664         data 8
1665         initial
1666         from refs/heads/master
1667         M 100644 :3 .gitmodules
1668         M 160000 :2 sub
1669
1670         blob
1671         mark :5
1672         data 20
1673         test file
1674         more data
1675
1676         commit refs/heads/sub
1677         mark :6
1678         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1679         data 11
1680         sub_second
1681         from :2
1682         M 100644 :5 file
1683
1684         commit refs/heads/subuse1
1685         mark :7
1686         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1687         data 7
1688         second
1689         from :4
1690         M 160000 :6 sub
1691
1692         INPUT_END
1693
1694         git fast-import <input &&
1695         git checkout subuse1 &&
1696         rm -rf sub &&
1697         mkdir sub &&
1698         (
1699                 cd sub &&
1700                 git init &&
1701                 git fetch --update-head-ok .. refs/heads/sub:refs/heads/master &&
1702                 git checkout master
1703         ) &&
1704         git submodule init &&
1705         git submodule update
1706 '
1707
1708 test_expect_success 'P: verbatim SHA gitlinks' '
1709         SUBLAST=$(git rev-parse --verify sub) &&
1710         SUBPREV=$(git rev-parse --verify sub^) &&
1711
1712         cat >input <<-INPUT_END &&
1713         blob
1714         mark :1
1715         data <<DATAEND
1716         [submodule "sub"]
1717                 path = sub
1718                 url = "$(pwd)/sub"
1719         DATAEND
1720
1721         commit refs/heads/subuse2
1722         mark :2
1723         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1724         data 8
1725         initial
1726         from refs/heads/master
1727         M 100644 :1 .gitmodules
1728         M 160000 $SUBPREV sub
1729
1730         commit refs/heads/subuse2
1731         mark :3
1732         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1733         data 7
1734         second
1735         from :2
1736         M 160000 $SUBLAST sub
1737
1738         INPUT_END
1739
1740         git branch -D sub &&
1741         git gc &&
1742         git prune &&
1743         git fast-import <input &&
1744         test $(git rev-parse --verify subuse2) = $(git rev-parse --verify subuse1)
1745 '
1746
1747 test_expect_success 'P: fail on inline gitlink' '
1748         test_tick &&
1749         cat >input <<-INPUT_END &&
1750         commit refs/heads/subuse3
1751         mark :1
1752         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1753         data <<COMMIT
1754         corrupt
1755         COMMIT
1756
1757         from refs/heads/subuse2
1758         M 160000 inline sub
1759         data <<DATA
1760         $SUBPREV
1761         DATA
1762
1763         INPUT_END
1764
1765         test_must_fail git fast-import <input
1766 '
1767
1768 test_expect_success 'P: fail on blob mark in gitlink' '
1769         test_tick &&
1770         cat >input <<-INPUT_END &&
1771         blob
1772         mark :1
1773         data <<DATA
1774         $SUBPREV
1775         DATA
1776
1777         commit refs/heads/subuse3
1778         mark :2
1779         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1780         data <<COMMIT
1781         corrupt
1782         COMMIT
1783
1784         from refs/heads/subuse2
1785         M 160000 :1 sub
1786
1787         INPUT_END
1788
1789         test_must_fail git fast-import <input
1790 '
1791
1792 ###
1793 ### series Q (notes)
1794 ###
1795
1796 test_expect_success 'Q: commit notes' '
1797         note1_data="The first note for the first commit" &&
1798         note2_data="The first note for the second commit" &&
1799         note3_data="The first note for the third commit" &&
1800         note1b_data="The second note for the first commit" &&
1801         note1c_data="The third note for the first commit" &&
1802         note2b_data="The second note for the second commit" &&
1803
1804         test_tick &&
1805         cat >input <<-INPUT_END &&
1806         blob
1807         mark :2
1808         data <<EOF
1809         $file2_data
1810         EOF
1811
1812         commit refs/heads/notes-test
1813         mark :3
1814         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1815         data <<COMMIT
1816         first (:3)
1817         COMMIT
1818
1819         M 644 :2 file2
1820
1821         blob
1822         mark :4
1823         data $file4_len
1824         $file4_data
1825         commit refs/heads/notes-test
1826         mark :5
1827         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1828         data <<COMMIT
1829         second (:5)
1830         COMMIT
1831
1832         M 644 :4 file4
1833
1834         commit refs/heads/notes-test
1835         mark :6
1836         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1837         data <<COMMIT
1838         third (:6)
1839         COMMIT
1840
1841         M 644 inline file5
1842         data <<EOF
1843         $file5_data
1844         EOF
1845
1846         M 755 inline file6
1847         data <<EOF
1848         $file6_data
1849         EOF
1850
1851         blob
1852         mark :7
1853         data <<EOF
1854         $note1_data
1855         EOF
1856
1857         blob
1858         mark :8
1859         data <<EOF
1860         $note2_data
1861         EOF
1862
1863         commit refs/notes/foobar
1864         mark :9
1865         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1866         data <<COMMIT
1867         notes (:9)
1868         COMMIT
1869
1870         N :7 :3
1871         N :8 :5
1872         N inline :6
1873         data <<EOF
1874         $note3_data
1875         EOF
1876
1877         commit refs/notes/foobar
1878         mark :10
1879         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1880         data <<COMMIT
1881         notes (:10)
1882         COMMIT
1883
1884         N inline :3
1885         data <<EOF
1886         $note1b_data
1887         EOF
1888
1889         commit refs/notes/foobar2
1890         mark :11
1891         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1892         data <<COMMIT
1893         notes (:11)
1894         COMMIT
1895
1896         N inline :3
1897         data <<EOF
1898         $note1c_data
1899         EOF
1900
1901         commit refs/notes/foobar
1902         mark :12
1903         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1904         data <<COMMIT
1905         notes (:12)
1906         COMMIT
1907
1908         deleteall
1909         N inline :5
1910         data <<EOF
1911         $note2b_data
1912         EOF
1913
1914         INPUT_END
1915
1916         git fast-import <input &&
1917         git whatchanged notes-test
1918 '
1919
1920 test_expect_success 'Q: verify pack' '
1921         verify_packs
1922 '
1923
1924 test_expect_success 'Q: verify first commit' '
1925         commit1=$(git rev-parse notes-test~2) &&
1926         commit2=$(git rev-parse notes-test^) &&
1927         commit3=$(git rev-parse notes-test) &&
1928
1929         cat >expect <<-EOF &&
1930         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1931         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1932
1933         first (:3)
1934         EOF
1935         git cat-file commit notes-test~2 | sed 1d >actual &&
1936         test_cmp expect actual
1937 '
1938
1939 test_expect_success 'Q: verify second commit' '
1940         cat >expect <<-EOF &&
1941         parent $commit1
1942         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1943         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1944
1945         second (:5)
1946         EOF
1947         git cat-file commit notes-test^ | sed 1d >actual &&
1948         test_cmp expect actual
1949 '
1950
1951 test_expect_success 'Q: verify third commit' '
1952         cat >expect <<-EOF &&
1953         parent $commit2
1954         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1955         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1956
1957         third (:6)
1958         EOF
1959         git cat-file commit notes-test | sed 1d >actual &&
1960         test_cmp expect actual
1961 '
1962
1963 test_expect_success 'Q: verify first notes commit' '
1964         cat >expect <<-EOF &&
1965         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1966         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
1967
1968         notes (:9)
1969         EOF
1970         git cat-file commit refs/notes/foobar~2 | sed 1d >actual &&
1971         test_cmp expect actual
1972 '
1973
1974 test_expect_success 'Q: verify first notes tree' '
1975         cat >expect.unsorted <<-EOF &&
1976         100644 blob $commit1
1977         100644 blob $commit2
1978         100644 blob $commit3
1979         EOF
1980         cat expect.unsorted | sort >expect &&
1981         git cat-file -p refs/notes/foobar~2^{tree} | sed "s/ [0-9a-f]*  / /" >actual &&
1982         test_cmp expect actual
1983 '
1984
1985 test_expect_success 'Q: verify first note for first commit' '
1986         echo "$note1_data" >expect &&
1987         git cat-file blob refs/notes/foobar~2:$commit1 >actual &&
1988         test_cmp expect actual
1989 '
1990
1991 test_expect_success 'Q: verify first note for second commit' '
1992         echo "$note2_data" >expect &&
1993         git cat-file blob refs/notes/foobar~2:$commit2 >actual &&
1994         test_cmp expect actual
1995 '
1996
1997 test_expect_success 'Q: verify first note for third commit' '
1998         echo "$note3_data" >expect &&
1999         git cat-file blob refs/notes/foobar~2:$commit3 >actual &&
2000         test_cmp expect actual
2001 '
2002
2003 test_expect_success 'Q: verify second notes commit' '
2004         cat >expect <<-EOF &&
2005         parent $(git rev-parse --verify refs/notes/foobar~2)
2006         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2007         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2008
2009         notes (:10)
2010         EOF
2011         git cat-file commit refs/notes/foobar^ | sed 1d >actual &&
2012         test_cmp expect actual
2013 '
2014
2015 test_expect_success 'Q: verify second notes tree' '
2016         cat >expect.unsorted <<-EOF &&
2017         100644 blob $commit1
2018         100644 blob $commit2
2019         100644 blob $commit3
2020         EOF
2021         cat expect.unsorted | sort >expect &&
2022         git cat-file -p refs/notes/foobar^^{tree} | sed "s/ [0-9a-f]*   / /" >actual &&
2023         test_cmp expect actual
2024 '
2025
2026 test_expect_success 'Q: verify second note for first commit' '
2027         echo "$note1b_data" >expect &&
2028         git cat-file blob refs/notes/foobar^:$commit1 >actual &&
2029         test_cmp expect actual
2030 '
2031
2032 test_expect_success 'Q: verify first note for second commit' '
2033         echo "$note2_data" >expect &&
2034         git cat-file blob refs/notes/foobar^:$commit2 >actual &&
2035         test_cmp expect actual
2036 '
2037
2038 test_expect_success 'Q: verify first note for third commit' '
2039         echo "$note3_data" >expect &&
2040         git cat-file blob refs/notes/foobar^:$commit3 >actual &&
2041         test_cmp expect actual
2042 '
2043
2044 test_expect_success 'Q: verify third notes commit' '
2045         cat >expect <<-EOF &&
2046         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2047         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2048
2049         notes (:11)
2050         EOF
2051         git cat-file commit refs/notes/foobar2 | sed 1d >actual &&
2052         test_cmp expect actual
2053 '
2054
2055 test_expect_success 'Q: verify third notes tree' '
2056         cat >expect.unsorted <<-EOF &&
2057         100644 blob $commit1
2058         EOF
2059         cat expect.unsorted | sort >expect &&
2060         git cat-file -p refs/notes/foobar2^{tree} | sed "s/ [0-9a-f]*   / /" >actual &&
2061         test_cmp expect actual
2062 '
2063
2064 test_expect_success 'Q: verify third note for first commit' '
2065         echo "$note1c_data" >expect &&
2066         git cat-file blob refs/notes/foobar2:$commit1 >actual &&
2067         test_cmp expect actual
2068 '
2069
2070 test_expect_success 'Q: verify fourth notes commit' '
2071         cat >expect <<-EOF &&
2072         parent $(git rev-parse --verify refs/notes/foobar^)
2073         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2074         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2075
2076         notes (:12)
2077         EOF
2078         git cat-file commit refs/notes/foobar | sed 1d >actual &&
2079         test_cmp expect actual
2080 '
2081
2082 test_expect_success 'Q: verify fourth notes tree' '
2083         cat >expect.unsorted <<-EOF &&
2084         100644 blob $commit2
2085         EOF
2086         cat expect.unsorted | sort >expect &&
2087         git cat-file -p refs/notes/foobar^{tree} | sed "s/ [0-9a-f]*    / /" >actual &&
2088         test_cmp expect actual
2089 '
2090
2091 test_expect_success 'Q: verify second note for second commit' '
2092         echo "$note2b_data" >expect &&
2093         git cat-file blob refs/notes/foobar:$commit2 >actual &&
2094         test_cmp expect actual
2095 '
2096
2097 test_expect_success 'Q: deny note on empty branch' '
2098         cat >input <<-EOF &&
2099         reset refs/heads/Q0
2100
2101         commit refs/heads/note-Q0
2102         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2103         data <<COMMIT
2104         Note for an empty branch.
2105         COMMIT
2106
2107         N inline refs/heads/Q0
2108         data <<NOTE
2109         some note
2110         NOTE
2111         EOF
2112         test_must_fail git fast-import <input
2113 '
2114 ###
2115 ### series R (feature and option)
2116 ###
2117
2118 test_expect_success 'R: abort on unsupported feature' '
2119         cat >input <<-EOF &&
2120         feature no-such-feature-exists
2121         EOF
2122
2123         test_must_fail git fast-import <input
2124 '
2125
2126 test_expect_success 'R: supported feature is accepted' '
2127         cat >input <<-EOF &&
2128         feature date-format=now
2129         EOF
2130
2131         git fast-import <input
2132 '
2133
2134 test_expect_success 'R: abort on receiving feature after data command' '
2135         cat >input <<-EOF &&
2136         blob
2137         data 3
2138         hi
2139         feature date-format=now
2140         EOF
2141
2142         test_must_fail git fast-import <input
2143 '
2144
2145 test_expect_success 'R: import-marks features forbidden by default' '
2146         >git.marks &&
2147         echo "feature import-marks=git.marks" >input &&
2148         test_must_fail git fast-import <input &&
2149         echo "feature import-marks-if-exists=git.marks" >input &&
2150         test_must_fail git fast-import <input
2151 '
2152
2153 test_expect_success 'R: only one import-marks feature allowed per stream' '
2154         >git.marks &&
2155         >git2.marks &&
2156         cat >input <<-EOF &&
2157         feature import-marks=git.marks
2158         feature import-marks=git2.marks
2159         EOF
2160
2161         test_must_fail git fast-import --allow-unsafe-features <input
2162 '
2163
2164 test_expect_success 'R: export-marks feature forbidden by default' '
2165         echo "feature export-marks=git.marks" >input &&
2166         test_must_fail git fast-import <input
2167 '
2168
2169 test_expect_success 'R: export-marks feature results in a marks file being created' '
2170         cat >input <<-EOF &&
2171         feature export-marks=git.marks
2172         blob
2173         mark :1
2174         data 3
2175         hi
2176
2177         EOF
2178
2179         git fast-import --allow-unsafe-features <input &&
2180         grep :1 git.marks
2181 '
2182
2183 test_expect_success 'R: export-marks options can be overridden by commandline options' '
2184         cat >input <<-\EOF &&
2185         feature export-marks=feature-sub/git.marks
2186         blob
2187         mark :1
2188         data 3
2189         hi
2190
2191         EOF
2192         git fast-import --allow-unsafe-features \
2193                         --export-marks=cmdline-sub/other.marks <input &&
2194         grep :1 cmdline-sub/other.marks &&
2195         test_path_is_missing feature-sub
2196 '
2197
2198 test_expect_success 'R: catch typo in marks file name' '
2199         test_must_fail git fast-import --import-marks=nonexistent.marks </dev/null &&
2200         echo "feature import-marks=nonexistent.marks" |
2201         test_must_fail git fast-import --allow-unsafe-features
2202 '
2203
2204 test_expect_success 'R: import and output marks can be the same file' '
2205         rm -f io.marks &&
2206         blob=$(echo hi | git hash-object --stdin) &&
2207         cat >expect <<-EOF &&
2208         :1 $blob
2209         :2 $blob
2210         EOF
2211         git fast-import --export-marks=io.marks <<-\EOF &&
2212         blob
2213         mark :1
2214         data 3
2215         hi
2216
2217         EOF
2218         git fast-import --import-marks=io.marks --export-marks=io.marks <<-\EOF &&
2219         blob
2220         mark :2
2221         data 3
2222         hi
2223
2224         EOF
2225         test_cmp expect io.marks
2226 '
2227
2228 test_expect_success 'R: --import-marks=foo --output-marks=foo to create foo fails' '
2229         rm -f io.marks &&
2230         test_must_fail git fast-import --import-marks=io.marks --export-marks=io.marks <<-\EOF
2231         blob
2232         mark :1
2233         data 3
2234         hi
2235
2236         EOF
2237 '
2238
2239 test_expect_success 'R: --import-marks-if-exists' '
2240         rm -f io.marks &&
2241         blob=$(echo hi | git hash-object --stdin) &&
2242         echo ":1 $blob" >expect &&
2243         git fast-import --import-marks-if-exists=io.marks --export-marks=io.marks <<-\EOF &&
2244         blob
2245         mark :1
2246         data 3
2247         hi
2248
2249         EOF
2250         test_cmp expect io.marks
2251 '
2252
2253 test_expect_success 'R: feature import-marks-if-exists' '
2254         rm -f io.marks &&
2255
2256         git fast-import --export-marks=io.marks \
2257                         --allow-unsafe-features <<-\EOF &&
2258         feature import-marks-if-exists=not_io.marks
2259         EOF
2260         test_must_be_empty io.marks &&
2261
2262         blob=$(echo hi | git hash-object --stdin) &&
2263
2264         echo ":1 $blob" >io.marks &&
2265         echo ":1 $blob" >expect &&
2266         echo ":2 $blob" >>expect &&
2267
2268         git fast-import --export-marks=io.marks \
2269                         --allow-unsafe-features <<-\EOF &&
2270         feature import-marks-if-exists=io.marks
2271         blob
2272         mark :2
2273         data 3
2274         hi
2275
2276         EOF
2277         test_cmp expect io.marks &&
2278
2279         echo ":3 $blob" >>expect &&
2280
2281         git fast-import --import-marks=io.marks \
2282                         --export-marks=io.marks \
2283                         --allow-unsafe-features <<-\EOF &&
2284         feature import-marks-if-exists=not_io.marks
2285         blob
2286         mark :3
2287         data 3
2288         hi
2289
2290         EOF
2291         test_cmp expect io.marks &&
2292
2293         git fast-import --import-marks-if-exists=not_io.marks \
2294                         --export-marks=io.marks \
2295                         --allow-unsafe-features <<-\EOF &&
2296         feature import-marks-if-exists=io.marks
2297         EOF
2298         test_must_be_empty io.marks
2299 '
2300
2301 test_expect_success 'R: import to output marks works without any content' '
2302         cat >input <<-EOF &&
2303         feature import-marks=marks.out
2304         feature export-marks=marks.new
2305         EOF
2306
2307         git fast-import --allow-unsafe-features <input &&
2308         test_cmp marks.out marks.new
2309 '
2310
2311 test_expect_success 'R: import marks prefers commandline marks file over the stream' '
2312         cat >input <<-EOF &&
2313         feature import-marks=nonexistent.marks
2314         feature export-marks=marks.new
2315         EOF
2316
2317         git fast-import --import-marks=marks.out --allow-unsafe-features <input &&
2318         test_cmp marks.out marks.new
2319 '
2320
2321
2322 test_expect_success 'R: multiple --import-marks= should be honoured' '
2323         cat >input <<-EOF &&
2324         feature import-marks=nonexistent.marks
2325         feature export-marks=combined.marks
2326         EOF
2327
2328         head -n2 marks.out > one.marks &&
2329         tail -n +3 marks.out > two.marks &&
2330         git fast-import --import-marks=one.marks --import-marks=two.marks \
2331                 --allow-unsafe-features <input &&
2332         test_cmp marks.out combined.marks
2333 '
2334
2335 test_expect_success 'R: feature relative-marks should be honoured' '
2336         cat >input <<-EOF &&
2337         feature relative-marks
2338         feature import-marks=relative.in
2339         feature export-marks=relative.out
2340         EOF
2341
2342         mkdir -p .git/info/fast-import/ &&
2343         cp marks.new .git/info/fast-import/relative.in &&
2344         git fast-import --allow-unsafe-features <input &&
2345         test_cmp marks.new .git/info/fast-import/relative.out
2346 '
2347
2348 test_expect_success 'R: feature no-relative-marks should be honoured' '
2349         cat >input <<-EOF &&
2350         feature relative-marks
2351         feature import-marks=relative.in
2352         feature no-relative-marks
2353         feature export-marks=non-relative.out
2354         EOF
2355
2356         git fast-import --allow-unsafe-features <input &&
2357         test_cmp marks.new non-relative.out
2358 '
2359
2360 test_expect_success 'R: feature ls supported' '
2361         echo "feature ls" |
2362         git fast-import
2363 '
2364
2365 test_expect_success 'R: feature cat-blob supported' '
2366         echo "feature cat-blob" |
2367         git fast-import
2368 '
2369
2370 test_expect_success 'R: cat-blob-fd must be a nonnegative integer' '
2371         test_must_fail git fast-import --cat-blob-fd=-1 </dev/null
2372 '
2373
2374 test_expect_success !MINGW 'R: print old blob' '
2375         blob=$(echo "yes it can" | git hash-object -w --stdin) &&
2376         cat >expect <<-EOF &&
2377         ${blob} blob 11
2378         yes it can
2379
2380         EOF
2381         echo "cat-blob $blob" |
2382         git fast-import --cat-blob-fd=6 6>actual &&
2383         test_cmp expect actual
2384 '
2385
2386 test_expect_success !MINGW 'R: in-stream cat-blob-fd not respected' '
2387         echo hello >greeting &&
2388         blob=$(git hash-object -w greeting) &&
2389         cat >expect <<-EOF &&
2390         ${blob} blob 6
2391         hello
2392
2393         EOF
2394         git fast-import --cat-blob-fd=3 3>actual.3 >actual.1 <<-EOF &&
2395         cat-blob $blob
2396         EOF
2397         test_cmp expect actual.3 &&
2398         test_must_be_empty actual.1 &&
2399         git fast-import 3>actual.3 >actual.1 <<-EOF &&
2400         option cat-blob-fd=3
2401         cat-blob $blob
2402         EOF
2403         test_must_be_empty actual.3 &&
2404         test_cmp expect actual.1
2405 '
2406
2407 test_expect_success !MINGW 'R: print mark for new blob' '
2408         echo "effluentish" | git hash-object --stdin >expect &&
2409         git fast-import --cat-blob-fd=6 6>actual <<-\EOF &&
2410         blob
2411         mark :1
2412         data <<BLOB_END
2413         effluentish
2414         BLOB_END
2415         get-mark :1
2416         EOF
2417         test_cmp expect actual
2418 '
2419
2420 test_expect_success !MINGW 'R: print new blob' '
2421         blob=$(echo "yep yep yep" | git hash-object --stdin) &&
2422         cat >expect <<-EOF &&
2423         ${blob} blob 12
2424         yep yep yep
2425
2426         EOF
2427         git fast-import --cat-blob-fd=6 6>actual <<-\EOF &&
2428         blob
2429         mark :1
2430         data <<BLOB_END
2431         yep yep yep
2432         BLOB_END
2433         cat-blob :1
2434         EOF
2435         test_cmp expect actual
2436 '
2437
2438 test_expect_success !MINGW 'R: print new blob by sha1' '
2439         blob=$(echo "a new blob named by sha1" | git hash-object --stdin) &&
2440         cat >expect <<-EOF &&
2441         ${blob} blob 25
2442         a new blob named by sha1
2443
2444         EOF
2445         git fast-import --cat-blob-fd=6 6>actual <<-EOF &&
2446         blob
2447         data <<BLOB_END
2448         a new blob named by sha1
2449         BLOB_END
2450         cat-blob $blob
2451         EOF
2452         test_cmp expect actual
2453 '
2454
2455 test_expect_success 'setup: big file' '
2456         (
2457                 echo "the quick brown fox jumps over the lazy dog" >big &&
2458                 for i in 1 2 3
2459                 do
2460                         cat big big big big >bigger &&
2461                         cat bigger bigger bigger bigger >big ||
2462                         exit
2463                 done
2464         )
2465 '
2466
2467 test_expect_success 'R: print two blobs to stdout' '
2468         blob1=$(git hash-object big) &&
2469         blob1_len=$(wc -c <big) &&
2470         blob2=$(echo hello | git hash-object --stdin) &&
2471         {
2472                 echo ${blob1} blob $blob1_len &&
2473                 cat big &&
2474                 cat <<-EOF
2475
2476                 ${blob2} blob 6
2477                 hello
2478
2479                 EOF
2480         } >expect &&
2481         {
2482                 cat <<-\END_PART1 &&
2483                         blob
2484                         mark :1
2485                         data <<data_end
2486                 END_PART1
2487                 cat big &&
2488                 cat <<-\EOF
2489                         data_end
2490                         blob
2491                         mark :2
2492                         data <<data_end
2493                         hello
2494                         data_end
2495                         cat-blob :1
2496                         cat-blob :2
2497                 EOF
2498         } |
2499         git fast-import >actual &&
2500         test_cmp expect actual
2501 '
2502
2503 test_expect_success PIPE 'R: copy using cat-file' '
2504         expect_id=$(git hash-object big) &&
2505         expect_len=$(wc -c <big) &&
2506         echo $expect_id blob $expect_len >expect.response &&
2507
2508         rm -f blobs &&
2509
2510         mkfifo blobs &&
2511         (
2512                 export GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL GIT_COMMITTER_DATE &&
2513                 cat <<-\EOF &&
2514                 feature cat-blob
2515                 blob
2516                 mark :1
2517                 data <<BLOB
2518                 EOF
2519                 cat big &&
2520                 cat <<-\EOF &&
2521                 BLOB
2522                 cat-blob :1
2523                 EOF
2524
2525                 read blob_id type size <&3 &&
2526                 echo "$blob_id $type $size" >response &&
2527                 test_copy_bytes $size >blob <&3 &&
2528                 read newline <&3 &&
2529
2530                 cat <<-EOF &&
2531                 commit refs/heads/copied
2532                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2533                 data <<COMMIT
2534                 copy big file as file3
2535                 COMMIT
2536                 M 644 inline file3
2537                 data <<BLOB
2538                 EOF
2539                 cat blob &&
2540                 echo BLOB
2541         ) 3<blobs |
2542         git fast-import --cat-blob-fd=3 3>blobs &&
2543         git show copied:file3 >actual &&
2544         test_cmp expect.response response &&
2545         test_cmp big actual
2546 '
2547
2548 test_expect_success PIPE 'R: print blob mid-commit' '
2549         rm -f blobs &&
2550         echo "A blob from _before_ the commit." >expect &&
2551         mkfifo blobs &&
2552         (
2553                 exec 3<blobs &&
2554                 cat <<-EOF &&
2555                 feature cat-blob
2556                 blob
2557                 mark :1
2558                 data <<BLOB
2559                 A blob from _before_ the commit.
2560                 BLOB
2561                 commit refs/heads/temporary
2562                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2563                 data <<COMMIT
2564                 Empty commit
2565                 COMMIT
2566                 cat-blob :1
2567                 EOF
2568
2569                 read blob_id type size <&3 &&
2570                 test_copy_bytes $size >actual <&3 &&
2571                 read newline <&3 &&
2572
2573                 echo
2574         ) |
2575         git fast-import --cat-blob-fd=3 3>blobs &&
2576         test_cmp expect actual
2577 '
2578
2579 test_expect_success PIPE 'R: print staged blob within commit' '
2580         rm -f blobs &&
2581         echo "A blob from _within_ the commit." >expect &&
2582         mkfifo blobs &&
2583         (
2584                 exec 3<blobs &&
2585                 cat <<-EOF &&
2586                 feature cat-blob
2587                 commit refs/heads/within
2588                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2589                 data <<COMMIT
2590                 Empty commit
2591                 COMMIT
2592                 M 644 inline within
2593                 data <<BLOB
2594                 A blob from _within_ the commit.
2595                 BLOB
2596                 EOF
2597
2598                 to_get=$(
2599                         echo "A blob from _within_ the commit." |
2600                         git hash-object --stdin
2601                 ) &&
2602                 echo "cat-blob $to_get" &&
2603
2604                 read blob_id type size <&3 &&
2605                 test_copy_bytes $size >actual <&3 &&
2606                 read newline <&3 &&
2607
2608                 echo deleteall
2609         ) |
2610         git fast-import --cat-blob-fd=3 3>blobs &&
2611         test_cmp expect actual
2612 '
2613
2614 test_expect_success 'R: quiet option results in no stats being output' '
2615         cat >input <<-EOF &&
2616         option git quiet
2617         blob
2618         data 3
2619         hi
2620
2621         EOF
2622
2623         git fast-import 2>output <input &&
2624         test_must_be_empty output
2625 '
2626
2627 test_expect_success 'R: feature done means terminating "done" is mandatory' '
2628         echo feature done | test_must_fail git fast-import &&
2629         test_must_fail git fast-import --done </dev/null
2630 '
2631
2632 test_expect_success 'R: terminating "done" with trailing gibberish is ok' '
2633         git fast-import <<-\EOF &&
2634         feature done
2635         done
2636         trailing gibberish
2637         EOF
2638         git fast-import <<-\EOF
2639         done
2640         more trailing gibberish
2641         EOF
2642 '
2643
2644 test_expect_success 'R: terminating "done" within commit' '
2645         cat >expect <<-\EOF &&
2646         OBJID
2647         :000000 100644 OBJID OBJID A    hello.c
2648         :000000 100644 OBJID OBJID A    hello2.c
2649         EOF
2650         git fast-import <<-EOF &&
2651         commit refs/heads/done-ends
2652         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2653         data <<EOT
2654         Commit terminated by "done" command
2655         EOT
2656         M 100644 inline hello.c
2657         data <<EOT
2658         Hello, world.
2659         EOT
2660         C hello.c hello2.c
2661         done
2662         EOF
2663         git rev-list done-ends |
2664         git diff-tree -r --stdin --root --always |
2665         sed -e "s/$OID_REGEX/OBJID/g" >actual &&
2666         test_cmp expect actual
2667 '
2668
2669 test_expect_success 'R: die on unknown option' '
2670         cat >input <<-EOF &&
2671         option git non-existing-option
2672         EOF
2673
2674         test_must_fail git fast-import <input
2675 '
2676
2677 test_expect_success 'R: unknown commandline options are rejected' '\
2678         test_must_fail git fast-import --non-existing-option < /dev/null
2679 '
2680
2681 test_expect_success 'R: die on invalid option argument' '
2682         echo "option git active-branches=-5" |
2683         test_must_fail git fast-import &&
2684         echo "option git depth=" |
2685         test_must_fail git fast-import &&
2686         test_must_fail git fast-import --depth="5 elephants" </dev/null
2687 '
2688
2689 test_expect_success 'R: ignore non-git options' '
2690         cat >input <<-EOF &&
2691         option non-existing-vcs non-existing-option
2692         EOF
2693
2694         git fast-import <input
2695 '
2696
2697 test_expect_success 'R: corrupt lines do not mess marks file' '
2698         rm -f io.marks &&
2699         blob=$(echo hi | git hash-object --stdin) &&
2700         cat >expect <<-EOF &&
2701         :3 0000000000000000000000000000000000000000
2702         :1 $blob
2703         :2 $blob
2704         EOF
2705         cp expect io.marks &&
2706         test_must_fail git fast-import --import-marks=io.marks --export-marks=io.marks <<-\EOF &&
2707
2708         EOF
2709         test_cmp expect io.marks
2710 '
2711
2712 ##
2713 ## R: very large blobs
2714 ##
2715 test_expect_success 'R: blob bigger than threshold' '
2716         blobsize=$((2*1024*1024 + 53)) &&
2717         test-tool genrandom bar $blobsize >expect &&
2718         cat >input <<-INPUT_END &&
2719         commit refs/heads/big-file
2720         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2721         data <<COMMIT
2722         R - big file
2723         COMMIT
2724
2725         M 644 inline big1
2726         data $blobsize
2727         INPUT_END
2728         cat expect >>input &&
2729         cat >>input <<-INPUT_END &&
2730         M 644 inline big2
2731         data $blobsize
2732         INPUT_END
2733         cat expect >>input &&
2734         echo >>input &&
2735
2736         test_create_repo R &&
2737         git --git-dir=R/.git config fastimport.unpackLimit 0 &&
2738         git --git-dir=R/.git fast-import --big-file-threshold=1 <input
2739 '
2740
2741 test_expect_success 'R: verify created pack' '
2742         (
2743                 cd R &&
2744                 verify_packs -v > ../verify
2745         )
2746 '
2747
2748 test_expect_success 'R: verify written objects' '
2749         git --git-dir=R/.git cat-file blob big-file:big1 >actual &&
2750         test_cmp_bin expect actual &&
2751         a=$(git --git-dir=R/.git rev-parse big-file:big1) &&
2752         b=$(git --git-dir=R/.git rev-parse big-file:big2) &&
2753         test $a = $b
2754 '
2755
2756 test_expect_success 'R: blob appears only once' '
2757         n=$(grep $a verify | wc -l) &&
2758         test 1 = $n
2759 '
2760
2761 ###
2762 ### series S
2763 ###
2764 #
2765 # Make sure missing spaces and EOLs after mark references
2766 # cause errors.
2767 #
2768 # Setup:
2769 #
2770 #   1--2--4
2771 #    \   /
2772 #     -3-
2773 #
2774 #   commit marks:  301, 302, 303, 304
2775 #   blob marks:              403, 404, resp.
2776 #   note mark:          202
2777 #
2778 # The error message when a space is missing not at the
2779 # end of the line is:
2780 #
2781 #   Missing space after ..
2782 #
2783 # or when extra characters come after the mark at the end
2784 # of the line:
2785 #
2786 #   Garbage after ..
2787 #
2788 # or when the dataref is neither "inline " or a known SHA1,
2789 #
2790 #   Invalid dataref ..
2791 #
2792 test_expect_success 'S: initialize for S tests' '
2793         test_tick &&
2794
2795         cat >input <<-INPUT_END &&
2796         commit refs/heads/S
2797         mark :301
2798         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2799         data <<COMMIT
2800         commit 1
2801         COMMIT
2802         M 100644 inline hello.c
2803         data <<BLOB
2804         blob 1
2805         BLOB
2806
2807         commit refs/heads/S
2808         mark :302
2809         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2810         data <<COMMIT
2811         commit 2
2812         COMMIT
2813         from :301
2814         M 100644 inline hello.c
2815         data <<BLOB
2816         blob 2
2817         BLOB
2818
2819         blob
2820         mark :403
2821         data <<BLOB
2822         blob 3
2823         BLOB
2824
2825         blob
2826         mark :202
2827         data <<BLOB
2828         note 2
2829         BLOB
2830         INPUT_END
2831
2832         git fast-import --export-marks=marks <input
2833 '
2834
2835 #
2836 # filemodify, three datarefs
2837 #
2838 test_expect_success 'S: filemodify with garbage after mark must fail' '
2839         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2840         commit refs/heads/S
2841         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2842         data <<COMMIT
2843         commit N
2844         COMMIT
2845         M 100644 :403x hello.c
2846         EOF
2847         test_i18ngrep "space after mark" err
2848 '
2849
2850 # inline is misspelled; fast-import thinks it is some unknown dataref
2851 test_expect_success 'S: filemodify with garbage after inline must fail' '
2852         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2853         commit refs/heads/S
2854         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2855         data <<COMMIT
2856         commit N
2857         COMMIT
2858         M 100644 inlineX hello.c
2859         data <<BLOB
2860         inline
2861         BLOB
2862         EOF
2863         test_i18ngrep "nvalid dataref" err
2864 '
2865
2866 test_expect_success 'S: filemodify with garbage after sha1 must fail' '
2867         sha1=$(grep :403 marks | cut -d\  -f2) &&
2868         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2869         commit refs/heads/S
2870         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2871         data <<COMMIT
2872         commit N
2873         COMMIT
2874         M 100644 ${sha1}x hello.c
2875         EOF
2876         test_i18ngrep "space after SHA1" err
2877 '
2878
2879 #
2880 # notemodify, three ways to say dataref
2881 #
2882 test_expect_success 'S: notemodify with garbage after mark dataref must fail' '
2883         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2884         commit refs/heads/S
2885         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2886         data <<COMMIT
2887         commit S note dataref markref
2888         COMMIT
2889         N :202x :302
2890         EOF
2891         test_i18ngrep "space after mark" err
2892 '
2893
2894 test_expect_success 'S: notemodify with garbage after inline dataref must fail' '
2895         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2896         commit refs/heads/S
2897         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2898         data <<COMMIT
2899         commit S note dataref inline
2900         COMMIT
2901         N inlineX :302
2902         data <<BLOB
2903         note blob
2904         BLOB
2905         EOF
2906         test_i18ngrep "nvalid dataref" err
2907 '
2908
2909 test_expect_success 'S: notemodify with garbage after sha1 dataref must fail' '
2910         sha1=$(grep :202 marks | cut -d\  -f2) &&
2911         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2912         commit refs/heads/S
2913         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2914         data <<COMMIT
2915         commit S note dataref sha1
2916         COMMIT
2917         N ${sha1}x :302
2918         EOF
2919         test_i18ngrep "space after SHA1" err
2920 '
2921
2922 #
2923 # notemodify, mark in commit-ish
2924 #
2925 test_expect_success 'S: notemodify with garbage after mark commit-ish must fail' '
2926         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2927         commit refs/heads/Snotes
2928         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2929         data <<COMMIT
2930         commit S note commit-ish
2931         COMMIT
2932         N :202 :302x
2933         EOF
2934         test_i18ngrep "after mark" err
2935 '
2936
2937 #
2938 # from
2939 #
2940 test_expect_success 'S: from with garbage after mark must fail' '
2941         test_must_fail \
2942         git fast-import --import-marks=marks --export-marks=marks <<-EOF 2>err &&
2943         commit refs/heads/S2
2944         mark :303
2945         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2946         data <<COMMIT
2947         commit 3
2948         COMMIT
2949         from :301x
2950         M 100644 :403 hello.c
2951         EOF
2952
2953
2954         # go create the commit, need it for merge test
2955         git fast-import --import-marks=marks --export-marks=marks <<-EOF &&
2956         commit refs/heads/S2
2957         mark :303
2958         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2959         data <<COMMIT
2960         commit 3
2961         COMMIT
2962         from :301
2963         M 100644 :403 hello.c
2964         EOF
2965
2966         # now evaluate the error
2967         test_i18ngrep "after mark" err
2968 '
2969
2970
2971 #
2972 # merge
2973 #
2974 test_expect_success 'S: merge with garbage after mark must fail' '
2975         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2976         commit refs/heads/S
2977         mark :304
2978         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2979         data <<COMMIT
2980         merge 4
2981         COMMIT
2982         from :302
2983         merge :303x
2984         M 100644 :403 hello.c
2985         EOF
2986         test_i18ngrep "after mark" err
2987 '
2988
2989 #
2990 # tag, from markref
2991 #
2992 test_expect_success 'S: tag with garbage after mark must fail' '
2993         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2994         tag refs/tags/Stag
2995         from :302x
2996         tagger $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2997         data <<TAG
2998         tag S
2999         TAG
3000         EOF
3001         test_i18ngrep "after mark" err
3002 '
3003
3004 #
3005 # cat-blob markref
3006 #
3007 test_expect_success 'S: cat-blob with garbage after mark must fail' '
3008         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3009         cat-blob :403x
3010         EOF
3011         test_i18ngrep "after mark" err
3012 '
3013
3014 #
3015 # ls markref
3016 #
3017 test_expect_success 'S: ls with garbage after mark must fail' '
3018         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3019         ls :302x hello.c
3020         EOF
3021         test_i18ngrep "space after mark" err
3022 '
3023
3024 test_expect_success 'S: ls with garbage after sha1 must fail' '
3025         sha1=$(grep :302 marks | cut -d\  -f2) &&
3026         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3027         ls ${sha1}x hello.c
3028         EOF
3029         test_i18ngrep "space after tree-ish" err
3030 '
3031
3032 ###
3033 ### series T (ls)
3034 ###
3035 # Setup is carried over from series S.
3036
3037 test_expect_success 'T: ls root tree' '
3038         sed -e "s/Z\$//" >expect <<-EOF &&
3039         040000 tree $(git rev-parse S^{tree})   Z
3040         EOF
3041         sha1=$(git rev-parse --verify S) &&
3042         git fast-import --import-marks=marks <<-EOF >actual &&
3043         ls $sha1 ""
3044         EOF
3045         test_cmp expect actual
3046 '
3047
3048 test_expect_success 'T: delete branch' '
3049         git branch to-delete &&
3050         git fast-import <<-EOF &&
3051         reset refs/heads/to-delete
3052         from 0000000000000000000000000000000000000000
3053         EOF
3054         test_must_fail git rev-parse --verify refs/heads/to-delete
3055 '
3056
3057 test_expect_success 'T: empty reset doesnt delete branch' '
3058         git branch not-to-delete &&
3059         git fast-import <<-EOF &&
3060         reset refs/heads/not-to-delete
3061         EOF
3062         git show-ref &&
3063         git rev-parse --verify refs/heads/not-to-delete
3064 '
3065
3066 ###
3067 ### series U (filedelete)
3068 ###
3069
3070 test_expect_success 'U: initialize for U tests' '
3071         cat >input <<-INPUT_END &&
3072         commit refs/heads/U
3073         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3074         data <<COMMIT
3075         test setup
3076         COMMIT
3077         M 100644 inline hello.c
3078         data <<BLOB
3079         blob 1
3080         BLOB
3081         M 100644 inline good/night.txt
3082         data <<BLOB
3083         sleep well
3084         BLOB
3085         M 100644 inline good/bye.txt
3086         data <<BLOB
3087         au revoir
3088         BLOB
3089
3090         INPUT_END
3091
3092         git fast-import <input
3093 '
3094
3095 test_expect_success 'U: filedelete file succeeds' '
3096         cat >input <<-INPUT_END &&
3097         commit refs/heads/U
3098         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3099         data <<COMMIT
3100         delete good/night.txt
3101         COMMIT
3102         from refs/heads/U^0
3103         D good/night.txt
3104
3105         INPUT_END
3106
3107         git fast-import <input
3108 '
3109
3110 test_expect_success 'U: validate file delete result' '
3111         cat >expect <<-EOF &&
3112         :100644 000000 2907ebb4bf85d91bf0716bb3bd8a68ef48d6da76 0000000000000000000000000000000000000000 D      good/night.txt
3113         EOF
3114
3115         git diff-tree -M -r U^1 U >actual &&
3116
3117         compare_diff_raw expect actual
3118 '
3119
3120 test_expect_success 'U: filedelete directory succeeds' '
3121         cat >input <<-INPUT_END &&
3122         commit refs/heads/U
3123         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3124         data <<COMMIT
3125         delete good dir
3126         COMMIT
3127         from refs/heads/U^0
3128         D good
3129
3130         INPUT_END
3131
3132         git fast-import <input
3133 '
3134
3135 test_expect_success 'U: validate directory delete result' '
3136         cat >expect <<-EOF &&
3137         :100644 000000 69cb75792f55123d8389c156b0b41c2ff00ed507 0000000000000000000000000000000000000000 D      good/bye.txt
3138         EOF
3139
3140         git diff-tree -M -r U^1 U >actual &&
3141
3142         compare_diff_raw expect actual
3143 '
3144
3145 test_expect_success 'U: filedelete root succeeds' '
3146         cat >input <<-INPUT_END &&
3147         commit refs/heads/U
3148         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3149         data <<COMMIT
3150         must succeed
3151         COMMIT
3152         from refs/heads/U^0
3153         D ""
3154
3155         INPUT_END
3156
3157         git fast-import <input
3158 '
3159
3160 test_expect_success 'U: validate root delete result' '
3161         cat >expect <<-EOF &&
3162         :100644 000000 c18147dc648481eeb65dc5e66628429a64843327 0000000000000000000000000000000000000000 D      hello.c
3163         EOF
3164
3165         git diff-tree -M -r U^1 U >actual &&
3166
3167         compare_diff_raw expect actual
3168 '
3169
3170 ###
3171 ### series V (checkpoint)
3172 ###
3173
3174 # The commands in input_file should not produce any output on the file
3175 # descriptor set with --cat-blob-fd (or stdout if unspecified).
3176 #
3177 # To make sure you're observing the side effects of checkpoint *before*
3178 # fast-import terminates (and thus writes out its state), check that the
3179 # fast-import process is still running using background_import_still_running
3180 # *after* evaluating the test conditions.
3181 background_import_then_checkpoint () {
3182         options=$1
3183         input_file=$2
3184
3185         mkfifo V.input
3186         exec 8<>V.input
3187         rm V.input
3188
3189         mkfifo V.output
3190         exec 9<>V.output
3191         rm V.output
3192
3193         (
3194                 git fast-import $options <&8 >&9 &
3195                 echo $! >&9
3196                 wait $!
3197                 echo >&2 "background fast-import terminated too early with exit code $?"
3198                 # Un-block the read loop in the main shell process.
3199                 echo >&9 UNEXPECTED
3200         ) &
3201         sh_pid=$!
3202         read fi_pid <&9
3203         # We don't mind if fast-import has already died by the time the test
3204         # ends.
3205         test_when_finished "
3206                 exec 8>&-; exec 9>&-;
3207                 kill $sh_pid && wait $sh_pid
3208                 kill $fi_pid && wait $fi_pid
3209                 true"
3210
3211         # Start in the background to ensure we adhere strictly to (blocking)
3212         # pipes writing sequence. We want to assume that the write below could
3213         # block, e.g. if fast-import blocks writing its own output to &9
3214         # because there is no reader on &9 yet.
3215         (
3216                 cat "$input_file"
3217                 echo "checkpoint"
3218                 echo "progress checkpoint"
3219         ) >&8 &
3220
3221         error=1 ;# assume the worst
3222         while read output <&9
3223         do
3224                 if test "$output" = "progress checkpoint"
3225                 then
3226                         error=0
3227                         break
3228                 elif test "$output" = "UNEXPECTED"
3229                 then
3230                         break
3231                 fi
3232                 # otherwise ignore cruft
3233                 echo >&2 "cruft: $output"
3234         done
3235
3236         if test $error -eq 1
3237         then
3238                 false
3239         fi
3240 }
3241
3242 background_import_still_running () {
3243         if ! kill -0 "$fi_pid"
3244         then
3245                 echo >&2 "background fast-import terminated too early"
3246                 false
3247         fi
3248 }
3249
3250 test_expect_success PIPE 'V: checkpoint helper does not get stuck with extra output' '
3251         cat >input <<-INPUT_END &&
3252         progress foo
3253         progress bar
3254
3255         INPUT_END
3256
3257         background_import_then_checkpoint "" input &&
3258         background_import_still_running
3259 '
3260
3261 test_expect_success PIPE 'V: checkpoint updates refs after reset' '
3262         cat >input <<-\INPUT_END &&
3263         reset refs/heads/V
3264         from refs/heads/U
3265
3266         INPUT_END
3267
3268         background_import_then_checkpoint "" input &&
3269         test "$(git rev-parse --verify V)" = "$(git rev-parse --verify U)" &&
3270         background_import_still_running
3271 '
3272
3273 test_expect_success PIPE 'V: checkpoint updates refs and marks after commit' '
3274         cat >input <<-INPUT_END &&
3275         commit refs/heads/V
3276         mark :1
3277         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3278         data 0
3279         from refs/heads/U
3280
3281         INPUT_END
3282
3283         background_import_then_checkpoint "--export-marks=marks.actual" input &&
3284
3285         echo ":1 $(git rev-parse --verify V)" >marks.expected &&
3286
3287         test "$(git rev-parse --verify V^)" = "$(git rev-parse --verify U)" &&
3288         test_cmp marks.expected marks.actual &&
3289         background_import_still_running
3290 '
3291
3292 # Re-create the exact same commit, but on a different branch: no new object is
3293 # created in the database, but the refs and marks still need to be updated.
3294 test_expect_success PIPE 'V: checkpoint updates refs and marks after commit (no new objects)' '
3295         cat >input <<-INPUT_END &&
3296         commit refs/heads/V2
3297         mark :2
3298         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3299         data 0
3300         from refs/heads/U
3301
3302         INPUT_END
3303
3304         background_import_then_checkpoint "--export-marks=marks.actual" input &&
3305
3306         echo ":2 $(git rev-parse --verify V2)" >marks.expected &&
3307
3308         test "$(git rev-parse --verify V2)" = "$(git rev-parse --verify V)" &&
3309         test_cmp marks.expected marks.actual &&
3310         background_import_still_running
3311 '
3312
3313 test_expect_success PIPE 'V: checkpoint updates tags after tag' '
3314         cat >input <<-INPUT_END &&
3315         tag Vtag
3316         from refs/heads/V
3317         tagger $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3318         data 0
3319
3320         INPUT_END
3321
3322         background_import_then_checkpoint "" input &&
3323         git show-ref -d Vtag &&
3324         background_import_still_running
3325 '
3326
3327 ###
3328 ### series W (get-mark and empty orphan commits)
3329 ###
3330
3331 cat >>W-input <<-W_INPUT_END
3332         commit refs/heads/W-branch
3333         mark :1
3334         author Full Name <user@company.tld> 1000000000 +0100
3335         committer Full Name <user@company.tld> 1000000000 +0100
3336         data 27
3337         Intentionally empty commit
3338         LFsget-mark :1
3339         W_INPUT_END
3340
3341 test_expect_success !MINGW 'W: get-mark & empty orphan commit with no newlines' '
3342         sed -e s/LFs// W-input | tr L "\n" | git fast-import
3343 '
3344
3345 test_expect_success !MINGW 'W: get-mark & empty orphan commit with one newline' '
3346         sed -e s/LFs/L/ W-input | tr L "\n" | git fast-import
3347 '
3348
3349 test_expect_success !MINGW 'W: get-mark & empty orphan commit with ugly second newline' '
3350         # Technically, this should fail as it has too many linefeeds
3351         # according to the grammar in fast-import.txt.  But, for whatever
3352         # reason, it works.  Since using the correct number of newlines
3353         # does not work with older (pre-2.22) versions of git, allow apps
3354         # that used this second-newline workaround to keep working by
3355         # checking it with this test...
3356         sed -e s/LFs/LL/ W-input | tr L "\n" | git fast-import
3357 '
3358
3359 test_expect_success !MINGW 'W: get-mark & empty orphan commit with erroneous third newline' '
3360         # ...but do NOT allow more empty lines than that (see previous test).
3361         sed -e s/LFs/LLL/ W-input | tr L "\n" | test_must_fail git fast-import
3362 '
3363
3364 ###
3365 ### series X (other new features)
3366 ###
3367
3368 test_expect_success 'X: handling encoding' '
3369         test_tick &&
3370         cat >input <<-INPUT_END &&
3371         commit refs/heads/encoding
3372         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3373         encoding iso-8859-7
3374         data <<COMMIT
3375         INPUT_END
3376
3377         printf "Pi: \360\nCOMMIT\n" >>input &&
3378
3379         git fast-import <input &&
3380         git cat-file -p encoding | grep $(printf "\360") &&
3381         git log -1 --format=%B encoding | grep $(printf "\317\200")
3382 '
3383
3384 test_done