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