t/t9300-fast-import.sh

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