read-cache: delete unused hashing methods
[git] / t / t2082-parallel-checkout-attributes.sh
1 #!/bin/sh
2
3 test_description='parallel-checkout: attributes
4
5 Verify that parallel-checkout correctly creates files that require
6 conversions, as specified in .gitattributes. The main point here is
7 to check that the conv_attr data is correctly sent to the workers
8 and that it contains sufficient information to smudge files
9 properly (without access to the index or attribute stack).
10 '
11
12 TEST_NO_CREATE_REPO=1
13 . ./test-lib.sh
14 . "$TEST_DIRECTORY/lib-parallel-checkout.sh"
15 . "$TEST_DIRECTORY/lib-encoding.sh"
16
17 test_expect_success 'parallel-checkout with ident' '
18         set_checkout_config 2 0 &&
19         git init ident &&
20         (
21                 cd ident &&
22                 echo "A ident" >.gitattributes &&
23                 echo "\$Id\$" >A &&
24                 echo "\$Id\$" >B &&
25                 git add -A &&
26                 git commit -m id &&
27
28                 rm A B &&
29                 test_checkout_workers 2 git reset --hard &&
30                 hexsz=$(test_oid hexsz) &&
31                 grep -E "\\\$Id: [0-9a-f]{$hexsz} \\\$" A &&
32                 grep "\\\$Id\\\$" B
33         )
34 '
35
36 test_expect_success 'parallel-checkout with re-encoding' '
37         set_checkout_config 2 0 &&
38         git init encoding &&
39         (
40                 cd encoding &&
41                 echo text >utf8-text &&
42                 write_utf16 <utf8-text >utf16-text &&
43
44                 echo "A working-tree-encoding=UTF-16" >.gitattributes &&
45                 cp utf16-text A &&
46                 cp utf8-text B &&
47                 git add A B .gitattributes &&
48                 git commit -m encoding &&
49
50                 # Check that A is stored in UTF-8
51                 git cat-file -p :A >A.internal &&
52                 test_cmp_bin utf8-text A.internal &&
53
54                 rm A B &&
55                 test_checkout_workers 2 git checkout A B &&
56
57                 # Check that A (and only A) is re-encoded during checkout
58                 test_cmp_bin utf16-text A &&
59                 test_cmp_bin utf8-text B
60         )
61 '
62
63 test_expect_success 'parallel-checkout with eol conversions' '
64         set_checkout_config 2 0 &&
65         git init eol &&
66         (
67                 cd eol &&
68                 printf "multi\r\nline\r\ntext" >crlf-text &&
69                 printf "multi\nline\ntext" >lf-text &&
70
71                 git config core.autocrlf false &&
72                 echo "A eol=crlf" >.gitattributes &&
73                 cp crlf-text A &&
74                 cp lf-text B &&
75                 git add A B .gitattributes &&
76                 git commit -m eol &&
77
78                 # Check that A is stored with LF format
79                 git cat-file -p :A >A.internal &&
80                 test_cmp_bin lf-text A.internal &&
81
82                 rm A B &&
83                 test_checkout_workers 2 git checkout A B &&
84
85                 # Check that A (and only A) is converted to CRLF during checkout
86                 test_cmp_bin crlf-text A &&
87                 test_cmp_bin lf-text B
88         )
89 '
90
91 # Entries that require an external filter are not eligible for parallel
92 # checkout. Check that both the parallel-eligible and non-eligible entries are
93 # properly writen in a single checkout operation.
94 #
95 test_expect_success 'parallel-checkout and external filter' '
96         set_checkout_config 2 0 &&
97         git init filter &&
98         (
99                 cd filter &&
100                 write_script <<-\EOF rot13.sh &&
101                 tr \
102                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" \
103                   "nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM"
104                 EOF
105
106                 git config filter.rot13.clean "\"$(pwd)/rot13.sh\"" &&
107                 git config filter.rot13.smudge "\"$(pwd)/rot13.sh\"" &&
108                 git config filter.rot13.required true &&
109
110                 echo abcd >original &&
111                 echo nopq >rot13 &&
112
113                 echo "A filter=rot13" >.gitattributes &&
114                 cp original A &&
115                 cp original B &&
116                 cp original C &&
117                 git add A B C .gitattributes &&
118                 git commit -m filter &&
119
120                 # Check that A (and only A) was cleaned
121                 git cat-file -p :A >A.internal &&
122                 test_cmp rot13 A.internal &&
123                 git cat-file -p :B >B.internal &&
124                 test_cmp original B.internal &&
125                 git cat-file -p :C >C.internal &&
126                 test_cmp original C.internal &&
127
128                 rm A B C *.internal &&
129                 test_checkout_workers 2 git checkout A B C &&
130
131                 # Check that A (and only A) was smudged during checkout
132                 test_cmp original A &&
133                 test_cmp original B &&
134                 test_cmp original C
135         )
136 '
137
138 # The delayed queue is independent from the parallel queue, and they should be
139 # able to work together in the same checkout process.
140 #
141 test_expect_success PERL 'parallel-checkout and delayed checkout' '
142         write_script rot13-filter.pl "$PERL_PATH" \
143                 <"$TEST_DIRECTORY"/t0021/rot13-filter.pl &&
144
145         test_config_global filter.delay.process \
146                 "\"$(pwd)/rot13-filter.pl\" --always-delay \"$(pwd)/delayed.log\" clean smudge delay" &&
147         test_config_global filter.delay.required true &&
148
149         echo "abcd" >original &&
150         echo "nopq" >rot13 &&
151
152         git init delayed &&
153         (
154                 cd delayed &&
155                 echo "*.d filter=delay" >.gitattributes &&
156                 cp ../original W.d &&
157                 cp ../original X.d &&
158                 cp ../original Y &&
159                 cp ../original Z &&
160                 git add -A &&
161                 git commit -m delayed &&
162
163                 # Check that *.d files were cleaned
164                 git cat-file -p :W.d >W.d.internal &&
165                 test_cmp W.d.internal ../rot13 &&
166                 git cat-file -p :X.d >X.d.internal &&
167                 test_cmp X.d.internal ../rot13 &&
168                 git cat-file -p :Y >Y.internal &&
169                 test_cmp Y.internal ../original &&
170                 git cat-file -p :Z >Z.internal &&
171                 test_cmp Z.internal ../original &&
172
173                 rm *
174         ) &&
175
176         set_checkout_config 2 0 &&
177         test_checkout_workers 2 git -C delayed checkout -f &&
178         verify_checkout delayed &&
179
180         # Check that the *.d files got to the delay queue and were filtered
181         grep "smudge W.d .* \[DELAYED\]" delayed.log &&
182         grep "smudge X.d .* \[DELAYED\]" delayed.log &&
183         test_cmp delayed/W.d original &&
184         test_cmp delayed/X.d original &&
185
186         # Check that the parallel-eligible entries went to the right queue and
187         # were not filtered
188         ! grep "smudge Y .* \[DELAYED\]" delayed.log &&
189         ! grep "smudge Z .* \[DELAYED\]" delayed.log &&
190         test_cmp delayed/Y original &&
191         test_cmp delayed/Z original
192 '
193
194 test_done