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