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         cut -f 2 <tmp >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         sort >expect <<-EOF &&
2011         100644 blob $commit1
2012         100644 blob $commit2
2013         100644 blob $commit3
2014         EOF
2015         git cat-file -p refs/notes/foobar~2^{tree} | sed "s/ [0-9a-f]*  / /" >actual &&
2016         test_cmp expect actual
2017 '
2018
2019 test_expect_success 'Q: verify first note for first commit' '
2020         echo "$note1_data" >expect &&
2021         git cat-file blob refs/notes/foobar~2:$commit1 >actual &&
2022         test_cmp expect actual
2023 '
2024
2025 test_expect_success 'Q: verify first note for second commit' '
2026         echo "$note2_data" >expect &&
2027         git cat-file blob refs/notes/foobar~2:$commit2 >actual &&
2028         test_cmp expect actual
2029 '
2030
2031 test_expect_success 'Q: verify first note for third commit' '
2032         echo "$note3_data" >expect &&
2033         git cat-file blob refs/notes/foobar~2:$commit3 >actual &&
2034         test_cmp expect actual
2035 '
2036
2037 test_expect_success 'Q: verify second notes commit' '
2038         cat >expect <<-EOF &&
2039         parent $(git rev-parse --verify refs/notes/foobar~2)
2040         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2041         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2042
2043         notes (:10)
2044         EOF
2045         git cat-file commit refs/notes/foobar^ | sed 1d >actual &&
2046         test_cmp expect actual
2047 '
2048
2049 test_expect_success 'Q: verify second notes tree' '
2050         sort >expect <<-EOF &&
2051         100644 blob $commit1
2052         100644 blob $commit2
2053         100644 blob $commit3
2054         EOF
2055         git cat-file -p refs/notes/foobar^^{tree} | sed "s/ [0-9a-f]*   / /" >actual &&
2056         test_cmp expect actual
2057 '
2058
2059 test_expect_success 'Q: verify second note for first commit' '
2060         echo "$note1b_data" >expect &&
2061         git cat-file blob refs/notes/foobar^:$commit1 >actual &&
2062         test_cmp expect actual
2063 '
2064
2065 test_expect_success 'Q: verify first note for second commit' '
2066         echo "$note2_data" >expect &&
2067         git cat-file blob refs/notes/foobar^:$commit2 >actual &&
2068         test_cmp expect actual
2069 '
2070
2071 test_expect_success 'Q: verify first note for third commit' '
2072         echo "$note3_data" >expect &&
2073         git cat-file blob refs/notes/foobar^:$commit3 >actual &&
2074         test_cmp expect actual
2075 '
2076
2077 test_expect_success 'Q: verify third notes commit' '
2078         cat >expect <<-EOF &&
2079         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2080         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2081
2082         notes (:11)
2083         EOF
2084         git cat-file commit refs/notes/foobar2 | sed 1d >actual &&
2085         test_cmp expect actual
2086 '
2087
2088 test_expect_success 'Q: verify third notes tree' '
2089         sort >expect <<-EOF &&
2090         100644 blob $commit1
2091         EOF
2092         git cat-file -p refs/notes/foobar2^{tree} | sed "s/ [0-9a-f]*   / /" >actual &&
2093         test_cmp expect actual
2094 '
2095
2096 test_expect_success 'Q: verify third note for first commit' '
2097         echo "$note1c_data" >expect &&
2098         git cat-file blob refs/notes/foobar2:$commit1 >actual &&
2099         test_cmp expect actual
2100 '
2101
2102 test_expect_success 'Q: verify fourth notes commit' '
2103         cat >expect <<-EOF &&
2104         parent $(git rev-parse --verify refs/notes/foobar^)
2105         author $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2106         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2107
2108         notes (:12)
2109         EOF
2110         git cat-file commit refs/notes/foobar | sed 1d >actual &&
2111         test_cmp expect actual
2112 '
2113
2114 test_expect_success 'Q: verify fourth notes tree' '
2115         sort >expect <<-EOF &&
2116         100644 blob $commit2
2117         EOF
2118         git cat-file -p refs/notes/foobar^{tree} | sed "s/ [0-9a-f]*    / /" >actual &&
2119         test_cmp expect actual
2120 '
2121
2122 test_expect_success 'Q: verify second note for second commit' '
2123         echo "$note2b_data" >expect &&
2124         git cat-file blob refs/notes/foobar:$commit2 >actual &&
2125         test_cmp expect actual
2126 '
2127
2128 test_expect_success 'Q: deny note on empty branch' '
2129         cat >input <<-EOF &&
2130         reset refs/heads/Q0
2131
2132         commit refs/heads/note-Q0
2133         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2134         data <<COMMIT
2135         Note for an empty branch.
2136         COMMIT
2137
2138         N inline refs/heads/Q0
2139         data <<NOTE
2140         some note
2141         NOTE
2142         EOF
2143         test_must_fail git fast-import <input
2144 '
2145 ###
2146 ### series R (feature and option)
2147 ###
2148
2149 test_expect_success 'R: abort on unsupported feature' '
2150         cat >input <<-EOF &&
2151         feature no-such-feature-exists
2152         EOF
2153
2154         test_must_fail git fast-import <input
2155 '
2156
2157 test_expect_success 'R: supported feature is accepted' '
2158         cat >input <<-EOF &&
2159         feature date-format=now
2160         EOF
2161
2162         git fast-import <input
2163 '
2164
2165 test_expect_success 'R: abort on receiving feature after data command' '
2166         cat >input <<-EOF &&
2167         blob
2168         data 3
2169         hi
2170         feature date-format=now
2171         EOF
2172
2173         test_must_fail git fast-import <input
2174 '
2175
2176 test_expect_success 'R: import-marks features forbidden by default' '
2177         >git.marks &&
2178         echo "feature import-marks=git.marks" >input &&
2179         test_must_fail git fast-import <input &&
2180         echo "feature import-marks-if-exists=git.marks" >input &&
2181         test_must_fail git fast-import <input
2182 '
2183
2184 test_expect_success 'R: only one import-marks feature allowed per stream' '
2185         >git.marks &&
2186         >git2.marks &&
2187         cat >input <<-EOF &&
2188         feature import-marks=git.marks
2189         feature import-marks=git2.marks
2190         EOF
2191
2192         test_must_fail git fast-import --allow-unsafe-features <input
2193 '
2194
2195 test_expect_success 'R: export-marks feature forbidden by default' '
2196         echo "feature export-marks=git.marks" >input &&
2197         test_must_fail git fast-import <input
2198 '
2199
2200 test_expect_success 'R: export-marks feature results in a marks file being created' '
2201         cat >input <<-EOF &&
2202         feature export-marks=git.marks
2203         blob
2204         mark :1
2205         data 3
2206         hi
2207
2208         EOF
2209
2210         git fast-import --allow-unsafe-features <input &&
2211         grep :1 git.marks
2212 '
2213
2214 test_expect_success 'R: export-marks options can be overridden by commandline options' '
2215         cat >input <<-\EOF &&
2216         feature export-marks=feature-sub/git.marks
2217         blob
2218         mark :1
2219         data 3
2220         hi
2221
2222         EOF
2223         git fast-import --allow-unsafe-features \
2224                         --export-marks=cmdline-sub/other.marks <input &&
2225         grep :1 cmdline-sub/other.marks &&
2226         test_path_is_missing feature-sub
2227 '
2228
2229 test_expect_success 'R: catch typo in marks file name' '
2230         test_must_fail git fast-import --import-marks=nonexistent.marks </dev/null &&
2231         echo "feature import-marks=nonexistent.marks" |
2232         test_must_fail git fast-import --allow-unsafe-features
2233 '
2234
2235 test_expect_success 'R: import and output marks can be the same file' '
2236         rm -f io.marks &&
2237         blob=$(echo hi | git hash-object --stdin) &&
2238         cat >expect <<-EOF &&
2239         :1 $blob
2240         :2 $blob
2241         EOF
2242         git fast-import --export-marks=io.marks <<-\EOF &&
2243         blob
2244         mark :1
2245         data 3
2246         hi
2247
2248         EOF
2249         git fast-import --import-marks=io.marks --export-marks=io.marks <<-\EOF &&
2250         blob
2251         mark :2
2252         data 3
2253         hi
2254
2255         EOF
2256         test_cmp expect io.marks
2257 '
2258
2259 test_expect_success 'R: --import-marks=foo --output-marks=foo to create foo fails' '
2260         rm -f io.marks &&
2261         test_must_fail git fast-import --import-marks=io.marks --export-marks=io.marks <<-\EOF
2262         blob
2263         mark :1
2264         data 3
2265         hi
2266
2267         EOF
2268 '
2269
2270 test_expect_success 'R: --import-marks-if-exists' '
2271         rm -f io.marks &&
2272         blob=$(echo hi | git hash-object --stdin) &&
2273         echo ":1 $blob" >expect &&
2274         git fast-import --import-marks-if-exists=io.marks --export-marks=io.marks <<-\EOF &&
2275         blob
2276         mark :1
2277         data 3
2278         hi
2279
2280         EOF
2281         test_cmp expect io.marks
2282 '
2283
2284 test_expect_success 'R: feature import-marks-if-exists' '
2285         rm -f io.marks &&
2286
2287         git fast-import --export-marks=io.marks \
2288                         --allow-unsafe-features <<-\EOF &&
2289         feature import-marks-if-exists=not_io.marks
2290         EOF
2291         test_must_be_empty io.marks &&
2292
2293         blob=$(echo hi | git hash-object --stdin) &&
2294
2295         echo ":1 $blob" >io.marks &&
2296         echo ":1 $blob" >expect &&
2297         echo ":2 $blob" >>expect &&
2298
2299         git fast-import --export-marks=io.marks \
2300                         --allow-unsafe-features <<-\EOF &&
2301         feature import-marks-if-exists=io.marks
2302         blob
2303         mark :2
2304         data 3
2305         hi
2306
2307         EOF
2308         test_cmp expect io.marks &&
2309
2310         echo ":3 $blob" >>expect &&
2311
2312         git fast-import --import-marks=io.marks \
2313                         --export-marks=io.marks \
2314                         --allow-unsafe-features <<-\EOF &&
2315         feature import-marks-if-exists=not_io.marks
2316         blob
2317         mark :3
2318         data 3
2319         hi
2320
2321         EOF
2322         test_cmp expect io.marks &&
2323
2324         git fast-import --import-marks-if-exists=not_io.marks \
2325                         --export-marks=io.marks \
2326                         --allow-unsafe-features <<-\EOF &&
2327         feature import-marks-if-exists=io.marks
2328         EOF
2329         test_must_be_empty io.marks
2330 '
2331
2332 test_expect_success 'R: import to output marks works without any content' '
2333         cat >input <<-EOF &&
2334         feature import-marks=marks.out
2335         feature export-marks=marks.new
2336         EOF
2337
2338         git fast-import --allow-unsafe-features <input &&
2339         test_cmp marks.out marks.new
2340 '
2341
2342 test_expect_success 'R: import marks prefers commandline marks file over the stream' '
2343         cat >input <<-EOF &&
2344         feature import-marks=nonexistent.marks
2345         feature export-marks=marks.new
2346         EOF
2347
2348         git fast-import --import-marks=marks.out --allow-unsafe-features <input &&
2349         test_cmp marks.out marks.new
2350 '
2351
2352
2353 test_expect_success 'R: multiple --import-marks= should be honoured' '
2354         cat >input <<-EOF &&
2355         feature import-marks=nonexistent.marks
2356         feature export-marks=combined.marks
2357         EOF
2358
2359         head -n2 marks.out > one.marks &&
2360         tail -n +3 marks.out > two.marks &&
2361         git fast-import --import-marks=one.marks --import-marks=two.marks \
2362                 --allow-unsafe-features <input &&
2363         test_cmp marks.out combined.marks
2364 '
2365
2366 test_expect_success 'R: feature relative-marks should be honoured' '
2367         cat >input <<-EOF &&
2368         feature relative-marks
2369         feature import-marks=relative.in
2370         feature export-marks=relative.out
2371         EOF
2372
2373         mkdir -p .git/info/fast-import/ &&
2374         cp marks.new .git/info/fast-import/relative.in &&
2375         git fast-import --allow-unsafe-features <input &&
2376         test_cmp marks.new .git/info/fast-import/relative.out
2377 '
2378
2379 test_expect_success 'R: feature no-relative-marks should be honoured' '
2380         cat >input <<-EOF &&
2381         feature relative-marks
2382         feature import-marks=relative.in
2383         feature no-relative-marks
2384         feature export-marks=non-relative.out
2385         EOF
2386
2387         git fast-import --allow-unsafe-features <input &&
2388         test_cmp marks.new non-relative.out
2389 '
2390
2391 test_expect_success 'R: feature ls supported' '
2392         echo "feature ls" |
2393         git fast-import
2394 '
2395
2396 test_expect_success 'R: feature cat-blob supported' '
2397         echo "feature cat-blob" |
2398         git fast-import
2399 '
2400
2401 test_expect_success 'R: cat-blob-fd must be a nonnegative integer' '
2402         test_must_fail git fast-import --cat-blob-fd=-1 </dev/null
2403 '
2404
2405 test_expect_success !MINGW 'R: print old blob' '
2406         blob=$(echo "yes it can" | git hash-object -w --stdin) &&
2407         cat >expect <<-EOF &&
2408         ${blob} blob 11
2409         yes it can
2410
2411         EOF
2412         echo "cat-blob $blob" |
2413         git fast-import --cat-blob-fd=6 6>actual &&
2414         test_cmp expect actual
2415 '
2416
2417 test_expect_success !MINGW 'R: in-stream cat-blob-fd not respected' '
2418         echo hello >greeting &&
2419         blob=$(git hash-object -w greeting) &&
2420         cat >expect <<-EOF &&
2421         ${blob} blob 6
2422         hello
2423
2424         EOF
2425         git fast-import --cat-blob-fd=3 3>actual.3 >actual.1 <<-EOF &&
2426         cat-blob $blob
2427         EOF
2428         test_cmp expect actual.3 &&
2429         test_must_be_empty actual.1 &&
2430         git fast-import 3>actual.3 >actual.1 <<-EOF &&
2431         option cat-blob-fd=3
2432         cat-blob $blob
2433         EOF
2434         test_must_be_empty actual.3 &&
2435         test_cmp expect actual.1
2436 '
2437
2438 test_expect_success !MINGW 'R: print mark for new blob' '
2439         echo "effluentish" | git hash-object --stdin >expect &&
2440         git fast-import --cat-blob-fd=6 6>actual <<-\EOF &&
2441         blob
2442         mark :1
2443         data <<BLOB_END
2444         effluentish
2445         BLOB_END
2446         get-mark :1
2447         EOF
2448         test_cmp expect actual
2449 '
2450
2451 test_expect_success !MINGW 'R: print new blob' '
2452         blob=$(echo "yep yep yep" | git hash-object --stdin) &&
2453         cat >expect <<-EOF &&
2454         ${blob} blob 12
2455         yep yep yep
2456
2457         EOF
2458         git fast-import --cat-blob-fd=6 6>actual <<-\EOF &&
2459         blob
2460         mark :1
2461         data <<BLOB_END
2462         yep yep yep
2463         BLOB_END
2464         cat-blob :1
2465         EOF
2466         test_cmp expect actual
2467 '
2468
2469 test_expect_success !MINGW 'R: print new blob by sha1' '
2470         blob=$(echo "a new blob named by sha1" | git hash-object --stdin) &&
2471         cat >expect <<-EOF &&
2472         ${blob} blob 25
2473         a new blob named by sha1
2474
2475         EOF
2476         git fast-import --cat-blob-fd=6 6>actual <<-EOF &&
2477         blob
2478         data <<BLOB_END
2479         a new blob named by sha1
2480         BLOB_END
2481         cat-blob $blob
2482         EOF
2483         test_cmp expect actual
2484 '
2485
2486 test_expect_success 'setup: big file' '
2487         (
2488                 echo "the quick brown fox jumps over the lazy dog" >big &&
2489                 for i in 1 2 3
2490                 do
2491                         cat big big big big >bigger &&
2492                         cat bigger bigger bigger bigger >big ||
2493                         exit
2494                 done
2495         )
2496 '
2497
2498 test_expect_success 'R: print two blobs to stdout' '
2499         blob1=$(git hash-object big) &&
2500         blob1_len=$(wc -c <big) &&
2501         blob2=$(echo hello | git hash-object --stdin) &&
2502         {
2503                 echo ${blob1} blob $blob1_len &&
2504                 cat big &&
2505                 cat <<-EOF
2506
2507                 ${blob2} blob 6
2508                 hello
2509
2510                 EOF
2511         } >expect &&
2512         {
2513                 cat <<-\END_PART1 &&
2514                         blob
2515                         mark :1
2516                         data <<data_end
2517                 END_PART1
2518                 cat big &&
2519                 cat <<-\EOF
2520                         data_end
2521                         blob
2522                         mark :2
2523                         data <<data_end
2524                         hello
2525                         data_end
2526                         cat-blob :1
2527                         cat-blob :2
2528                 EOF
2529         } |
2530         git fast-import >actual &&
2531         test_cmp expect actual
2532 '
2533
2534 test_expect_success PIPE 'R: copy using cat-file' '
2535         expect_id=$(git hash-object big) &&
2536         expect_len=$(wc -c <big) &&
2537         echo $expect_id blob $expect_len >expect.response &&
2538
2539         rm -f blobs &&
2540
2541         mkfifo blobs &&
2542         (
2543                 export GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL GIT_COMMITTER_DATE &&
2544                 cat <<-\EOF &&
2545                 feature cat-blob
2546                 blob
2547                 mark :1
2548                 data <<BLOB
2549                 EOF
2550                 cat big &&
2551                 cat <<-\EOF &&
2552                 BLOB
2553                 cat-blob :1
2554                 EOF
2555
2556                 read blob_id type size <&3 &&
2557                 echo "$blob_id $type $size" >response &&
2558                 test_copy_bytes $size >blob <&3 &&
2559                 read newline <&3 &&
2560
2561                 cat <<-EOF &&
2562                 commit refs/heads/copied
2563                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2564                 data <<COMMIT
2565                 copy big file as file3
2566                 COMMIT
2567                 M 644 inline file3
2568                 data <<BLOB
2569                 EOF
2570                 cat blob &&
2571                 echo BLOB
2572         ) 3<blobs |
2573         git fast-import --cat-blob-fd=3 3>blobs &&
2574         git show copied:file3 >actual &&
2575         test_cmp expect.response response &&
2576         test_cmp big actual
2577 '
2578
2579 test_expect_success PIPE 'R: print blob mid-commit' '
2580         rm -f blobs &&
2581         echo "A blob from _before_ the commit." >expect &&
2582         mkfifo blobs &&
2583         (
2584                 exec 3<blobs &&
2585                 cat <<-EOF &&
2586                 feature cat-blob
2587                 blob
2588                 mark :1
2589                 data <<BLOB
2590                 A blob from _before_ the commit.
2591                 BLOB
2592                 commit refs/heads/temporary
2593                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2594                 data <<COMMIT
2595                 Empty commit
2596                 COMMIT
2597                 cat-blob :1
2598                 EOF
2599
2600                 read blob_id type size <&3 &&
2601                 test_copy_bytes $size >actual <&3 &&
2602                 read newline <&3 &&
2603
2604                 echo
2605         ) |
2606         git fast-import --cat-blob-fd=3 3>blobs &&
2607         test_cmp expect actual
2608 '
2609
2610 test_expect_success PIPE 'R: print staged blob within commit' '
2611         rm -f blobs &&
2612         echo "A blob from _within_ the commit." >expect &&
2613         mkfifo blobs &&
2614         (
2615                 exec 3<blobs &&
2616                 cat <<-EOF &&
2617                 feature cat-blob
2618                 commit refs/heads/within
2619                 committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2620                 data <<COMMIT
2621                 Empty commit
2622                 COMMIT
2623                 M 644 inline within
2624                 data <<BLOB
2625                 A blob from _within_ the commit.
2626                 BLOB
2627                 EOF
2628
2629                 to_get=$(
2630                         echo "A blob from _within_ the commit." |
2631                         git hash-object --stdin
2632                 ) &&
2633                 echo "cat-blob $to_get" &&
2634
2635                 read blob_id type size <&3 &&
2636                 test_copy_bytes $size >actual <&3 &&
2637                 read newline <&3 &&
2638
2639                 echo deleteall
2640         ) |
2641         git fast-import --cat-blob-fd=3 3>blobs &&
2642         test_cmp expect actual
2643 '
2644
2645 test_expect_success 'R: quiet option results in no stats being output' '
2646         cat >input <<-EOF &&
2647         option git quiet
2648         blob
2649         data 3
2650         hi
2651
2652         EOF
2653
2654         git fast-import 2>output <input &&
2655         test_must_be_empty output
2656 '
2657
2658 test_expect_success 'R: feature done means terminating "done" is mandatory' '
2659         echo feature done | test_must_fail git fast-import &&
2660         test_must_fail git fast-import --done </dev/null
2661 '
2662
2663 test_expect_success 'R: terminating "done" with trailing gibberish is ok' '
2664         git fast-import <<-\EOF &&
2665         feature done
2666         done
2667         trailing gibberish
2668         EOF
2669         git fast-import <<-\EOF
2670         done
2671         more trailing gibberish
2672         EOF
2673 '
2674
2675 test_expect_success 'R: terminating "done" within commit' '
2676         cat >expect <<-\EOF &&
2677         OBJID
2678         :000000 100644 OBJID OBJID A    hello.c
2679         :000000 100644 OBJID OBJID A    hello2.c
2680         EOF
2681         git fast-import <<-EOF &&
2682         commit refs/heads/done-ends
2683         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2684         data <<EOT
2685         Commit terminated by "done" command
2686         EOT
2687         M 100644 inline hello.c
2688         data <<EOT
2689         Hello, world.
2690         EOT
2691         C hello.c hello2.c
2692         done
2693         EOF
2694         git rev-list done-ends |
2695         git diff-tree -r --stdin --root --always |
2696         sed -e "s/$OID_REGEX/OBJID/g" >actual &&
2697         test_cmp expect actual
2698 '
2699
2700 test_expect_success 'R: die on unknown option' '
2701         cat >input <<-EOF &&
2702         option git non-existing-option
2703         EOF
2704
2705         test_must_fail git fast-import <input
2706 '
2707
2708 test_expect_success 'R: unknown commandline options are rejected' '\
2709         test_must_fail git fast-import --non-existing-option < /dev/null
2710 '
2711
2712 test_expect_success 'R: die on invalid option argument' '
2713         echo "option git active-branches=-5" |
2714         test_must_fail git fast-import &&
2715         echo "option git depth=" |
2716         test_must_fail git fast-import &&
2717         test_must_fail git fast-import --depth="5 elephants" </dev/null
2718 '
2719
2720 test_expect_success 'R: ignore non-git options' '
2721         cat >input <<-EOF &&
2722         option non-existing-vcs non-existing-option
2723         EOF
2724
2725         git fast-import <input
2726 '
2727
2728 test_expect_success 'R: corrupt lines do not mess marks file' '
2729         rm -f io.marks &&
2730         blob=$(echo hi | git hash-object --stdin) &&
2731         cat >expect <<-EOF &&
2732         :3 $ZERO_OID
2733         :1 $blob
2734         :2 $blob
2735         EOF
2736         cp expect io.marks &&
2737         test_must_fail git fast-import --import-marks=io.marks --export-marks=io.marks <<-\EOF &&
2738
2739         EOF
2740         test_cmp expect io.marks
2741 '
2742
2743 ##
2744 ## R: very large blobs
2745 ##
2746 test_expect_success 'R: blob bigger than threshold' '
2747         blobsize=$((2*1024*1024 + 53)) &&
2748         test-tool genrandom bar $blobsize >expect &&
2749         cat >input <<-INPUT_END &&
2750         commit refs/heads/big-file
2751         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2752         data <<COMMIT
2753         R - big file
2754         COMMIT
2755
2756         M 644 inline big1
2757         data $blobsize
2758         INPUT_END
2759         cat expect >>input &&
2760         cat >>input <<-INPUT_END &&
2761         M 644 inline big2
2762         data $blobsize
2763         INPUT_END
2764         cat expect >>input &&
2765         echo >>input &&
2766
2767         test_create_repo R &&
2768         git --git-dir=R/.git config fastimport.unpackLimit 0 &&
2769         git --git-dir=R/.git fast-import --big-file-threshold=1 <input
2770 '
2771
2772 test_expect_success 'R: verify created pack' '
2773         (
2774                 cd R &&
2775                 verify_packs -v > ../verify
2776         )
2777 '
2778
2779 test_expect_success 'R: verify written objects' '
2780         git --git-dir=R/.git cat-file blob big-file:big1 >actual &&
2781         test_cmp_bin expect actual &&
2782         a=$(git --git-dir=R/.git rev-parse big-file:big1) &&
2783         b=$(git --git-dir=R/.git rev-parse big-file:big2) &&
2784         test $a = $b
2785 '
2786
2787 test_expect_success 'R: blob appears only once' '
2788         n=$(grep $a verify | wc -l) &&
2789         test 1 = $n
2790 '
2791
2792 ###
2793 ### series S
2794 ###
2795 #
2796 # Make sure missing spaces and EOLs after mark references
2797 # cause errors.
2798 #
2799 # Setup:
2800 #
2801 #   1--2--4
2802 #    \   /
2803 #     -3-
2804 #
2805 #   commit marks:  301, 302, 303, 304
2806 #   blob marks:              403, 404, resp.
2807 #   note mark:          202
2808 #
2809 # The error message when a space is missing not at the
2810 # end of the line is:
2811 #
2812 #   Missing space after ..
2813 #
2814 # or when extra characters come after the mark at the end
2815 # of the line:
2816 #
2817 #   Garbage after ..
2818 #
2819 # or when the dataref is neither "inline " or a known SHA1,
2820 #
2821 #   Invalid dataref ..
2822 #
2823 test_expect_success 'S: initialize for S tests' '
2824         test_tick &&
2825
2826         cat >input <<-INPUT_END &&
2827         commit refs/heads/S
2828         mark :301
2829         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2830         data <<COMMIT
2831         commit 1
2832         COMMIT
2833         M 100644 inline hello.c
2834         data <<BLOB
2835         blob 1
2836         BLOB
2837
2838         commit refs/heads/S
2839         mark :302
2840         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2841         data <<COMMIT
2842         commit 2
2843         COMMIT
2844         from :301
2845         M 100644 inline hello.c
2846         data <<BLOB
2847         blob 2
2848         BLOB
2849
2850         blob
2851         mark :403
2852         data <<BLOB
2853         blob 3
2854         BLOB
2855
2856         blob
2857         mark :202
2858         data <<BLOB
2859         note 2
2860         BLOB
2861         INPUT_END
2862
2863         git fast-import --export-marks=marks <input
2864 '
2865
2866 #
2867 # filemodify, three datarefs
2868 #
2869 test_expect_success 'S: filemodify with garbage after mark must fail' '
2870         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2871         commit refs/heads/S
2872         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2873         data <<COMMIT
2874         commit N
2875         COMMIT
2876         M 100644 :403x hello.c
2877         EOF
2878         test_grep "space after mark" err
2879 '
2880
2881 # inline is misspelled; fast-import thinks it is some unknown dataref
2882 test_expect_success 'S: filemodify with garbage after inline must fail' '
2883         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2884         commit refs/heads/S
2885         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2886         data <<COMMIT
2887         commit N
2888         COMMIT
2889         M 100644 inlineX hello.c
2890         data <<BLOB
2891         inline
2892         BLOB
2893         EOF
2894         test_grep "nvalid dataref" err
2895 '
2896
2897 test_expect_success 'S: filemodify with garbage after sha1 must fail' '
2898         sha1=$(grep :403 marks | cut -d\  -f2) &&
2899         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2900         commit refs/heads/S
2901         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2902         data <<COMMIT
2903         commit N
2904         COMMIT
2905         M 100644 ${sha1}x hello.c
2906         EOF
2907         test_grep "space after SHA1" err
2908 '
2909
2910 #
2911 # notemodify, three ways to say dataref
2912 #
2913 test_expect_success 'S: notemodify with garbage after mark dataref must fail' '
2914         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2915         commit refs/heads/S
2916         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2917         data <<COMMIT
2918         commit S note dataref markref
2919         COMMIT
2920         N :202x :302
2921         EOF
2922         test_grep "space after mark" err
2923 '
2924
2925 test_expect_success 'S: notemodify with garbage after inline dataref must fail' '
2926         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2927         commit refs/heads/S
2928         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2929         data <<COMMIT
2930         commit S note dataref inline
2931         COMMIT
2932         N inlineX :302
2933         data <<BLOB
2934         note blob
2935         BLOB
2936         EOF
2937         test_grep "nvalid dataref" err
2938 '
2939
2940 test_expect_success 'S: notemodify with garbage after sha1 dataref must fail' '
2941         sha1=$(grep :202 marks | cut -d\  -f2) &&
2942         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2943         commit refs/heads/S
2944         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2945         data <<COMMIT
2946         commit S note dataref sha1
2947         COMMIT
2948         N ${sha1}x :302
2949         EOF
2950         test_grep "space after SHA1" err
2951 '
2952
2953 #
2954 # notemodify, mark in commit-ish
2955 #
2956 test_expect_success 'S: notemodify with garbage after mark commit-ish must fail' '
2957         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
2958         commit refs/heads/Snotes
2959         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2960         data <<COMMIT
2961         commit S note commit-ish
2962         COMMIT
2963         N :202 :302x
2964         EOF
2965         test_grep "after mark" err
2966 '
2967
2968 #
2969 # from
2970 #
2971 test_expect_success 'S: from with garbage after mark must fail' '
2972         test_must_fail \
2973         git fast-import --import-marks=marks --export-marks=marks <<-EOF 2>err &&
2974         commit refs/heads/S2
2975         mark :303
2976         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2977         data <<COMMIT
2978         commit 3
2979         COMMIT
2980         from :301x
2981         M 100644 :403 hello.c
2982         EOF
2983
2984
2985         # go create the commit, need it for merge test
2986         git fast-import --import-marks=marks --export-marks=marks <<-EOF &&
2987         commit refs/heads/S2
2988         mark :303
2989         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
2990         data <<COMMIT
2991         commit 3
2992         COMMIT
2993         from :301
2994         M 100644 :403 hello.c
2995         EOF
2996
2997         # now evaluate the error
2998         test_grep "after mark" err
2999 '
3000
3001
3002 #
3003 # merge
3004 #
3005 test_expect_success 'S: merge with garbage after mark must fail' '
3006         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3007         commit refs/heads/S
3008         mark :304
3009         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3010         data <<COMMIT
3011         merge 4
3012         COMMIT
3013         from :302
3014         merge :303x
3015         M 100644 :403 hello.c
3016         EOF
3017         test_grep "after mark" err
3018 '
3019
3020 #
3021 # tag, from markref
3022 #
3023 test_expect_success 'S: tag with garbage after mark must fail' '
3024         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3025         tag refs/tags/Stag
3026         from :302x
3027         tagger $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3028         data <<TAG
3029         tag S
3030         TAG
3031         EOF
3032         test_grep "after mark" err
3033 '
3034
3035 #
3036 # cat-blob markref
3037 #
3038 test_expect_success 'S: cat-blob with garbage after mark must fail' '
3039         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3040         cat-blob :403x
3041         EOF
3042         test_grep "after mark" err
3043 '
3044
3045 #
3046 # ls markref
3047 #
3048 test_expect_success 'S: ls with garbage after mark must fail' '
3049         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3050         ls :302x hello.c
3051         EOF
3052         test_grep "space after mark" err
3053 '
3054
3055 test_expect_success 'S: ls with garbage after sha1 must fail' '
3056         sha1=$(grep :302 marks | cut -d\  -f2) &&
3057         test_must_fail git fast-import --import-marks=marks <<-EOF 2>err &&
3058         ls ${sha1}x hello.c
3059         EOF
3060         test_grep "space after tree-ish" err
3061 '
3062
3063 ###
3064 ### series T (ls)
3065 ###
3066 # Setup is carried over from series S.
3067
3068 test_expect_success 'T: ls root tree' '
3069         sed -e "s/Z\$//" >expect <<-EOF &&
3070         040000 tree $(git rev-parse S^{tree})   Z
3071         EOF
3072         sha1=$(git rev-parse --verify S) &&
3073         git fast-import --import-marks=marks <<-EOF >actual &&
3074         ls $sha1 ""
3075         EOF
3076         test_cmp expect actual
3077 '
3078
3079 test_expect_success 'T: delete branch' '
3080         git branch to-delete &&
3081         git fast-import <<-EOF &&
3082         reset refs/heads/to-delete
3083         from $ZERO_OID
3084         EOF
3085         test_must_fail git rev-parse --verify refs/heads/to-delete
3086 '
3087
3088 test_expect_success 'T: empty reset doesnt delete branch' '
3089         git branch not-to-delete &&
3090         git fast-import <<-EOF &&
3091         reset refs/heads/not-to-delete
3092         EOF
3093         git show-ref &&
3094         git rev-parse --verify refs/heads/not-to-delete
3095 '
3096
3097 ###
3098 ### series U (filedelete)
3099 ###
3100
3101 test_expect_success 'U: initialize for U tests' '
3102         cat >input <<-INPUT_END &&
3103         commit refs/heads/U
3104         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3105         data <<COMMIT
3106         test setup
3107         COMMIT
3108         M 100644 inline hello.c
3109         data <<BLOB
3110         blob 1
3111         BLOB
3112         M 100644 inline good/night.txt
3113         data <<BLOB
3114         sleep well
3115         BLOB
3116         M 100644 inline good/bye.txt
3117         data <<BLOB
3118         au revoir
3119         BLOB
3120
3121         INPUT_END
3122
3123         f7id=$(echo "blob 1" | git hash-object --stdin) &&
3124         f8id=$(echo "sleep well" | git hash-object --stdin) &&
3125         f9id=$(echo "au revoir" | git hash-object --stdin) &&
3126         git fast-import <input
3127 '
3128
3129 test_expect_success 'U: filedelete file succeeds' '
3130         cat >input <<-INPUT_END &&
3131         commit refs/heads/U
3132         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3133         data <<COMMIT
3134         delete good/night.txt
3135         COMMIT
3136         from refs/heads/U^0
3137         D good/night.txt
3138
3139         INPUT_END
3140
3141         git fast-import <input
3142 '
3143
3144 test_expect_success 'U: validate file delete result' '
3145         cat >expect <<-EOF &&
3146         :100644 000000 $f8id $ZERO_OID D        good/night.txt
3147         EOF
3148
3149         git diff-tree -M -r U^1 U >actual &&
3150
3151         compare_diff_raw expect actual
3152 '
3153
3154 test_expect_success 'U: filedelete directory succeeds' '
3155         cat >input <<-INPUT_END &&
3156         commit refs/heads/U
3157         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3158         data <<COMMIT
3159         delete good dir
3160         COMMIT
3161         from refs/heads/U^0
3162         D good
3163
3164         INPUT_END
3165
3166         git fast-import <input
3167 '
3168
3169 test_expect_success 'U: validate directory delete result' '
3170         cat >expect <<-EOF &&
3171         :100644 000000 $f9id $ZERO_OID D        good/bye.txt
3172         EOF
3173
3174         git diff-tree -M -r U^1 U >actual &&
3175
3176         compare_diff_raw expect actual
3177 '
3178
3179 test_expect_success 'U: filedelete root succeeds' '
3180         cat >input <<-INPUT_END &&
3181         commit refs/heads/U
3182         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3183         data <<COMMIT
3184         must succeed
3185         COMMIT
3186         from refs/heads/U^0
3187         D ""
3188
3189         INPUT_END
3190
3191         git fast-import <input
3192 '
3193
3194 test_expect_success 'U: validate root delete result' '
3195         cat >expect <<-EOF &&
3196         :100644 000000 $f7id $ZERO_OID D        hello.c
3197         EOF
3198
3199         git diff-tree -M -r U^1 U >actual &&
3200
3201         compare_diff_raw expect actual
3202 '
3203
3204 ###
3205 ### series V (checkpoint)
3206 ###
3207
3208 # The commands in input_file should not produce any output on the file
3209 # descriptor set with --cat-blob-fd (or stdout if unspecified).
3210 #
3211 # To make sure you're observing the side effects of checkpoint *before*
3212 # fast-import terminates (and thus writes out its state), check that the
3213 # fast-import process is still running using background_import_still_running
3214 # *after* evaluating the test conditions.
3215 background_import_then_checkpoint () {
3216         options=$1
3217         input_file=$2
3218
3219         mkfifo V.input
3220         exec 8<>V.input
3221         rm V.input
3222
3223         mkfifo V.output
3224         exec 9<>V.output
3225         rm V.output
3226
3227         (
3228                 git fast-import $options <&8 >&9 &
3229                 echo $! >&9
3230                 wait $!
3231                 echo >&2 "background fast-import terminated too early with exit code $?"
3232                 # Un-block the read loop in the main shell process.
3233                 echo >&9 UNEXPECTED
3234         ) &
3235         sh_pid=$!
3236         read fi_pid <&9
3237         # We don't mind if fast-import has already died by the time the test
3238         # ends.
3239         test_when_finished "
3240                 exec 8>&-; exec 9>&-;
3241                 kill $sh_pid && wait $sh_pid
3242                 kill $fi_pid && wait $fi_pid
3243                 true"
3244
3245         # Start in the background to ensure we adhere strictly to (blocking)
3246         # pipes writing sequence. We want to assume that the write below could
3247         # block, e.g. if fast-import blocks writing its own output to &9
3248         # because there is no reader on &9 yet.
3249         (
3250                 cat "$input_file"
3251                 echo "checkpoint"
3252                 echo "progress checkpoint"
3253         ) >&8 &
3254
3255         error=1 ;# assume the worst
3256         while read output <&9
3257         do
3258                 if test "$output" = "progress checkpoint"
3259                 then
3260                         error=0
3261                         break
3262                 elif test "$output" = "UNEXPECTED"
3263                 then
3264                         break
3265                 fi
3266                 # otherwise ignore cruft
3267                 echo >&2 "cruft: $output"
3268         done
3269
3270         if test $error -eq 1
3271         then
3272                 false
3273         fi
3274 }
3275
3276 background_import_still_running () {
3277         if ! kill -0 "$fi_pid"
3278         then
3279                 echo >&2 "background fast-import terminated too early"
3280                 false
3281         fi
3282 }
3283
3284 test_expect_success PIPE 'V: checkpoint helper does not get stuck with extra output' '
3285         cat >input <<-INPUT_END &&
3286         progress foo
3287         progress bar
3288
3289         INPUT_END
3290
3291         background_import_then_checkpoint "" input &&
3292         background_import_still_running
3293 '
3294
3295 test_expect_success PIPE 'V: checkpoint updates refs after reset' '
3296         cat >input <<-\INPUT_END &&
3297         reset refs/heads/V
3298         from refs/heads/U
3299
3300         INPUT_END
3301
3302         background_import_then_checkpoint "" input &&
3303         test "$(git rev-parse --verify V)" = "$(git rev-parse --verify U)" &&
3304         background_import_still_running
3305 '
3306
3307 test_expect_success PIPE 'V: checkpoint updates refs and marks after commit' '
3308         cat >input <<-INPUT_END &&
3309         commit refs/heads/V
3310         mark :1
3311         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3312         data 0
3313         from refs/heads/U
3314
3315         INPUT_END
3316
3317         background_import_then_checkpoint "--export-marks=marks.actual" input &&
3318
3319         echo ":1 $(git rev-parse --verify V)" >marks.expected &&
3320
3321         test "$(git rev-parse --verify V^)" = "$(git rev-parse --verify U)" &&
3322         test_cmp marks.expected marks.actual &&
3323         background_import_still_running
3324 '
3325
3326 # Re-create the exact same commit, but on a different branch: no new object is
3327 # created in the database, but the refs and marks still need to be updated.
3328 test_expect_success PIPE 'V: checkpoint updates refs and marks after commit (no new objects)' '
3329         cat >input <<-INPUT_END &&
3330         commit refs/heads/V2
3331         mark :2
3332         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3333         data 0
3334         from refs/heads/U
3335
3336         INPUT_END
3337
3338         background_import_then_checkpoint "--export-marks=marks.actual" input &&
3339
3340         echo ":2 $(git rev-parse --verify V2)" >marks.expected &&
3341
3342         test "$(git rev-parse --verify V2)" = "$(git rev-parse --verify V)" &&
3343         test_cmp marks.expected marks.actual &&
3344         background_import_still_running
3345 '
3346
3347 test_expect_success PIPE 'V: checkpoint updates tags after tag' '
3348         cat >input <<-INPUT_END &&
3349         tag Vtag
3350         from refs/heads/V
3351         tagger $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3352         data 0
3353
3354         INPUT_END
3355
3356         background_import_then_checkpoint "" input &&
3357         git show-ref -d Vtag &&
3358         background_import_still_running
3359 '
3360
3361 ###
3362 ### series W (get-mark and empty orphan commits)
3363 ###
3364
3365 cat >>W-input <<-W_INPUT_END
3366         commit refs/heads/W-branch
3367         mark :1
3368         author Full Name <user@company.tld> 1000000000 +0100
3369         committer Full Name <user@company.tld> 1000000000 +0100
3370         data 27
3371         Intentionally empty commit
3372         LFsget-mark :1
3373         W_INPUT_END
3374
3375 test_expect_success !MINGW 'W: get-mark & empty orphan commit with no newlines' '
3376         sed -e s/LFs// W-input | tr L "\n" | git fast-import
3377 '
3378
3379 test_expect_success !MINGW 'W: get-mark & empty orphan commit with one newline' '
3380         sed -e s/LFs/L/ W-input | tr L "\n" | git fast-import
3381 '
3382
3383 test_expect_success !MINGW 'W: get-mark & empty orphan commit with ugly second newline' '
3384         # Technically, this should fail as it has too many linefeeds
3385         # according to the grammar in fast-import.txt.  But, for whatever
3386         # reason, it works.  Since using the correct number of newlines
3387         # does not work with older (pre-2.22) versions of git, allow apps
3388         # that used this second-newline workaround to keep working by
3389         # checking it with this test...
3390         sed -e s/LFs/LL/ W-input | tr L "\n" | git fast-import
3391 '
3392
3393 test_expect_success !MINGW 'W: get-mark & empty orphan commit with erroneous third newline' '
3394         # ...but do NOT allow more empty lines than that (see previous test).
3395         sed -e s/LFs/LLL/ W-input | tr L "\n" | test_must_fail git fast-import
3396 '
3397
3398 ###
3399 ### series X (other new features)
3400 ###
3401
3402 test_expect_success 'X: handling encoding' '
3403         test_tick &&
3404         cat >input <<-INPUT_END &&
3405         commit refs/heads/encoding
3406         committer $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> $GIT_COMMITTER_DATE
3407         encoding iso-8859-7
3408         data <<COMMIT
3409         INPUT_END
3410
3411         printf "Pi: \360\nCOMMIT\n" >>input &&
3412
3413         git fast-import <input &&
3414         git cat-file -p encoding | grep $(printf "\360") &&
3415         git log -1 --format=%B encoding | grep $(printf "\317\200")
3416 '
3417
3418 ###
3419 ### series Y (submodules and hash algorithms)
3420 ###
3421
3422 cat >Y-sub-input <<\Y_INPUT_END
3423 blob
3424 mark :1
3425 data 4
3426 foo
3427
3428 reset refs/heads/main
3429 commit refs/heads/main
3430 mark :2
3431 author Full Name <user@company.tld> 1000000000 +0100
3432 committer Full Name <user@company.tld> 1000000000 +0100
3433 data 24
3434 Test submodule commit 1
3435 M 100644 :1 file
3436
3437 blob
3438 mark :3
3439 data 8
3440 foo
3441 bar
3442
3443 commit refs/heads/main
3444 mark :4
3445 author Full Name <user@company.tld> 1000000001 +0100
3446 committer Full Name <user@company.tld> 1000000001 +0100
3447 data 24
3448 Test submodule commit 2
3449 from :2
3450 M 100644 :3 file
3451 Y_INPUT_END
3452
3453 # Note that the submodule object IDs are intentionally not translated.
3454 cat >Y-main-input <<\Y_INPUT_END
3455 blob
3456 mark :1
3457 data 4
3458 foo
3459
3460 reset refs/heads/main
3461 commit refs/heads/main
3462 mark :2
3463 author Full Name <user@company.tld> 2000000000 +0100
3464 committer Full Name <user@company.tld> 2000000000 +0100
3465 data 14
3466 Test commit 1
3467 M 100644 :1 file
3468
3469 blob
3470 mark :3
3471 data 73
3472 [submodule "sub1"]
3473         path = sub1
3474         url = https://void.example.com/main.git
3475
3476 commit refs/heads/main
3477 mark :4
3478 author Full Name <user@company.tld> 2000000001 +0100
3479 committer Full Name <user@company.tld> 2000000001 +0100
3480 data 14
3481 Test commit 2
3482 from :2
3483 M 100644 :3 .gitmodules
3484 M 160000 0712c5be7cf681388e355ef47525aaf23aee1a6d sub1
3485
3486 blob
3487 mark :5
3488 data 8
3489 foo
3490 bar
3491
3492 commit refs/heads/main
3493 mark :6
3494 author Full Name <user@company.tld> 2000000002 +0100
3495 committer Full Name <user@company.tld> 2000000002 +0100
3496 data 14
3497 Test commit 3
3498 from :4
3499 M 100644 :5 file
3500 M 160000 ff729f5e62f72c0c3978207d9a80e5f3a65f14d7 sub1
3501 Y_INPUT_END
3502
3503 cat >Y-marks <<\Y_INPUT_END
3504 :2 0712c5be7cf681388e355ef47525aaf23aee1a6d
3505 :4 ff729f5e62f72c0c3978207d9a80e5f3a65f14d7
3506 Y_INPUT_END
3507
3508 test_expect_success 'Y: setup' '
3509         test_oid_cache <<-EOF
3510         Ymain sha1:9afed2f9161ddf416c0a1863b8b0725b00070504
3511         Ymain sha256:c0a1010da1df187b2e287654793df01b464bd6f8e3f17fc1481a7dadf84caee3
3512         EOF
3513 '
3514
3515 test_expect_success 'Y: rewrite submodules' '
3516         git init main1 &&
3517         (
3518                 cd main1 &&
3519                 git init sub2 &&
3520                 git -C sub2 fast-import --export-marks=../sub2-marks <../Y-sub-input &&
3521                 git fast-import --rewrite-submodules-from=sub:../Y-marks \
3522                         --rewrite-submodules-to=sub:sub2-marks <../Y-main-input &&
3523                 test "$(git rev-parse main)" = "$(test_oid Ymain)"
3524         )
3525 '
3526
3527 test_done