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