]>
Commit | Line | Data |
---|---|---|
60df071c LD |
1 | #!/bin/sh |
2 | ||
a64f732e | 3 | test_description='git p4 rcs keywords' |
60df071c LD |
4 | |
5 | . ./lib-git-p4.sh | |
6 | ||
7 | test_expect_success 'start p4d' ' | |
8 | start_p4d | |
9 | ' | |
10 | ||
11 | # | |
12 | # Make one file with keyword lines at the top, and | |
13 | # enough plain text to be able to test modifications | |
14 | # far away from the keywords. | |
15 | # | |
16 | test_expect_success 'init depot' ' | |
17 | ( | |
18 | cd "$cli" && | |
19 | cat <<-\EOF >filek && | |
20 | $Id$ | |
21 | /* $Revision$ */ | |
22 | # $Change$ | |
23 | line4 | |
24 | line5 | |
25 | line6 | |
26 | line7 | |
27 | line8 | |
28 | EOF | |
29 | cp filek fileko && | |
30 | sed -i "s/Revision/Revision: do not scrub me/" fileko | |
31 | cp fileko file_text && | |
32 | sed -i "s/Id/Id: do not scrub me/" file_text | |
33 | p4 add -t text+k filek && | |
34 | p4 submit -d "filek" && | |
35 | p4 add -t text+ko fileko && | |
36 | p4 submit -d "fileko" && | |
37 | p4 add -t text file_text && | |
38 | p4 submit -d "file_text" | |
39 | ) | |
40 | ' | |
41 | ||
42 | # | |
43 | # Generate these in a function to make it easy to use single quote marks. | |
44 | # | |
45 | write_scrub_scripts () { | |
46 | cat >"$TRASH_DIRECTORY/scrub_k.py" <<-\EOF && | |
47 | import re, sys | |
48 | sys.stdout.write(re.sub(r'(?i)\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$]*\$', r'$\1$', sys.stdin.read())) | |
49 | EOF | |
50 | cat >"$TRASH_DIRECTORY/scrub_ko.py" <<-\EOF | |
51 | import re, sys | |
52 | sys.stdout.write(re.sub(r'(?i)\$(Id|Header):[^$]*\$', r'$\1$', sys.stdin.read())) | |
53 | EOF | |
54 | } | |
55 | ||
56 | test_expect_success 'scrub scripts' ' | |
57 | write_scrub_scripts | |
58 | ' | |
59 | ||
60 | # | |
61 | # Compare $cli/file to its scrubbed version, should be different. | |
62 | # Compare scrubbed $cli/file to $git/file, should be same. | |
63 | # | |
64 | scrub_k_check () { | |
65 | file="$1" && | |
66 | scrub="$TRASH_DIRECTORY/$file" && | |
67 | "$PYTHON_PATH" "$TRASH_DIRECTORY/scrub_k.py" <"$git/$file" >"$scrub" && | |
68 | ! test_cmp "$cli/$file" "$scrub" && | |
69 | test_cmp "$git/$file" "$scrub" && | |
70 | rm "$scrub" | |
71 | } | |
72 | scrub_ko_check () { | |
73 | file="$1" && | |
74 | scrub="$TRASH_DIRECTORY/$file" && | |
75 | "$PYTHON_PATH" "$TRASH_DIRECTORY/scrub_ko.py" <"$git/$file" >"$scrub" && | |
76 | ! test_cmp "$cli/$file" "$scrub" && | |
77 | test_cmp "$git/$file" "$scrub" && | |
78 | rm "$scrub" | |
79 | } | |
80 | ||
81 | # | |
82 | # Modify far away from keywords. If no RCS lines show up | |
83 | # in the diff, there is no conflict. | |
84 | # | |
85 | test_expect_success 'edit far away from RCS lines' ' | |
86 | test_when_finished cleanup_git && | |
6ab1d76c | 87 | git p4 clone --dest="$git" //depot && |
60df071c LD |
88 | ( |
89 | cd "$git" && | |
90 | git config git-p4.skipSubmitEdit true && | |
91 | sed -i "s/^line7/line7 edit/" filek && | |
92 | git commit -m "filek line7 edit" filek && | |
6ab1d76c | 93 | git p4 submit && |
60df071c LD |
94 | scrub_k_check filek |
95 | ) | |
96 | ' | |
97 | ||
98 | # | |
99 | # Modify near the keywords. This will require RCS scrubbing. | |
100 | # | |
101 | test_expect_success 'edit near RCS lines' ' | |
102 | test_when_finished cleanup_git && | |
6ab1d76c | 103 | git p4 clone --dest="$git" //depot && |
60df071c LD |
104 | ( |
105 | cd "$git" && | |
106 | git config git-p4.skipSubmitEdit true && | |
107 | git config git-p4.attemptRCSCleanup true && | |
108 | sed -i "s/^line4/line4 edit/" filek && | |
109 | git commit -m "filek line4 edit" filek && | |
6ab1d76c | 110 | git p4 submit && |
60df071c LD |
111 | scrub_k_check filek |
112 | ) | |
113 | ' | |
114 | ||
115 | # | |
116 | # Modify the keywords themselves. This also will require RCS scrubbing. | |
117 | # | |
118 | test_expect_success 'edit keyword lines' ' | |
119 | test_when_finished cleanup_git && | |
6ab1d76c | 120 | git p4 clone --dest="$git" //depot && |
60df071c LD |
121 | ( |
122 | cd "$git" && | |
123 | git config git-p4.skipSubmitEdit true && | |
124 | git config git-p4.attemptRCSCleanup true && | |
125 | sed -i "/Revision/d" filek && | |
126 | git commit -m "filek remove Revision line" filek && | |
6ab1d76c | 127 | git p4 submit && |
60df071c LD |
128 | scrub_k_check filek |
129 | ) | |
130 | ' | |
131 | ||
132 | # | |
133 | # Scrubbing text+ko files should not alter all keywords, just Id, Header. | |
134 | # | |
135 | test_expect_success 'scrub ko files differently' ' | |
136 | test_when_finished cleanup_git && | |
6ab1d76c | 137 | git p4 clone --dest="$git" //depot && |
60df071c LD |
138 | ( |
139 | cd "$git" && | |
140 | git config git-p4.skipSubmitEdit true && | |
141 | git config git-p4.attemptRCSCleanup true && | |
142 | sed -i "s/^line4/line4 edit/" fileko && | |
143 | git commit -m "fileko line4 edit" fileko && | |
6ab1d76c | 144 | git p4 submit && |
60df071c LD |
145 | scrub_ko_check fileko && |
146 | ! scrub_k_check fileko | |
147 | ) | |
148 | ' | |
149 | ||
a64f732e | 150 | # hack; git p4 submit should do it on its own |
60df071c LD |
151 | test_expect_success 'cleanup after failure' ' |
152 | ( | |
153 | cd "$cli" && | |
154 | p4 revert ... | |
155 | ) | |
156 | ' | |
157 | ||
158 | # | |
159 | # Do not scrub anything but +k or +ko files. Sneak a change into | |
160 | # the cli file so that submit will get a conflict. Make sure that | |
161 | # scrubbing doesn't make a mess of things. | |
162 | # | |
163 | # Assumes that git-p4 exits leaving the p4 file open, with the | |
164 | # conflict-generating patch unapplied. | |
165 | # | |
166 | # This might happen only if the git repo is behind the p4 repo at | |
167 | # submit time, and there is a conflict. | |
168 | # | |
169 | test_expect_success 'do not scrub plain text' ' | |
170 | test_when_finished cleanup_git && | |
6ab1d76c | 171 | git p4 clone --dest="$git" //depot && |
60df071c LD |
172 | ( |
173 | cd "$git" && | |
174 | git config git-p4.skipSubmitEdit true && | |
175 | git config git-p4.attemptRCSCleanup true && | |
176 | sed -i "s/^line4/line4 edit/" file_text && | |
177 | git commit -m "file_text line4 edit" file_text && | |
178 | ( | |
179 | cd "$cli" && | |
180 | p4 open file_text && | |
181 | sed -i "s/^line5/line5 p4 edit/" file_text && | |
182 | p4 submit -d "file5 p4 edit" | |
183 | ) && | |
6ab1d76c | 184 | ! git p4 submit && |
60df071c LD |
185 | ( |
186 | # exepct something like: | |
187 | # file_text - file(s) not opened on this client | |
188 | # but not copious diff output | |
189 | cd "$cli" && | |
190 | p4 diff file_text >wc && | |
191 | test_line_count = 1 wc | |
192 | ) | |
193 | ) | |
194 | ' | |
195 | ||
a64f732e | 196 | # hack; git p4 submit should do it on its own |
60df071c LD |
197 | test_expect_success 'cleanup after failure 2' ' |
198 | ( | |
199 | cd "$cli" && | |
200 | p4 revert ... | |
201 | ) | |
202 | ' | |
203 | ||
204 | create_kw_file () { | |
205 | cat <<\EOF >"$1" | |
206 | /* A file | |
207 | Id: $Id$ | |
208 | Revision: $Revision$ | |
209 | File: $File$ | |
210 | */ | |
211 | int main(int argc, const char **argv) { | |
212 | return 0; | |
213 | } | |
214 | EOF | |
215 | } | |
216 | ||
217 | test_expect_success 'add kwfile' ' | |
218 | ( | |
219 | cd "$cli" && | |
220 | echo file1 >file1 && | |
221 | p4 add file1 && | |
222 | p4 submit -d "file 1" && | |
223 | create_kw_file kwfile1.c && | |
224 | p4 add kwfile1.c && | |
225 | p4 submit -d "Add rcw kw file" kwfile1.c | |
226 | ) | |
227 | ' | |
228 | ||
229 | p4_append_to_file () { | |
230 | f="$1" && | |
231 | p4 edit -t ktext "$f" && | |
232 | echo "/* $(date) */" >>"$f" && | |
233 | p4 submit -d "appending a line in p4" | |
234 | } | |
235 | ||
236 | # Create some files with RCS keywords. If they get modified | |
237 | # elsewhere then the version number gets bumped which then | |
238 | # results in a merge conflict if we touch the RCS kw lines, | |
239 | # even though the change itself would otherwise apply cleanly. | |
240 | test_expect_success 'cope with rcs keyword expansion damage' ' | |
241 | test_when_finished cleanup_git && | |
6ab1d76c | 242 | git p4 clone --dest="$git" //depot && |
60df071c LD |
243 | ( |
244 | cd "$git" && | |
245 | git config git-p4.skipSubmitEdit true && | |
246 | git config git-p4.attemptRCSCleanup true && | |
23bd0c99 | 247 | (cd "$cli" && p4_append_to_file kwfile1.c) && |
60df071c | 248 | old_lines=$(wc -l <kwfile1.c) && |
7096b648 | 249 | "$PERL_PATH" -n -i -e "print unless m/Revision:/" kwfile1.c && |
60df071c LD |
250 | new_lines=$(wc -l <kwfile1.c) && |
251 | test $new_lines = $(($old_lines - 1)) && | |
252 | ||
253 | git add kwfile1.c && | |
254 | git commit -m "Zap an RCS kw line" && | |
6ab1d76c PW |
255 | git p4 submit && |
256 | git p4 rebase && | |
60df071c | 257 | git diff p4/master && |
6ab1d76c | 258 | git p4 commit && |
60df071c LD |
259 | echo "try modifying in both" && |
260 | cd "$cli" && | |
261 | p4 edit kwfile1.c && | |
262 | echo "line from p4" >>kwfile1.c && | |
263 | p4 submit -d "add a line in p4" kwfile1.c && | |
264 | cd "$git" && | |
265 | echo "line from git at the top" | cat - kwfile1.c >kwfile1.c.new && | |
266 | mv kwfile1.c.new kwfile1.c && | |
267 | git commit -m "Add line in git at the top" kwfile1.c && | |
6ab1d76c PW |
268 | git p4 rebase && |
269 | git p4 submit | |
60df071c LD |
270 | ) |
271 | ' | |
272 | ||
273 | test_expect_success 'cope with rcs keyword file deletion' ' | |
274 | test_when_finished cleanup_git && | |
275 | ( | |
276 | cd "$cli" && | |
277 | echo "\$Revision\$" >kwdelfile.c && | |
278 | p4 add -t ktext kwdelfile.c && | |
279 | p4 submit -d "Add file to be deleted" && | |
280 | cat kwdelfile.c && | |
281 | grep 1 kwdelfile.c | |
282 | ) && | |
6ab1d76c | 283 | git p4 clone --dest="$git" //depot && |
60df071c LD |
284 | ( |
285 | cd "$git" && | |
286 | grep Revision kwdelfile.c && | |
287 | git rm -f kwdelfile.c && | |
288 | git commit -m "Delete a file containing RCS keywords" && | |
289 | git config git-p4.skipSubmitEdit true && | |
290 | git config git-p4.attemptRCSCleanup true && | |
6ab1d76c | 291 | git p4 submit |
60df071c LD |
292 | ) && |
293 | ( | |
294 | cd "$cli" && | |
295 | p4 sync && | |
296 | ! test -f kwdelfile.c | |
297 | ) | |
298 | ' | |
299 | ||
300 | # If you add keywords in git of the form $Header$ then everything should | |
301 | # work fine without any special handling. | |
302 | test_expect_success 'Add keywords in git which match the default p4 values' ' | |
303 | test_when_finished cleanup_git && | |
6ab1d76c | 304 | git p4 clone --dest="$git" //depot && |
60df071c LD |
305 | ( |
306 | cd "$git" && | |
307 | echo "NewKW: \$Revision\$" >>kwfile1.c && | |
308 | git add kwfile1.c && | |
309 | git commit -m "Adding RCS keywords in git" && | |
310 | git config git-p4.skipSubmitEdit true && | |
311 | git config git-p4.attemptRCSCleanup true && | |
6ab1d76c | 312 | git p4 submit |
60df071c LD |
313 | ) && |
314 | ( | |
315 | cd "$cli" && | |
316 | p4 sync && | |
317 | test -f kwfile1.c && | |
318 | grep "NewKW.*Revision.*[0-9]" kwfile1.c | |
319 | ||
320 | ) | |
321 | ' | |
322 | ||
323 | # If you add keywords in git of the form $Header:#1$ then things will fail | |
324 | # unless git-p4 takes steps to scrub the *git* commit. | |
325 | # | |
326 | test_expect_failure 'Add keywords in git which do not match the default p4 values' ' | |
327 | test_when_finished cleanup_git && | |
6ab1d76c | 328 | git p4 clone --dest="$git" //depot && |
60df071c LD |
329 | ( |
330 | cd "$git" && | |
331 | echo "NewKW2: \$Revision:1\$" >>kwfile1.c && | |
332 | git add kwfile1.c && | |
333 | git commit -m "Adding RCS keywords in git" && | |
334 | git config git-p4.skipSubmitEdit true && | |
335 | git config git-p4.attemptRCSCleanup true && | |
6ab1d76c | 336 | git p4 submit |
60df071c LD |
337 | ) && |
338 | ( | |
339 | cd "$cli" && | |
340 | p4 sync && | |
341 | grep "NewKW2.*Revision.*[0-9]" kwfile1.c | |
342 | ||
343 | ) | |
344 | ' | |
345 | ||
346 | # Check that the existing merge conflict handling still works. | |
347 | # Modify kwfile1.c in git, and delete in p4. We should be able | |
348 | # to skip the git commit. | |
349 | # | |
350 | test_expect_success 'merge conflict handling still works' ' | |
351 | test_when_finished cleanup_git && | |
352 | ( | |
353 | cd "$cli" && | |
354 | echo "Hello:\$Id\$" >merge2.c && | |
355 | echo "World" >>merge2.c && | |
356 | p4 add -t ktext merge2.c && | |
357 | p4 submit -d "add merge test file" | |
358 | ) && | |
6ab1d76c | 359 | git p4 clone --dest="$git" //depot && |
60df071c LD |
360 | ( |
361 | cd "$git" && | |
362 | sed -e "/Hello/d" merge2.c >merge2.c.tmp && | |
363 | mv merge2.c.tmp merge2.c && | |
364 | git add merge2.c && | |
365 | git commit -m "Modifying merge2.c" | |
366 | ) && | |
367 | ( | |
368 | cd "$cli" && | |
369 | p4 delete merge2.c && | |
370 | p4 submit -d "remove merge test file" | |
371 | ) && | |
372 | ( | |
373 | cd "$git" && | |
374 | test -f merge2.c && | |
375 | git config git-p4.skipSubmitEdit true && | |
376 | git config git-p4.attemptRCSCleanup true && | |
6ab1d76c | 377 | !(echo "s" | git p4 submit) && |
60df071c LD |
378 | git rebase --skip && |
379 | ! test -f merge2.c | |
380 | ) | |
381 | ' | |
382 | ||
383 | ||
384 | test_expect_success 'kill p4d' ' | |
385 | kill_p4d | |
386 | ' | |
387 | ||
388 | test_done |