]> git.ipfire.org Git - thirdparty/git.git/blob - t/t0021-conversion.sh
l10n: fr v2.23.0 round 2
[thirdparty/git.git] / t / t0021-conversion.sh
1 #!/bin/sh
2
3 test_description='blob conversion via gitattributes'
4
5 . ./test-lib.sh
6
7 TEST_ROOT="$PWD"
8 PATH=$TEST_ROOT:$PATH
9
10 write_script <<\EOF "$TEST_ROOT/rot13.sh"
11 tr \
12 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' \
13 'nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM'
14 EOF
15
16 write_script rot13-filter.pl "$PERL_PATH" \
17 <"$TEST_DIRECTORY"/t0021/rot13-filter.pl
18
19 generate_random_characters () {
20 LEN=$1
21 NAME=$2
22 test-tool genrandom some-seed $LEN |
23 perl -pe "s/./chr((ord($&) % 26) + ord('a'))/sge" >"$TEST_ROOT/$NAME"
24 }
25
26 file_size () {
27 test-tool path-utils file-size "$1"
28 }
29
30 filter_git () {
31 rm -f *.log &&
32 git "$@"
33 }
34
35 # Compare two files and ensure that `clean` and `smudge` respectively are
36 # called at least once if specified in the `expect` file. The actual
37 # invocation count is not relevant because their number can vary.
38 # c.f. http://public-inbox.org/git/xmqqshv18i8i.fsf@gitster.mtv.corp.google.com/
39 test_cmp_count () {
40 expect=$1
41 actual=$2
42 for FILE in "$expect" "$actual"
43 do
44 sort "$FILE" | uniq -c |
45 sed -e "s/^ *[0-9][0-9]*[ ]*IN: /x IN: /" >"$FILE.tmp"
46 done &&
47 test_cmp "$expect.tmp" "$actual.tmp" &&
48 rm "$expect.tmp" "$actual.tmp"
49 }
50
51 # Compare two files but exclude all `clean` invocations because Git can
52 # call `clean` zero or more times.
53 # c.f. http://public-inbox.org/git/xmqqshv18i8i.fsf@gitster.mtv.corp.google.com/
54 test_cmp_exclude_clean () {
55 expect=$1
56 actual=$2
57 for FILE in "$expect" "$actual"
58 do
59 grep -v "IN: clean" "$FILE" >"$FILE.tmp"
60 done &&
61 test_cmp "$expect.tmp" "$actual.tmp" &&
62 rm "$expect.tmp" "$actual.tmp"
63 }
64
65 # Check that the contents of two files are equal and that their rot13 version
66 # is equal to the committed content.
67 test_cmp_committed_rot13 () {
68 test_cmp "$1" "$2" &&
69 rot13.sh <"$1" >expected &&
70 git cat-file blob :"$2" >actual &&
71 test_cmp expected actual
72 }
73
74 test_expect_success setup '
75 git config filter.rot13.smudge ./rot13.sh &&
76 git config filter.rot13.clean ./rot13.sh &&
77
78 {
79 echo "*.t filter=rot13"
80 echo "*.i ident"
81 } >.gitattributes &&
82
83 {
84 echo a b c d e f g h i j k l m
85 echo n o p q r s t u v w x y z
86 echo '\''$Id$'\''
87 } >test &&
88 cat test >test.t &&
89 cat test >test.o &&
90 cat test >test.i &&
91 git add test test.t test.i &&
92 rm -f test test.t test.i &&
93 git checkout -- test test.t test.i &&
94
95 echo "content-test2" >test2.o &&
96 echo "content-test3 - filename with special characters" >"test3 '\''sq'\'',\$x=.o"
97 '
98
99 script='s/^\$Id: \([0-9a-f]*\) \$/\1/p'
100
101 test_expect_success check '
102
103 test_cmp test.o test &&
104 test_cmp test.o test.t &&
105
106 # ident should be stripped in the repository
107 git diff --raw --exit-code :test :test.i &&
108 id=$(git rev-parse --verify :test) &&
109 embedded=$(sed -ne "$script" test.i) &&
110 test "z$id" = "z$embedded" &&
111
112 git cat-file blob :test.t >test.r &&
113
114 ./rot13.sh <test.o >test.t &&
115 test_cmp test.r test.t
116 '
117
118 # If an expanded ident ever gets into the repository, we want to make sure that
119 # it is collapsed before being expanded again on checkout
120 test_expect_success expanded_in_repo '
121 {
122 echo "File with expanded keywords"
123 echo "\$Id\$"
124 echo "\$Id:\$"
125 echo "\$Id: 0000000000000000000000000000000000000000 \$"
126 echo "\$Id: NoSpaceAtEnd\$"
127 echo "\$Id:NoSpaceAtFront \$"
128 echo "\$Id:NoSpaceAtEitherEnd\$"
129 echo "\$Id: NoTerminatingSymbol"
130 echo "\$Id: Foreign Commit With Spaces \$"
131 } >expanded-keywords.0 &&
132
133 {
134 cat expanded-keywords.0 &&
135 printf "\$Id: NoTerminatingSymbolAtEOF"
136 } >expanded-keywords &&
137 cat expanded-keywords >expanded-keywords-crlf &&
138 git add expanded-keywords expanded-keywords-crlf &&
139 git commit -m "File with keywords expanded" &&
140 id=$(git rev-parse --verify :expanded-keywords) &&
141
142 {
143 echo "File with expanded keywords"
144 echo "\$Id: $id \$"
145 echo "\$Id: $id \$"
146 echo "\$Id: $id \$"
147 echo "\$Id: $id \$"
148 echo "\$Id: $id \$"
149 echo "\$Id: $id \$"
150 echo "\$Id: NoTerminatingSymbol"
151 echo "\$Id: Foreign Commit With Spaces \$"
152 } >expected-output.0 &&
153 {
154 cat expected-output.0 &&
155 printf "\$Id: NoTerminatingSymbolAtEOF"
156 } >expected-output &&
157 {
158 append_cr <expected-output.0 &&
159 printf "\$Id: NoTerminatingSymbolAtEOF"
160 } >expected-output-crlf &&
161 {
162 echo "expanded-keywords ident"
163 echo "expanded-keywords-crlf ident text eol=crlf"
164 } >>.gitattributes &&
165
166 rm -f expanded-keywords expanded-keywords-crlf &&
167
168 git checkout -- expanded-keywords &&
169 test_cmp expected-output expanded-keywords &&
170
171 git checkout -- expanded-keywords-crlf &&
172 test_cmp expected-output-crlf expanded-keywords-crlf
173 '
174
175 # The use of %f in a filter definition is expanded to the path to
176 # the filename being smudged or cleaned. It must be shell escaped.
177 # First, set up some interesting file names and pet them in
178 # .gitattributes.
179 test_expect_success 'filter shell-escaped filenames' '
180 cat >argc.sh <<-EOF &&
181 #!$SHELL_PATH
182 cat >/dev/null
183 echo argc: \$# "\$@"
184 EOF
185 normal=name-no-magic &&
186 special="name with '\''sq'\'' and \$x" &&
187 echo some test text >"$normal" &&
188 echo some test text >"$special" &&
189 git add "$normal" "$special" &&
190 git commit -q -m "add files" &&
191 echo "name* filter=argc" >.gitattributes &&
192
193 # delete the files and check them out again, using a smudge filter
194 # that will count the args and echo the command-line back to us
195 test_config filter.argc.smudge "sh ./argc.sh %f" &&
196 rm "$normal" "$special" &&
197 git checkout -- "$normal" "$special" &&
198
199 # make sure argc.sh counted the right number of args
200 echo "argc: 1 $normal" >expect &&
201 test_cmp expect "$normal" &&
202 echo "argc: 1 $special" >expect &&
203 test_cmp expect "$special" &&
204
205 # do the same thing, but with more args in the filter expression
206 test_config filter.argc.smudge "sh ./argc.sh %f --my-extra-arg" &&
207 rm "$normal" "$special" &&
208 git checkout -- "$normal" "$special" &&
209
210 # make sure argc.sh counted the right number of args
211 echo "argc: 2 $normal --my-extra-arg" >expect &&
212 test_cmp expect "$normal" &&
213 echo "argc: 2 $special --my-extra-arg" >expect &&
214 test_cmp expect "$special" &&
215 :
216 '
217
218 test_expect_success 'required filter should filter data' '
219 test_config filter.required.smudge ./rot13.sh &&
220 test_config filter.required.clean ./rot13.sh &&
221 test_config filter.required.required true &&
222
223 echo "*.r filter=required" >.gitattributes &&
224
225 cat test.o >test.r &&
226 git add test.r &&
227
228 rm -f test.r &&
229 git checkout -- test.r &&
230 test_cmp test.o test.r &&
231
232 ./rot13.sh <test.o >expected &&
233 git cat-file blob :test.r >actual &&
234 test_cmp expected actual
235 '
236
237 test_expect_success 'required filter smudge failure' '
238 test_config filter.failsmudge.smudge false &&
239 test_config filter.failsmudge.clean cat &&
240 test_config filter.failsmudge.required true &&
241
242 echo "*.fs filter=failsmudge" >.gitattributes &&
243
244 echo test >test.fs &&
245 git add test.fs &&
246 rm -f test.fs &&
247 test_must_fail git checkout -- test.fs
248 '
249
250 test_expect_success 'required filter clean failure' '
251 test_config filter.failclean.smudge cat &&
252 test_config filter.failclean.clean false &&
253 test_config filter.failclean.required true &&
254
255 echo "*.fc filter=failclean" >.gitattributes &&
256
257 echo test >test.fc &&
258 test_must_fail git add test.fc
259 '
260
261 test_expect_success 'filtering large input to small output should use little memory' '
262 test_config filter.devnull.clean "cat >/dev/null" &&
263 test_config filter.devnull.required true &&
264 for i in $(test_seq 1 30); do printf "%1048576d" 1; done >30MB &&
265 echo "30MB filter=devnull" >.gitattributes &&
266 GIT_MMAP_LIMIT=1m GIT_ALLOC_LIMIT=1m git add 30MB
267 '
268
269 test_expect_success 'filter that does not read is fine' '
270 test-tool genrandom foo $((128 * 1024 + 1)) >big &&
271 echo "big filter=epipe" >.gitattributes &&
272 test_config filter.epipe.clean "echo xyzzy" &&
273 git add big &&
274 git cat-file blob :big >actual &&
275 echo xyzzy >expect &&
276 test_cmp expect actual
277 '
278
279 test_expect_success EXPENSIVE 'filter large file' '
280 test_config filter.largefile.smudge cat &&
281 test_config filter.largefile.clean cat &&
282 for i in $(test_seq 1 2048); do printf "%1048576d" 1; done >2GB &&
283 echo "2GB filter=largefile" >.gitattributes &&
284 git add 2GB 2>err &&
285 test_must_be_empty err &&
286 rm -f 2GB &&
287 git checkout -- 2GB 2>err &&
288 test_must_be_empty err
289 '
290
291 test_expect_success "filter: clean empty file" '
292 test_config filter.in-repo-header.clean "echo cleaned && cat" &&
293 test_config filter.in-repo-header.smudge "sed 1d" &&
294
295 echo "empty-in-worktree filter=in-repo-header" >>.gitattributes &&
296 >empty-in-worktree &&
297
298 echo cleaned >expected &&
299 git add empty-in-worktree &&
300 git show :empty-in-worktree >actual &&
301 test_cmp expected actual
302 '
303
304 test_expect_success "filter: smudge empty file" '
305 test_config filter.empty-in-repo.clean "cat >/dev/null" &&
306 test_config filter.empty-in-repo.smudge "echo smudged && cat" &&
307
308 echo "empty-in-repo filter=empty-in-repo" >>.gitattributes &&
309 echo dead data walking >empty-in-repo &&
310 git add empty-in-repo &&
311
312 echo smudged >expected &&
313 git checkout-index --prefix=filtered- empty-in-repo &&
314 test_cmp expected filtered-empty-in-repo
315 '
316
317 test_expect_success 'disable filter with empty override' '
318 test_config_global filter.disable.smudge false &&
319 test_config_global filter.disable.clean false &&
320 test_config filter.disable.smudge false &&
321 test_config filter.disable.clean false &&
322
323 echo "*.disable filter=disable" >.gitattributes &&
324
325 echo test >test.disable &&
326 git -c filter.disable.clean= add test.disable 2>err &&
327 test_must_be_empty err &&
328 rm -f test.disable &&
329 git -c filter.disable.smudge= checkout -- test.disable 2>err &&
330 test_must_be_empty err
331 '
332
333 test_expect_success 'diff does not reuse worktree files that need cleaning' '
334 test_config filter.counter.clean "echo . >>count; sed s/^/clean:/" &&
335 echo "file filter=counter" >.gitattributes &&
336 test_commit one file &&
337 test_commit two file &&
338
339 >count &&
340 git diff-tree -p HEAD &&
341 test_line_count = 0 count
342 '
343
344 test_expect_success PERL 'required process filter should filter data' '
345 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
346 test_config_global filter.protocol.required true &&
347 rm -rf repo &&
348 mkdir repo &&
349 (
350 cd repo &&
351 git init &&
352
353 echo "*.r filter=protocol" >.gitattributes &&
354 git add . &&
355 git commit -m "test commit 1" &&
356 git branch empty-branch &&
357
358 cp "$TEST_ROOT/test.o" test.r &&
359 cp "$TEST_ROOT/test2.o" test2.r &&
360 mkdir testsubdir &&
361 cp "$TEST_ROOT/test3 '\''sq'\'',\$x=.o" "testsubdir/test3 '\''sq'\'',\$x=.r" &&
362 >test4-empty.r &&
363
364 S=$(file_size test.r) &&
365 S2=$(file_size test2.r) &&
366 S3=$(file_size "testsubdir/test3 '\''sq'\'',\$x=.r") &&
367
368 filter_git add . &&
369 cat >expected.log <<-EOF &&
370 START
371 init handshake complete
372 IN: clean test.r $S [OK] -- OUT: $S . [OK]
373 IN: clean test2.r $S2 [OK] -- OUT: $S2 . [OK]
374 IN: clean test4-empty.r 0 [OK] -- OUT: 0 [OK]
375 IN: clean testsubdir/test3 '\''sq'\'',\$x=.r $S3 [OK] -- OUT: $S3 . [OK]
376 STOP
377 EOF
378 test_cmp_count expected.log debug.log &&
379
380 git commit -m "test commit 2" &&
381 rm -f test2.r "testsubdir/test3 '\''sq'\'',\$x=.r" &&
382
383 filter_git checkout --quiet --no-progress . &&
384 cat >expected.log <<-EOF &&
385 START
386 init handshake complete
387 IN: smudge test2.r $S2 [OK] -- OUT: $S2 . [OK]
388 IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $S3 [OK] -- OUT: $S3 . [OK]
389 STOP
390 EOF
391 test_cmp_exclude_clean expected.log debug.log &&
392
393 filter_git checkout --quiet --no-progress empty-branch &&
394 cat >expected.log <<-EOF &&
395 START
396 init handshake complete
397 IN: clean test.r $S [OK] -- OUT: $S . [OK]
398 STOP
399 EOF
400 test_cmp_exclude_clean expected.log debug.log &&
401
402 filter_git checkout --quiet --no-progress master &&
403 cat >expected.log <<-EOF &&
404 START
405 init handshake complete
406 IN: smudge test.r $S [OK] -- OUT: $S . [OK]
407 IN: smudge test2.r $S2 [OK] -- OUT: $S2 . [OK]
408 IN: smudge test4-empty.r 0 [OK] -- OUT: 0 [OK]
409 IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $S3 [OK] -- OUT: $S3 . [OK]
410 STOP
411 EOF
412 test_cmp_exclude_clean expected.log debug.log &&
413
414 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.r &&
415 test_cmp_committed_rot13 "$TEST_ROOT/test2.o" test2.r &&
416 test_cmp_committed_rot13 "$TEST_ROOT/test3 '\''sq'\'',\$x=.o" "testsubdir/test3 '\''sq'\'',\$x=.r"
417 )
418 '
419
420 test_expect_success PERL 'required process filter takes precedence' '
421 test_config_global filter.protocol.clean false &&
422 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean" &&
423 test_config_global filter.protocol.required true &&
424 rm -rf repo &&
425 mkdir repo &&
426 (
427 cd repo &&
428 git init &&
429
430 echo "*.r filter=protocol" >.gitattributes &&
431 cp "$TEST_ROOT/test.o" test.r &&
432 S=$(file_size test.r) &&
433
434 # Check that the process filter is invoked here
435 filter_git add . &&
436 cat >expected.log <<-EOF &&
437 START
438 init handshake complete
439 IN: clean test.r $S [OK] -- OUT: $S . [OK]
440 STOP
441 EOF
442 test_cmp_count expected.log debug.log
443 )
444 '
445
446 test_expect_success PERL 'required process filter should be used only for "clean" operation only' '
447 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean" &&
448 rm -rf repo &&
449 mkdir repo &&
450 (
451 cd repo &&
452 git init &&
453
454 echo "*.r filter=protocol" >.gitattributes &&
455 cp "$TEST_ROOT/test.o" test.r &&
456 S=$(file_size test.r) &&
457
458 filter_git add . &&
459 cat >expected.log <<-EOF &&
460 START
461 init handshake complete
462 IN: clean test.r $S [OK] -- OUT: $S . [OK]
463 STOP
464 EOF
465 test_cmp_count expected.log debug.log &&
466
467 rm test.r &&
468
469 filter_git checkout --quiet --no-progress . &&
470 # If the filter would be used for "smudge", too, we would see
471 # "IN: smudge test.r 57 [OK] -- OUT: 57 . [OK]" here
472 cat >expected.log <<-EOF &&
473 START
474 init handshake complete
475 STOP
476 EOF
477 test_cmp_exclude_clean expected.log debug.log
478 )
479 '
480
481 test_expect_success PERL 'required process filter should process multiple packets' '
482 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
483 test_config_global filter.protocol.required true &&
484
485 rm -rf repo &&
486 mkdir repo &&
487 (
488 cd repo &&
489 git init &&
490
491 # Generate data requiring 1, 2, 3 packets
492 S=65516 && # PKTLINE_DATA_MAXLEN -> Maximal size of a packet
493 generate_random_characters $(($S )) 1pkt_1__.file &&
494 generate_random_characters $(($S +1)) 2pkt_1+1.file &&
495 generate_random_characters $(($S*2-1)) 2pkt_2-1.file &&
496 generate_random_characters $(($S*2 )) 2pkt_2__.file &&
497 generate_random_characters $(($S*2+1)) 3pkt_2+1.file &&
498
499 for FILE in "$TEST_ROOT"/*.file
500 do
501 cp "$FILE" . &&
502 rot13.sh <"$FILE" >"$FILE.rot13"
503 done &&
504
505 echo "*.file filter=protocol" >.gitattributes &&
506 filter_git add *.file .gitattributes &&
507 cat >expected.log <<-EOF &&
508 START
509 init handshake complete
510 IN: clean 1pkt_1__.file $(($S )) [OK] -- OUT: $(($S )) . [OK]
511 IN: clean 2pkt_1+1.file $(($S +1)) [OK] -- OUT: $(($S +1)) .. [OK]
512 IN: clean 2pkt_2-1.file $(($S*2-1)) [OK] -- OUT: $(($S*2-1)) .. [OK]
513 IN: clean 2pkt_2__.file $(($S*2 )) [OK] -- OUT: $(($S*2 )) .. [OK]
514 IN: clean 3pkt_2+1.file $(($S*2+1)) [OK] -- OUT: $(($S*2+1)) ... [OK]
515 STOP
516 EOF
517 test_cmp_count expected.log debug.log &&
518
519 rm -f *.file &&
520
521 filter_git checkout --quiet --no-progress -- *.file &&
522 cat >expected.log <<-EOF &&
523 START
524 init handshake complete
525 IN: smudge 1pkt_1__.file $(($S )) [OK] -- OUT: $(($S )) . [OK]
526 IN: smudge 2pkt_1+1.file $(($S +1)) [OK] -- OUT: $(($S +1)) .. [OK]
527 IN: smudge 2pkt_2-1.file $(($S*2-1)) [OK] -- OUT: $(($S*2-1)) .. [OK]
528 IN: smudge 2pkt_2__.file $(($S*2 )) [OK] -- OUT: $(($S*2 )) .. [OK]
529 IN: smudge 3pkt_2+1.file $(($S*2+1)) [OK] -- OUT: $(($S*2+1)) ... [OK]
530 STOP
531 EOF
532 test_cmp_exclude_clean expected.log debug.log &&
533
534 for FILE in *.file
535 do
536 test_cmp_committed_rot13 "$TEST_ROOT/$FILE" $FILE
537 done
538 )
539 '
540
541 test_expect_success PERL 'required process filter with clean error should fail' '
542 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
543 test_config_global filter.protocol.required true &&
544 rm -rf repo &&
545 mkdir repo &&
546 (
547 cd repo &&
548 git init &&
549
550 echo "*.r filter=protocol" >.gitattributes &&
551
552 cp "$TEST_ROOT/test.o" test.r &&
553 echo "this is going to fail" >clean-write-fail.r &&
554 echo "content-test3-subdir" >test3.r &&
555
556 test_must_fail git add .
557 )
558 '
559
560 test_expect_success PERL 'process filter should restart after unexpected write failure' '
561 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
562 rm -rf repo &&
563 mkdir repo &&
564 (
565 cd repo &&
566 git init &&
567
568 echo "*.r filter=protocol" >.gitattributes &&
569
570 cp "$TEST_ROOT/test.o" test.r &&
571 cp "$TEST_ROOT/test2.o" test2.r &&
572 echo "this is going to fail" >smudge-write-fail.o &&
573 cp smudge-write-fail.o smudge-write-fail.r &&
574
575 S=$(file_size test.r) &&
576 S2=$(file_size test2.r) &&
577 SF=$(file_size smudge-write-fail.r) &&
578
579 git add . &&
580 rm -f *.r &&
581
582 rm -f debug.log &&
583 git checkout --quiet --no-progress . 2>git-stderr.log &&
584
585 grep "smudge write error at" git-stderr.log &&
586 test_i18ngrep "error: external filter" git-stderr.log &&
587
588 cat >expected.log <<-EOF &&
589 START
590 init handshake complete
591 IN: smudge smudge-write-fail.r $SF [OK] -- [WRITE FAIL]
592 START
593 init handshake complete
594 IN: smudge test.r $S [OK] -- OUT: $S . [OK]
595 IN: smudge test2.r $S2 [OK] -- OUT: $S2 . [OK]
596 STOP
597 EOF
598 test_cmp_exclude_clean expected.log debug.log &&
599
600 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.r &&
601 test_cmp_committed_rot13 "$TEST_ROOT/test2.o" test2.r &&
602
603 # Smudge failed
604 ! test_cmp smudge-write-fail.o smudge-write-fail.r &&
605 rot13.sh <smudge-write-fail.o >expected &&
606 git cat-file blob :smudge-write-fail.r >actual &&
607 test_cmp expected actual
608 )
609 '
610
611 test_expect_success PERL 'process filter should not be restarted if it signals an error' '
612 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
613 rm -rf repo &&
614 mkdir repo &&
615 (
616 cd repo &&
617 git init &&
618
619 echo "*.r filter=protocol" >.gitattributes &&
620
621 cp "$TEST_ROOT/test.o" test.r &&
622 cp "$TEST_ROOT/test2.o" test2.r &&
623 echo "this will cause an error" >error.o &&
624 cp error.o error.r &&
625
626 S=$(file_size test.r) &&
627 S2=$(file_size test2.r) &&
628 SE=$(file_size error.r) &&
629
630 git add . &&
631 rm -f *.r &&
632
633 filter_git checkout --quiet --no-progress . &&
634 cat >expected.log <<-EOF &&
635 START
636 init handshake complete
637 IN: smudge error.r $SE [OK] -- [ERROR]
638 IN: smudge test.r $S [OK] -- OUT: $S . [OK]
639 IN: smudge test2.r $S2 [OK] -- OUT: $S2 . [OK]
640 STOP
641 EOF
642 test_cmp_exclude_clean expected.log debug.log &&
643
644 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.r &&
645 test_cmp_committed_rot13 "$TEST_ROOT/test2.o" test2.r &&
646 test_cmp error.o error.r
647 )
648 '
649
650 test_expect_success PERL 'process filter abort stops processing of all further files' '
651 test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
652 rm -rf repo &&
653 mkdir repo &&
654 (
655 cd repo &&
656 git init &&
657
658 echo "*.r filter=protocol" >.gitattributes &&
659
660 cp "$TEST_ROOT/test.o" test.r &&
661 cp "$TEST_ROOT/test2.o" test2.r &&
662 echo "error this blob and all future blobs" >abort.o &&
663 cp abort.o abort.r &&
664
665 SA=$(file_size abort.r) &&
666
667 git add . &&
668 rm -f *.r &&
669
670 # Note: This test assumes that Git filters files in alphabetical
671 # order ("abort.r" before "test.r").
672 filter_git checkout --quiet --no-progress . &&
673 cat >expected.log <<-EOF &&
674 START
675 init handshake complete
676 IN: smudge abort.r $SA [OK] -- [ABORT]
677 STOP
678 EOF
679 test_cmp_exclude_clean expected.log debug.log &&
680
681 test_cmp "$TEST_ROOT/test.o" test.r &&
682 test_cmp "$TEST_ROOT/test2.o" test2.r &&
683 test_cmp abort.o abort.r
684 )
685 '
686
687 test_expect_success PERL 'invalid process filter must fail (and not hang!)' '
688 test_config_global filter.protocol.process cat &&
689 test_config_global filter.protocol.required true &&
690 rm -rf repo &&
691 mkdir repo &&
692 (
693 cd repo &&
694 git init &&
695
696 echo "*.r filter=protocol" >.gitattributes &&
697
698 cp "$TEST_ROOT/test.o" test.r &&
699 test_must_fail git add . 2>git-stderr.log &&
700 grep "expected git-filter-server" git-stderr.log
701 )
702 '
703
704 test_expect_success PERL 'delayed checkout in process filter' '
705 test_config_global filter.a.process "rot13-filter.pl a.log clean smudge delay" &&
706 test_config_global filter.a.required true &&
707 test_config_global filter.b.process "rot13-filter.pl b.log clean smudge delay" &&
708 test_config_global filter.b.required true &&
709
710 rm -rf repo &&
711 mkdir repo &&
712 (
713 cd repo &&
714 git init &&
715 echo "*.a filter=a" >.gitattributes &&
716 echo "*.b filter=b" >>.gitattributes &&
717 cp "$TEST_ROOT/test.o" test.a &&
718 cp "$TEST_ROOT/test.o" test-delay10.a &&
719 cp "$TEST_ROOT/test.o" test-delay11.a &&
720 cp "$TEST_ROOT/test.o" test-delay20.a &&
721 cp "$TEST_ROOT/test.o" test-delay10.b &&
722 git add . &&
723 git commit -m "test commit"
724 ) &&
725
726 S=$(file_size "$TEST_ROOT/test.o") &&
727 cat >a.exp <<-EOF &&
728 START
729 init handshake complete
730 IN: smudge test.a $S [OK] -- OUT: $S . [OK]
731 IN: smudge test-delay10.a $S [OK] -- [DELAYED]
732 IN: smudge test-delay11.a $S [OK] -- [DELAYED]
733 IN: smudge test-delay20.a $S [OK] -- [DELAYED]
734 IN: list_available_blobs test-delay10.a test-delay11.a [OK]
735 IN: smudge test-delay10.a 0 [OK] -- OUT: $S . [OK]
736 IN: smudge test-delay11.a 0 [OK] -- OUT: $S . [OK]
737 IN: list_available_blobs test-delay20.a [OK]
738 IN: smudge test-delay20.a 0 [OK] -- OUT: $S . [OK]
739 IN: list_available_blobs [OK]
740 STOP
741 EOF
742 cat >b.exp <<-EOF &&
743 START
744 init handshake complete
745 IN: smudge test-delay10.b $S [OK] -- [DELAYED]
746 IN: list_available_blobs test-delay10.b [OK]
747 IN: smudge test-delay10.b 0 [OK] -- OUT: $S . [OK]
748 IN: list_available_blobs [OK]
749 STOP
750 EOF
751
752 rm -rf repo-cloned &&
753 filter_git clone repo repo-cloned &&
754 test_cmp_count a.exp repo-cloned/a.log &&
755 test_cmp_count b.exp repo-cloned/b.log &&
756
757 (
758 cd repo-cloned &&
759 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.a &&
760 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.a &&
761 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay11.a &&
762 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay20.a &&
763 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.b &&
764
765 rm *.a *.b &&
766 filter_git checkout . &&
767 test_cmp_count ../a.exp a.log &&
768 test_cmp_count ../b.exp b.log &&
769
770 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.a &&
771 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.a &&
772 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay11.a &&
773 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay20.a &&
774 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.b
775 )
776 '
777
778 test_expect_success PERL 'missing file in delayed checkout' '
779 test_config_global filter.bug.process "rot13-filter.pl bug.log clean smudge delay" &&
780 test_config_global filter.bug.required true &&
781
782 rm -rf repo &&
783 mkdir repo &&
784 (
785 cd repo &&
786 git init &&
787 echo "*.a filter=bug" >.gitattributes &&
788 cp "$TEST_ROOT/test.o" missing-delay.a &&
789 git add . &&
790 git commit -m "test commit"
791 ) &&
792
793 rm -rf repo-cloned &&
794 test_must_fail git clone repo repo-cloned 2>git-stderr.log &&
795 cat git-stderr.log &&
796 grep "error: .missing-delay\.a. was not filtered properly" git-stderr.log
797 '
798
799 test_expect_success PERL 'invalid file in delayed checkout' '
800 test_config_global filter.bug.process "rot13-filter.pl bug.log clean smudge delay" &&
801 test_config_global filter.bug.required true &&
802
803 rm -rf repo &&
804 mkdir repo &&
805 (
806 cd repo &&
807 git init &&
808 echo "*.a filter=bug" >.gitattributes &&
809 cp "$TEST_ROOT/test.o" invalid-delay.a &&
810 cp "$TEST_ROOT/test.o" unfiltered &&
811 git add . &&
812 git commit -m "test commit"
813 ) &&
814
815 rm -rf repo-cloned &&
816 test_must_fail git clone repo repo-cloned 2>git-stderr.log &&
817 grep "error: external filter .* signaled that .unfiltered. is now available although it has not been delayed earlier" git-stderr.log
818 '
819
820 test_done