Andrew's git - gitweb.git/blob - t/t9300-fast-import.sh

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