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

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