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