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