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