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