]>
Commit | Line | Data |
---|---|---|
6de08ae6 SP |
1 | #!/bin/sh |
2 | # | |
3 | # Copyright (c) 2006 Shawn Pearce | |
4 | # | |
5 | ||
5be60078 | 6 | test_description='Test git update-ref and basic ref logging' |
6de08ae6 SP |
7 | . ./test-lib.sh |
8 | ||
3749fde5 | 9 | Z=$_z40 |
c3b0dec5 LT |
10 | |
11 | test_expect_success setup ' | |
12 | ||
13 | for name in A B C D E F | |
14 | do | |
15 | test_tick && | |
16 | T=$(git write-tree) && | |
17 | sha1=$(echo $name | git commit-tree $T) && | |
18 | eval $name=$sha1 | |
19 | done | |
20 | ||
21 | ' | |
22 | ||
6de08ae6 | 23 | m=refs/heads/master |
818f477c SP |
24 | n_dir=refs/heads/gu |
25 | n=$n_dir/fixes | |
6de08ae6 SP |
26 | |
27 | test_expect_success \ | |
28 | "create $m" \ | |
5be60078 | 29 | "git update-ref $m $A && |
8aac4b45 | 30 | test $A"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
31 | test_expect_success \ |
32 | "create $m" \ | |
5be60078 | 33 | "git update-ref $m $B $A && |
8aac4b45 | 34 | test $B"' = $(cat .git/'"$m"')' |
40672a19 KW |
35 | test_expect_success "fail to delete $m with stale ref" ' |
36 | test_must_fail git update-ref -d $m $A && | |
37 | test $B = "$(cat .git/$m)" | |
38 | ' | |
39 | test_expect_success "delete $m" ' | |
40 | git update-ref -d $m $B && | |
41 | ! test -f .git/$m | |
42 | ' | |
6de08ae6 SP |
43 | rm -f .git/$m |
44 | ||
3fe8dce6 KW |
45 | test_expect_success "delete $m without oldvalue verification" " |
46 | git update-ref $m $A && | |
47 | test $A = \$(cat .git/$m) && | |
48 | git update-ref -d $m && | |
49 | ! test -f .git/$m | |
50 | " | |
51 | rm -f .git/$m | |
52 | ||
818f477c SP |
53 | test_expect_success \ |
54 | "fail to create $n" \ | |
598f0877 JN |
55 | "touch .git/$n_dir && |
56 | test_must_fail git update-ref $n $A >out 2>err" | |
818f477c SP |
57 | rm -f .git/$n_dir out err |
58 | ||
6de08ae6 SP |
59 | test_expect_success \ |
60 | "create $m (by HEAD)" \ | |
5be60078 | 61 | "git update-ref HEAD $A && |
8aac4b45 | 62 | test $A"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
63 | test_expect_success \ |
64 | "create $m (by HEAD)" \ | |
5be60078 | 65 | "git update-ref HEAD $B $A && |
8aac4b45 | 66 | test $B"' = $(cat .git/'"$m"')' |
40672a19 KW |
67 | test_expect_success "fail to delete $m (by HEAD) with stale ref" ' |
68 | test_must_fail git update-ref -d HEAD $A && | |
69 | test $B = $(cat .git/$m) | |
70 | ' | |
71 | test_expect_success "delete $m (by HEAD)" ' | |
72 | git update-ref -d HEAD $B && | |
73 | ! test -f .git/$m | |
74 | ' | |
6de08ae6 SP |
75 | rm -f .git/$m |
76 | ||
75c96e05 JH |
77 | test_expect_success \ |
78 | "create $m (by HEAD)" \ | |
79 | "git update-ref HEAD $A && | |
80 | test $A"' = $(cat .git/'"$m"')' | |
81 | test_expect_success \ | |
82 | "pack refs" \ | |
83 | "git pack-refs --all" | |
84 | test_expect_success \ | |
85 | "move $m (by HEAD)" \ | |
86 | "git update-ref HEAD $B $A && | |
87 | test $B"' = $(cat .git/'"$m"')' | |
b274a714 | 88 | test_expect_success "delete $m (by HEAD) should remove both packed and loose $m" ' |
75c96e05 JH |
89 | git update-ref -d HEAD $B && |
90 | ! grep "$m" .git/packed-refs && | |
91 | ! test -f .git/$m | |
92 | ' | |
93 | rm -f .git/$m | |
94 | ||
569740bd MV |
95 | cp -f .git/HEAD .git/HEAD.orig |
96 | test_expect_success "delete symref without dereference" ' | |
97 | git update-ref --no-deref -d HEAD && | |
98 | ! test -f .git/HEAD | |
99 | ' | |
100 | cp -f .git/HEAD.orig .git/HEAD | |
101 | ||
045a476f MV |
102 | test_expect_success "delete symref without dereference when the referred ref is packed" ' |
103 | echo foo >foo.c && | |
104 | git add foo.c && | |
105 | git commit -m foo && | |
106 | git pack-refs --all && | |
107 | git update-ref --no-deref -d HEAD && | |
108 | ! test -f .git/HEAD | |
109 | ' | |
110 | cp -f .git/HEAD.orig .git/HEAD | |
111 | git update-ref -d $m | |
112 | ||
41ac414e | 113 | test_expect_success '(not) create HEAD with old sha1' " |
d492b31c | 114 | test_must_fail git update-ref HEAD $A $B |
41ac414e JH |
115 | " |
116 | test_expect_success "(not) prior created .git/$m" " | |
117 | ! test -f .git/$m | |
118 | " | |
6de08ae6 SP |
119 | rm -f .git/$m |
120 | ||
121 | test_expect_success \ | |
122 | "create HEAD" \ | |
5be60078 | 123 | "git update-ref HEAD $A" |
41ac414e | 124 | test_expect_success '(not) change HEAD with wrong SHA1' " |
d492b31c | 125 | test_must_fail git update-ref HEAD $B $Z |
41ac414e JH |
126 | " |
127 | test_expect_success "(not) changed .git/$m" " | |
128 | ! test $B"' = $(cat .git/'"$m"') | |
129 | ' | |
6de08ae6 SP |
130 | rm -f .git/$m |
131 | ||
0bee5918 SP |
132 | : a repository with working tree always has reflog these days... |
133 | : >.git/logs/refs/heads/master | |
6de08ae6 SP |
134 | test_expect_success \ |
135 | "create $m (logged by touch)" \ | |
136 | 'GIT_COMMITTER_DATE="2005-05-26 23:30" \ | |
5be60078 | 137 | git update-ref HEAD '"$A"' -m "Initial Creation" && |
8aac4b45 | 138 | test '"$A"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
139 | test_expect_success \ |
140 | "update $m (logged by touch)" \ | |
141 | 'GIT_COMMITTER_DATE="2005-05-26 23:31" \ | |
5be60078 | 142 | git update-ref HEAD'" $B $A "'-m "Switch" && |
8aac4b45 | 143 | test '"$B"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
144 | test_expect_success \ |
145 | "set $m (logged by touch)" \ | |
146 | 'GIT_COMMITTER_DATE="2005-05-26 23:41" \ | |
5be60078 | 147 | git update-ref HEAD'" $A && |
8aac4b45 | 148 | test $A"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
149 | |
150 | cat >expect <<EOF | |
151 | $Z $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150200 +0000 Initial Creation | |
152 | $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150260 +0000 Switch | |
153 | $B $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150860 +0000 | |
154 | EOF | |
155 | test_expect_success \ | |
156 | "verifying $m's log" \ | |
188c3827 | 157 | "test_cmp expect .git/logs/$m" |
6de08ae6 SP |
158 | rm -rf .git/$m .git/logs expect |
159 | ||
160 | test_expect_success \ | |
161 | 'enable core.logAllRefUpdates' \ | |
5be60078 JH |
162 | 'git config core.logAllRefUpdates true && |
163 | test true = $(git config --bool --get core.logAllRefUpdates)' | |
6de08ae6 SP |
164 | |
165 | test_expect_success \ | |
166 | "create $m (logged by config)" \ | |
167 | 'GIT_COMMITTER_DATE="2005-05-26 23:32" \ | |
5be60078 | 168 | git update-ref HEAD'" $A "'-m "Initial Creation" && |
8aac4b45 | 169 | test '"$A"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
170 | test_expect_success \ |
171 | "update $m (logged by config)" \ | |
172 | 'GIT_COMMITTER_DATE="2005-05-26 23:33" \ | |
5be60078 | 173 | git update-ref HEAD'" $B $A "'-m "Switch" && |
8aac4b45 | 174 | test '"$B"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
175 | test_expect_success \ |
176 | "set $m (logged by config)" \ | |
177 | 'GIT_COMMITTER_DATE="2005-05-26 23:43" \ | |
5be60078 | 178 | git update-ref HEAD '"$A && |
8aac4b45 | 179 | test $A"' = $(cat .git/'"$m"')' |
6de08ae6 SP |
180 | |
181 | cat >expect <<EOF | |
182 | $Z $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150320 +0000 Initial Creation | |
183 | $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150380 +0000 Switch | |
184 | $B $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150980 +0000 | |
185 | EOF | |
186 | test_expect_success \ | |
187 | "verifying $m's log" \ | |
188c3827 | 188 | 'test_cmp expect .git/logs/$m' |
6de08ae6 SP |
189 | rm -f .git/$m .git/logs/$m expect |
190 | ||
5be60078 | 191 | git update-ref $m $D |
e5229042 | 192 | cat >.git/logs/$m <<EOF |
d1a4489a JK |
193 | 0000000000000000000000000000000000000000 $C $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150320 -0500 |
194 | $C $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150350 -0500 | |
e5229042 SP |
195 | $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150380 -0500 |
196 | $F $Z $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150680 -0500 | |
197 | $Z $E $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150980 -0500 | |
198 | EOF | |
199 | ||
200 | ed="Thu, 26 May 2005 18:32:00 -0500" | |
201 | gd="Thu, 26 May 2005 18:33:00 -0500" | |
202 | ld="Thu, 26 May 2005 18:43:00 -0500" | |
203 | test_expect_success \ | |
cce91a2c | 204 | 'Query "master@{May 25 2005}" (before history)' \ |
2dec68cf | 205 | 'rm -f o e && |
5be60078 | 206 | git rev-parse --verify "master@{May 25 2005}" >o 2>e && |
8aac4b45 | 207 | test '"$C"' = $(cat o) && |
16d7cc90 | 208 | test "warning: Log for '\'master\'' only goes back to $ed." = "$(cat e)"' |
e5229042 | 209 | test_expect_success \ |
cce91a2c | 210 | "Query master@{2005-05-25} (before history)" \ |
2dec68cf | 211 | 'rm -f o e && |
5be60078 | 212 | git rev-parse --verify master@{2005-05-25} >o 2>e && |
8aac4b45 | 213 | test '"$C"' = $(cat o) && |
16d7cc90 | 214 | echo test "warning: Log for '\'master\'' only goes back to $ed." = "$(cat e)"' |
e5229042 | 215 | test_expect_success \ |
cce91a2c | 216 | 'Query "master@{May 26 2005 23:31:59}" (1 second before history)' \ |
2dec68cf | 217 | 'rm -f o e && |
5be60078 | 218 | git rev-parse --verify "master@{May 26 2005 23:31:59}" >o 2>e && |
8aac4b45 | 219 | test '"$C"' = $(cat o) && |
16d7cc90 | 220 | test "warning: Log for '\''master'\'' only goes back to $ed." = "$(cat e)"' |
e5229042 | 221 | test_expect_success \ |
cce91a2c | 222 | 'Query "master@{May 26 2005 23:32:00}" (exactly history start)' \ |
2dec68cf | 223 | 'rm -f o e && |
5be60078 | 224 | git rev-parse --verify "master@{May 26 2005 23:32:00}" >o 2>e && |
d1a4489a JK |
225 | test '"$C"' = $(cat o) && |
226 | test "" = "$(cat e)"' | |
227 | test_expect_success \ | |
228 | 'Query "master@{May 26 2005 23:32:30}" (first non-creation change)' \ | |
2dec68cf | 229 | 'rm -f o e && |
d1a4489a | 230 | git rev-parse --verify "master@{May 26 2005 23:32:30}" >o 2>e && |
8aac4b45 | 231 | test '"$A"' = $(cat o) && |
e5229042 SP |
232 | test "" = "$(cat e)"' |
233 | test_expect_success \ | |
cce91a2c | 234 | 'Query "master@{2005-05-26 23:33:01}" (middle of history with gap)' \ |
2dec68cf | 235 | 'rm -f o e && |
5be60078 | 236 | git rev-parse --verify "master@{2005-05-26 23:33:01}" >o 2>e && |
8aac4b45 JH |
237 | test '"$B"' = $(cat o) && |
238 | test "warning: Log .git/logs/'"$m has gap after $gd"'." = "$(cat e)"' | |
e5229042 | 239 | test_expect_success \ |
cce91a2c | 240 | 'Query "master@{2005-05-26 23:38:00}" (middle of history)' \ |
2dec68cf | 241 | 'rm -f o e && |
5be60078 | 242 | git rev-parse --verify "master@{2005-05-26 23:38:00}" >o 2>e && |
8aac4b45 | 243 | test '"$Z"' = $(cat o) && |
e5229042 SP |
244 | test "" = "$(cat e)"' |
245 | test_expect_success \ | |
cce91a2c | 246 | 'Query "master@{2005-05-26 23:43:00}" (exact end of history)' \ |
2dec68cf | 247 | 'rm -f o e && |
5be60078 | 248 | git rev-parse --verify "master@{2005-05-26 23:43:00}" >o 2>e && |
8aac4b45 | 249 | test '"$E"' = $(cat o) && |
e5229042 SP |
250 | test "" = "$(cat e)"' |
251 | test_expect_success \ | |
cce91a2c | 252 | 'Query "master@{2005-05-28}" (past end of history)' \ |
2dec68cf | 253 | 'rm -f o e && |
5be60078 | 254 | git rev-parse --verify "master@{2005-05-28}" >o 2>e && |
8aac4b45 JH |
255 | test '"$D"' = $(cat o) && |
256 | test "warning: Log .git/logs/'"$m unexpectedly ended on $ld"'." = "$(cat e)"' | |
e5229042 | 257 | |
cce91a2c SP |
258 | |
259 | rm -f .git/$m .git/logs/$m expect | |
260 | ||
261 | test_expect_success \ | |
262 | 'creating initial files' \ | |
9c7466fa | 263 | 'echo TEST >F && |
5be60078 | 264 | git add F && |
9c7466fa | 265 | GIT_AUTHOR_DATE="2005-05-26 23:30" \ |
0cb0e143 | 266 | GIT_COMMITTER_DATE="2005-05-26 23:30" git commit -m add -a && |
2dec68cf | 267 | h_TEST=$(git rev-parse --verify HEAD) && |
9c7466fa SP |
268 | echo The other day this did not work. >M && |
269 | echo And then Bob told me how to fix it. >>M && | |
270 | echo OTHER >F && | |
271 | GIT_AUTHOR_DATE="2005-05-26 23:41" \ | |
0cb0e143 | 272 | GIT_COMMITTER_DATE="2005-05-26 23:41" git commit -F M -a && |
5be60078 | 273 | h_OTHER=$(git rev-parse --verify HEAD) && |
a3a733e6 | 274 | GIT_AUTHOR_DATE="2005-05-26 23:44" \ |
0cb0e143 | 275 | GIT_COMMITTER_DATE="2005-05-26 23:44" git commit --amend && |
5be60078 | 276 | h_FIXED=$(git rev-parse --verify HEAD) && |
a3a733e6 SP |
277 | echo Merged initial commit and a later commit. >M && |
278 | echo $h_TEST >.git/MERGE_HEAD && | |
279 | GIT_AUTHOR_DATE="2005-05-26 23:45" \ | |
0cb0e143 | 280 | GIT_COMMITTER_DATE="2005-05-26 23:45" git commit -F M && |
d9c8344b | 281 | h_MERGED=$(git rev-parse --verify HEAD) && |
9c7466fa SP |
282 | rm -f M' |
283 | ||
284 | cat >expect <<EOF | |
a3a733e6 | 285 | $Z $h_TEST $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150200 +0000 commit (initial): add |
9c7466fa | 286 | $h_TEST $h_OTHER $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150860 +0000 commit: The other day this did not work. |
a3a733e6 SP |
287 | $h_OTHER $h_FIXED $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117151040 +0000 commit (amend): The other day this did not work. |
288 | $h_FIXED $h_MERGED $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117151100 +0000 commit (merge): Merged initial commit and a later commit. | |
9c7466fa SP |
289 | EOF |
290 | test_expect_success \ | |
0cb0e143 | 291 | 'git commit logged updates' \ |
188c3827 | 292 | "test_cmp expect .git/logs/$m" |
a3a733e6 | 293 | unset h_TEST h_OTHER h_FIXED h_MERGED |
cce91a2c SP |
294 | |
295 | test_expect_success \ | |
5be60078 JH |
296 | 'git cat-file blob master:F (expect OTHER)' \ |
297 | 'test OTHER = $(git cat-file blob master:F)' | |
cce91a2c | 298 | test_expect_success \ |
5be60078 JH |
299 | 'git cat-file blob master@{2005-05-26 23:30}:F (expect TEST)' \ |
300 | 'test TEST = $(git cat-file blob "master@{2005-05-26 23:30}:F")' | |
cce91a2c | 301 | test_expect_success \ |
5be60078 JH |
302 | 'git cat-file blob master@{2005-05-26 23:42}:F (expect OTHER)' \ |
303 | 'test OTHER = $(git cat-file blob "master@{2005-05-26 23:42}:F")' | |
cce91a2c | 304 | |
c6268bc0 BK |
305 | a=refs/heads/a |
306 | b=refs/heads/b | |
307 | c=refs/heads/c | |
308 | E='""' | |
309 | F='%s\0' | |
310 | pws='path with space' | |
311 | ||
312 | test_expect_success 'stdin test setup' ' | |
313 | echo "$pws" >"$pws" && | |
314 | git add -- "$pws" && | |
315 | git commit -m "$pws" | |
316 | ' | |
317 | ||
318 | test_expect_success '-z fails without --stdin' ' | |
319 | test_must_fail git update-ref -z $m $m $m 2>err && | |
320 | grep "usage: git update-ref" err | |
321 | ' | |
322 | ||
323 | test_expect_success 'stdin works with no input' ' | |
324 | >stdin && | |
325 | git update-ref --stdin <stdin && | |
326 | git rev-parse --verify -q $m | |
327 | ' | |
328 | ||
329 | test_expect_success 'stdin fails on empty line' ' | |
330 | echo "" >stdin && | |
331 | test_must_fail git update-ref --stdin <stdin 2>err && | |
332 | grep "fatal: empty command in input" err | |
333 | ' | |
334 | ||
335 | test_expect_success 'stdin fails on only whitespace' ' | |
336 | echo " " >stdin && | |
337 | test_must_fail git update-ref --stdin <stdin 2>err && | |
338 | grep "fatal: whitespace before command: " err | |
339 | ' | |
340 | ||
341 | test_expect_success 'stdin fails on leading whitespace' ' | |
342 | echo " create $a $m" >stdin && | |
343 | test_must_fail git update-ref --stdin <stdin 2>err && | |
344 | grep "fatal: whitespace before command: create $a $m" err | |
345 | ' | |
346 | ||
347 | test_expect_success 'stdin fails on unknown command' ' | |
348 | echo "unknown $a" >stdin && | |
349 | test_must_fail git update-ref --stdin <stdin 2>err && | |
350 | grep "fatal: unknown command: unknown $a" err | |
351 | ' | |
352 | ||
353 | test_expect_success 'stdin fails on badly quoted input' ' | |
354 | echo "create $a \"master" >stdin && | |
355 | test_must_fail git update-ref --stdin <stdin 2>err && | |
356 | grep "fatal: badly quoted argument: \\\"master" err | |
357 | ' | |
358 | ||
359 | test_expect_success 'stdin fails on arguments not separated by space' ' | |
360 | echo "create \"$a\"master" >stdin && | |
361 | test_must_fail git update-ref --stdin <stdin 2>err && | |
362 | grep "fatal: expected SP but got: master" err | |
363 | ' | |
364 | ||
365 | test_expect_success 'stdin fails create with no ref' ' | |
366 | echo "create " >stdin && | |
367 | test_must_fail git update-ref --stdin <stdin 2>err && | |
368 | grep "fatal: create line missing <ref>" err | |
369 | ' | |
370 | ||
371 | test_expect_success 'stdin fails create with bad ref name' ' | |
372 | echo "create ~a $m" >stdin && | |
373 | test_must_fail git update-ref --stdin <stdin 2>err && | |
374 | grep "fatal: invalid ref format: ~a" err | |
375 | ' | |
376 | ||
377 | test_expect_success 'stdin fails create with no new value' ' | |
378 | echo "create $a" >stdin && | |
379 | test_must_fail git update-ref --stdin <stdin 2>err && | |
380 | grep "fatal: create $a missing <newvalue>" err | |
381 | ' | |
382 | ||
383 | test_expect_success 'stdin fails create with too many arguments' ' | |
384 | echo "create $a $m $m" >stdin && | |
385 | test_must_fail git update-ref --stdin <stdin 2>err && | |
386 | grep "fatal: create $a has extra input: $m" err | |
387 | ' | |
388 | ||
389 | test_expect_success 'stdin fails update with no ref' ' | |
390 | echo "update " >stdin && | |
391 | test_must_fail git update-ref --stdin <stdin 2>err && | |
392 | grep "fatal: update line missing <ref>" err | |
393 | ' | |
394 | ||
395 | test_expect_success 'stdin fails update with bad ref name' ' | |
396 | echo "update ~a $m" >stdin && | |
397 | test_must_fail git update-ref --stdin <stdin 2>err && | |
398 | grep "fatal: invalid ref format: ~a" err | |
399 | ' | |
400 | ||
401 | test_expect_success 'stdin fails update with no new value' ' | |
402 | echo "update $a" >stdin && | |
403 | test_must_fail git update-ref --stdin <stdin 2>err && | |
404 | grep "fatal: update $a missing <newvalue>" err | |
405 | ' | |
406 | ||
407 | test_expect_success 'stdin fails update with too many arguments' ' | |
408 | echo "update $a $m $m $m" >stdin && | |
409 | test_must_fail git update-ref --stdin <stdin 2>err && | |
410 | grep "fatal: update $a has extra input: $m" err | |
411 | ' | |
412 | ||
413 | test_expect_success 'stdin fails delete with no ref' ' | |
414 | echo "delete " >stdin && | |
415 | test_must_fail git update-ref --stdin <stdin 2>err && | |
416 | grep "fatal: delete line missing <ref>" err | |
417 | ' | |
418 | ||
419 | test_expect_success 'stdin fails delete with bad ref name' ' | |
420 | echo "delete ~a $m" >stdin && | |
421 | test_must_fail git update-ref --stdin <stdin 2>err && | |
422 | grep "fatal: invalid ref format: ~a" err | |
423 | ' | |
424 | ||
425 | test_expect_success 'stdin fails delete with too many arguments' ' | |
426 | echo "delete $a $m $m" >stdin && | |
427 | test_must_fail git update-ref --stdin <stdin 2>err && | |
428 | grep "fatal: delete $a has extra input: $m" err | |
429 | ' | |
430 | ||
431 | test_expect_success 'stdin fails verify with too many arguments' ' | |
432 | echo "verify $a $m $m" >stdin && | |
433 | test_must_fail git update-ref --stdin <stdin 2>err && | |
434 | grep "fatal: verify $a has extra input: $m" err | |
435 | ' | |
436 | ||
437 | test_expect_success 'stdin fails option with unknown name' ' | |
438 | echo "option unknown" >stdin && | |
439 | test_must_fail git update-ref --stdin <stdin 2>err && | |
440 | grep "fatal: option unknown: unknown" err | |
441 | ' | |
442 | ||
443 | test_expect_success 'stdin fails with duplicate refs' ' | |
444 | cat >stdin <<-EOF && | |
445 | create $a $m | |
446 | create $b $m | |
447 | create $a $m | |
448 | EOF | |
449 | test_must_fail git update-ref --stdin <stdin 2>err && | |
450 | grep "fatal: Multiple updates for ref '"'"'$a'"'"' not allowed." err | |
451 | ' | |
452 | ||
453 | test_expect_success 'stdin create ref works' ' | |
454 | echo "create $a $m" >stdin && | |
455 | git update-ref --stdin <stdin && | |
456 | git rev-parse $m >expect && | |
457 | git rev-parse $a >actual && | |
458 | test_cmp expect actual | |
459 | ' | |
460 | ||
461 | test_expect_success 'stdin update ref creates with zero old value' ' | |
462 | echo "update $b $m $Z" >stdin && | |
463 | git update-ref --stdin <stdin && | |
464 | git rev-parse $m >expect && | |
465 | git rev-parse $b >actual && | |
466 | test_cmp expect actual && | |
467 | git update-ref -d $b | |
468 | ' | |
469 | ||
470 | test_expect_success 'stdin update ref creates with empty old value' ' | |
471 | echo "update $b $m $E" >stdin && | |
472 | git update-ref --stdin <stdin && | |
473 | git rev-parse $m >expect && | |
474 | git rev-parse $b >actual && | |
475 | test_cmp expect actual | |
476 | ' | |
477 | ||
478 | test_expect_success 'stdin create ref works with path with space to blob' ' | |
479 | echo "create refs/blobs/pws \"$m:$pws\"" >stdin && | |
480 | git update-ref --stdin <stdin && | |
481 | git rev-parse "$m:$pws" >expect && | |
482 | git rev-parse refs/blobs/pws >actual && | |
483 | test_cmp expect actual && | |
484 | git update-ref -d refs/blobs/pws | |
485 | ' | |
486 | ||
487 | test_expect_success 'stdin update ref fails with wrong old value' ' | |
488 | echo "update $c $m $m~1" >stdin && | |
489 | test_must_fail git update-ref --stdin <stdin 2>err && | |
490 | grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err && | |
491 | test_must_fail git rev-parse --verify -q $c | |
492 | ' | |
493 | ||
494 | test_expect_success 'stdin update ref fails with bad old value' ' | |
495 | echo "update $c $m does-not-exist" >stdin && | |
496 | test_must_fail git update-ref --stdin <stdin 2>err && | |
497 | grep "fatal: invalid old value for ref $c: does-not-exist" err && | |
498 | test_must_fail git rev-parse --verify -q $c | |
499 | ' | |
500 | ||
501 | test_expect_success 'stdin create ref fails with bad new value' ' | |
502 | echo "create $c does-not-exist" >stdin && | |
503 | test_must_fail git update-ref --stdin <stdin 2>err && | |
504 | grep "fatal: invalid new value for ref $c: does-not-exist" err && | |
505 | test_must_fail git rev-parse --verify -q $c | |
506 | ' | |
507 | ||
508 | test_expect_success 'stdin create ref fails with zero new value' ' | |
509 | echo "create $c " >stdin && | |
510 | test_must_fail git update-ref --stdin <stdin 2>err && | |
511 | grep "fatal: create $c given zero new value" err && | |
512 | test_must_fail git rev-parse --verify -q $c | |
513 | ' | |
514 | ||
515 | test_expect_success 'stdin update ref works with right old value' ' | |
516 | echo "update $b $m~1 $m" >stdin && | |
517 | git update-ref --stdin <stdin && | |
518 | git rev-parse $m~1 >expect && | |
519 | git rev-parse $b >actual && | |
520 | test_cmp expect actual | |
521 | ' | |
522 | ||
523 | test_expect_success 'stdin delete ref fails with wrong old value' ' | |
524 | echo "delete $a $m~1" >stdin && | |
525 | test_must_fail git update-ref --stdin <stdin 2>err && | |
526 | grep "fatal: Cannot lock the ref '"'"'$a'"'"'" err && | |
527 | git rev-parse $m >expect && | |
528 | git rev-parse $a >actual && | |
529 | test_cmp expect actual | |
530 | ' | |
531 | ||
532 | test_expect_success 'stdin delete ref fails with zero old value' ' | |
533 | echo "delete $a " >stdin && | |
534 | test_must_fail git update-ref --stdin <stdin 2>err && | |
535 | grep "fatal: delete $a given zero old value" err && | |
536 | git rev-parse $m >expect && | |
537 | git rev-parse $a >actual && | |
538 | test_cmp expect actual | |
539 | ' | |
540 | ||
541 | test_expect_success 'stdin update symref works option no-deref' ' | |
542 | git symbolic-ref TESTSYMREF $b && | |
543 | cat >stdin <<-EOF && | |
544 | option no-deref | |
545 | update TESTSYMREF $a $b | |
546 | EOF | |
547 | git update-ref --stdin <stdin && | |
548 | git rev-parse TESTSYMREF >expect && | |
549 | git rev-parse $a >actual && | |
550 | test_cmp expect actual && | |
551 | git rev-parse $m~1 >expect && | |
552 | git rev-parse $b >actual && | |
553 | test_cmp expect actual | |
554 | ' | |
555 | ||
556 | test_expect_success 'stdin delete symref works option no-deref' ' | |
557 | git symbolic-ref TESTSYMREF $b && | |
558 | cat >stdin <<-EOF && | |
559 | option no-deref | |
560 | delete TESTSYMREF $b | |
561 | EOF | |
562 | git update-ref --stdin <stdin && | |
563 | test_must_fail git rev-parse --verify -q TESTSYMREF && | |
564 | git rev-parse $m~1 >expect && | |
565 | git rev-parse $b >actual && | |
566 | test_cmp expect actual | |
567 | ' | |
568 | ||
569 | test_expect_success 'stdin delete ref works with right old value' ' | |
570 | echo "delete $b $m~1" >stdin && | |
571 | git update-ref --stdin <stdin && | |
572 | test_must_fail git rev-parse --verify -q $b | |
573 | ' | |
574 | ||
575 | test_expect_success 'stdin update/create/verify combination works' ' | |
576 | cat >stdin <<-EOF && | |
577 | update $a $m | |
578 | create $b $m | |
579 | verify $c | |
580 | EOF | |
581 | git update-ref --stdin <stdin && | |
582 | git rev-parse $m >expect && | |
583 | git rev-parse $a >actual && | |
584 | test_cmp expect actual && | |
585 | git rev-parse $b >actual && | |
586 | test_cmp expect actual && | |
587 | test_must_fail git rev-parse --verify -q $c | |
588 | ' | |
589 | ||
590 | test_expect_success 'stdin update refs works with identity updates' ' | |
591 | cat >stdin <<-EOF && | |
592 | update $a $m $m | |
593 | update $b $m $m | |
594 | update $c $Z $E | |
595 | EOF | |
596 | git update-ref --stdin <stdin && | |
597 | git rev-parse $m >expect && | |
598 | git rev-parse $a >actual && | |
599 | test_cmp expect actual && | |
600 | git rev-parse $b >actual && | |
601 | test_cmp expect actual && | |
602 | test_must_fail git rev-parse --verify -q $c | |
603 | ' | |
604 | ||
605 | test_expect_success 'stdin update refs fails with wrong old value' ' | |
606 | git update-ref $c $m && | |
607 | cat >stdin <<-EOF && | |
608 | update $a $m $m | |
609 | update $b $m $m | |
610 | update $c '' | |
611 | EOF | |
612 | test_must_fail git update-ref --stdin <stdin 2>err && | |
613 | grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err && | |
614 | git rev-parse $m >expect && | |
615 | git rev-parse $a >actual && | |
616 | test_cmp expect actual && | |
617 | git rev-parse $b >actual && | |
618 | test_cmp expect actual && | |
619 | git rev-parse $c >actual && | |
620 | test_cmp expect actual | |
621 | ' | |
622 | ||
623 | test_expect_success 'stdin delete refs works with packed and loose refs' ' | |
624 | git pack-refs --all && | |
625 | git update-ref $c $m~1 && | |
626 | cat >stdin <<-EOF && | |
627 | delete $a $m | |
628 | update $b $Z $m | |
629 | update $c $E $m~1 | |
630 | EOF | |
631 | git update-ref --stdin <stdin && | |
632 | test_must_fail git rev-parse --verify -q $a && | |
633 | test_must_fail git rev-parse --verify -q $b && | |
634 | test_must_fail git rev-parse --verify -q $c | |
635 | ' | |
636 | ||
637 | test_expect_success 'stdin -z works on empty input' ' | |
638 | >stdin && | |
639 | git update-ref -z --stdin <stdin && | |
640 | git rev-parse --verify -q $m | |
641 | ' | |
642 | ||
643 | test_expect_success 'stdin -z fails on empty line' ' | |
644 | echo "" >stdin && | |
645 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
646 | grep "fatal: whitespace before command: " err | |
647 | ' | |
648 | ||
649 | test_expect_success 'stdin -z fails on empty command' ' | |
650 | printf $F "" >stdin && | |
651 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
652 | grep "fatal: empty command in input" err | |
653 | ' | |
654 | ||
655 | test_expect_success 'stdin -z fails on only whitespace' ' | |
656 | printf $F " " >stdin && | |
657 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
658 | grep "fatal: whitespace before command: " err | |
659 | ' | |
660 | ||
661 | test_expect_success 'stdin -z fails on leading whitespace' ' | |
662 | printf $F " create $a" "$m" >stdin && | |
663 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
664 | grep "fatal: whitespace before command: create $a" err | |
665 | ' | |
666 | ||
667 | test_expect_success 'stdin -z fails on unknown command' ' | |
668 | printf $F "unknown $a" >stdin && | |
669 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
670 | grep "fatal: unknown command: unknown $a" err | |
671 | ' | |
672 | ||
673 | test_expect_success 'stdin -z fails create with no ref' ' | |
674 | printf $F "create " >stdin && | |
675 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
676 | grep "fatal: create line missing <ref>" err | |
677 | ' | |
678 | ||
679 | test_expect_success 'stdin -z fails create with bad ref name' ' | |
680 | printf $F "create ~a " "$m" >stdin && | |
681 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
682 | grep "fatal: invalid ref format: ~a " err | |
683 | ' | |
684 | ||
685 | test_expect_success 'stdin -z fails create with no new value' ' | |
686 | printf $F "create $a" >stdin && | |
687 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
688 | grep "fatal: create $a missing <newvalue>" err | |
689 | ' | |
690 | ||
691 | test_expect_success 'stdin -z fails create with too many arguments' ' | |
692 | printf $F "create $a" "$m" "$m" >stdin && | |
693 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
694 | grep "fatal: unknown command: $m" err | |
695 | ' | |
696 | ||
697 | test_expect_success 'stdin -z fails update with no ref' ' | |
698 | printf $F "update " >stdin && | |
699 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
700 | grep "fatal: update line missing <ref>" err | |
701 | ' | |
702 | ||
703 | test_expect_success 'stdin -z fails update with bad ref name' ' | |
704 | printf $F "update ~a" "$m" >stdin && | |
705 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
706 | grep "fatal: invalid ref format: ~a" err | |
707 | ' | |
708 | ||
709 | test_expect_success 'stdin -z fails update with no new value' ' | |
710 | printf $F "update $a" >stdin && | |
711 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
712 | grep "fatal: update $a missing <newvalue>" err | |
713 | ' | |
714 | ||
715 | test_expect_success 'stdin -z fails update with no old value' ' | |
716 | printf $F "update $a" "$m" >stdin && | |
717 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
718 | grep "fatal: update $a missing \\[<oldvalue>\\] NUL" err | |
719 | ' | |
720 | ||
721 | test_expect_success 'stdin -z fails update with too many arguments' ' | |
722 | printf $F "update $a" "$m" "$m" "$m" >stdin && | |
723 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
724 | grep "fatal: unknown command: $m" err | |
725 | ' | |
726 | ||
727 | test_expect_success 'stdin -z fails delete with no ref' ' | |
728 | printf $F "delete " >stdin && | |
729 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
730 | grep "fatal: delete line missing <ref>" err | |
731 | ' | |
732 | ||
733 | test_expect_success 'stdin -z fails delete with bad ref name' ' | |
734 | printf $F "delete ~a" "$m" >stdin && | |
735 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
736 | grep "fatal: invalid ref format: ~a" err | |
737 | ' | |
738 | ||
739 | test_expect_success 'stdin -z fails delete with no old value' ' | |
740 | printf $F "delete $a" >stdin && | |
741 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
742 | grep "fatal: delete $a missing \\[<oldvalue>\\] NUL" err | |
743 | ' | |
744 | ||
745 | test_expect_success 'stdin -z fails delete with too many arguments' ' | |
746 | printf $F "delete $a" "$m" "$m" >stdin && | |
747 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
748 | grep "fatal: unknown command: $m" err | |
749 | ' | |
750 | ||
751 | test_expect_success 'stdin -z fails verify with too many arguments' ' | |
752 | printf $F "verify $a" "$m" "$m" >stdin && | |
753 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
754 | grep "fatal: unknown command: $m" err | |
755 | ' | |
756 | ||
757 | test_expect_success 'stdin -z fails verify with no old value' ' | |
758 | printf $F "verify $a" >stdin && | |
759 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
760 | grep "fatal: verify $a missing \\[<oldvalue>\\] NUL" err | |
761 | ' | |
762 | ||
763 | test_expect_success 'stdin -z fails option with unknown name' ' | |
764 | printf $F "option unknown" >stdin && | |
765 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
766 | grep "fatal: option unknown: unknown" err | |
767 | ' | |
768 | ||
769 | test_expect_success 'stdin -z fails with duplicate refs' ' | |
770 | printf $F "create $a" "$m" "create $b" "$m" "create $a" "$m" >stdin && | |
771 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
772 | grep "fatal: Multiple updates for ref '"'"'$a'"'"' not allowed." err | |
773 | ' | |
774 | ||
775 | test_expect_success 'stdin -z create ref works' ' | |
776 | printf $F "create $a" "$m" >stdin && | |
777 | git update-ref -z --stdin <stdin && | |
778 | git rev-parse $m >expect && | |
779 | git rev-parse $a >actual && | |
780 | test_cmp expect actual | |
781 | ' | |
782 | ||
783 | test_expect_success 'stdin -z update ref creates with zero old value' ' | |
784 | printf $F "update $b" "$m" "$Z" >stdin && | |
785 | git update-ref -z --stdin <stdin && | |
786 | git rev-parse $m >expect && | |
787 | git rev-parse $b >actual && | |
788 | test_cmp expect actual && | |
789 | git update-ref -d $b | |
790 | ' | |
791 | ||
792 | test_expect_success 'stdin -z update ref creates with empty old value' ' | |
793 | printf $F "update $b" "$m" "" >stdin && | |
794 | git update-ref -z --stdin <stdin && | |
795 | git rev-parse $m >expect && | |
796 | git rev-parse $b >actual && | |
797 | test_cmp expect actual | |
798 | ' | |
799 | ||
800 | test_expect_success 'stdin -z create ref works with path with space to blob' ' | |
801 | printf $F "create refs/blobs/pws" "$m:$pws" >stdin && | |
802 | git update-ref -z --stdin <stdin && | |
803 | git rev-parse "$m:$pws" >expect && | |
804 | git rev-parse refs/blobs/pws >actual && | |
805 | test_cmp expect actual && | |
806 | git update-ref -d refs/blobs/pws | |
807 | ' | |
808 | ||
809 | test_expect_success 'stdin -z update ref fails with wrong old value' ' | |
810 | printf $F "update $c" "$m" "$m~1" >stdin && | |
811 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
812 | grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err && | |
813 | test_must_fail git rev-parse --verify -q $c | |
814 | ' | |
815 | ||
816 | test_expect_success 'stdin -z update ref fails with bad old value' ' | |
817 | printf $F "update $c" "$m" "does-not-exist" >stdin && | |
818 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
819 | grep "fatal: invalid old value for ref $c: does-not-exist" err && | |
820 | test_must_fail git rev-parse --verify -q $c | |
821 | ' | |
822 | ||
b9d56b5d AG |
823 | test_expect_success 'stdin -z create ref fails when ref exists' ' |
824 | git update-ref $c $m && | |
825 | git rev-parse "$c" >expect && | |
826 | printf $F "create $c" "$m~1" >stdin && | |
827 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
828 | grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err && | |
829 | git rev-parse "$c" >actual && | |
830 | test_cmp expect actual | |
831 | ' | |
832 | ||
c6268bc0 | 833 | test_expect_success 'stdin -z create ref fails with bad new value' ' |
b9d56b5d | 834 | git update-ref -d "$c" && |
c6268bc0 BK |
835 | printf $F "create $c" "does-not-exist" >stdin && |
836 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
837 | grep "fatal: invalid new value for ref $c: does-not-exist" err && | |
838 | test_must_fail git rev-parse --verify -q $c | |
839 | ' | |
840 | ||
841 | test_expect_success 'stdin -z create ref fails with zero new value' ' | |
842 | printf $F "create $c" "" >stdin && | |
843 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
844 | grep "fatal: create $c given zero new value" err && | |
845 | test_must_fail git rev-parse --verify -q $c | |
846 | ' | |
847 | ||
848 | test_expect_success 'stdin -z update ref works with right old value' ' | |
849 | printf $F "update $b" "$m~1" "$m" >stdin && | |
850 | git update-ref -z --stdin <stdin && | |
851 | git rev-parse $m~1 >expect && | |
852 | git rev-parse $b >actual && | |
853 | test_cmp expect actual | |
854 | ' | |
855 | ||
856 | test_expect_success 'stdin -z delete ref fails with wrong old value' ' | |
857 | printf $F "delete $a" "$m~1" >stdin && | |
858 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
859 | grep "fatal: Cannot lock the ref '"'"'$a'"'"'" err && | |
860 | git rev-parse $m >expect && | |
861 | git rev-parse $a >actual && | |
862 | test_cmp expect actual | |
863 | ' | |
864 | ||
865 | test_expect_success 'stdin -z delete ref fails with zero old value' ' | |
866 | printf $F "delete $a" "$Z" >stdin && | |
867 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
868 | grep "fatal: delete $a given zero old value" err && | |
869 | git rev-parse $m >expect && | |
870 | git rev-parse $a >actual && | |
871 | test_cmp expect actual | |
872 | ' | |
873 | ||
874 | test_expect_success 'stdin -z update symref works option no-deref' ' | |
875 | git symbolic-ref TESTSYMREF $b && | |
876 | printf $F "option no-deref" "update TESTSYMREF" "$a" "$b" >stdin && | |
877 | git update-ref -z --stdin <stdin && | |
878 | git rev-parse TESTSYMREF >expect && | |
879 | git rev-parse $a >actual && | |
880 | test_cmp expect actual && | |
881 | git rev-parse $m~1 >expect && | |
882 | git rev-parse $b >actual && | |
883 | test_cmp expect actual | |
884 | ' | |
885 | ||
886 | test_expect_success 'stdin -z delete symref works option no-deref' ' | |
887 | git symbolic-ref TESTSYMREF $b && | |
888 | printf $F "option no-deref" "delete TESTSYMREF" "$b" >stdin && | |
889 | git update-ref -z --stdin <stdin && | |
890 | test_must_fail git rev-parse --verify -q TESTSYMREF && | |
891 | git rev-parse $m~1 >expect && | |
892 | git rev-parse $b >actual && | |
893 | test_cmp expect actual | |
894 | ' | |
895 | ||
896 | test_expect_success 'stdin -z delete ref works with right old value' ' | |
897 | printf $F "delete $b" "$m~1" >stdin && | |
898 | git update-ref -z --stdin <stdin && | |
899 | test_must_fail git rev-parse --verify -q $b | |
900 | ' | |
901 | ||
902 | test_expect_success 'stdin -z update/create/verify combination works' ' | |
903 | printf $F "update $a" "$m" "" "create $b" "$m" "verify $c" "" >stdin && | |
904 | git update-ref -z --stdin <stdin && | |
905 | git rev-parse $m >expect && | |
906 | git rev-parse $a >actual && | |
907 | test_cmp expect actual && | |
908 | git rev-parse $b >actual && | |
909 | test_cmp expect actual && | |
910 | test_must_fail git rev-parse --verify -q $c | |
911 | ' | |
912 | ||
913 | test_expect_success 'stdin -z update refs works with identity updates' ' | |
914 | printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "$Z" "" >stdin && | |
915 | git update-ref -z --stdin <stdin && | |
916 | git rev-parse $m >expect && | |
917 | git rev-parse $a >actual && | |
918 | test_cmp expect actual && | |
919 | git rev-parse $b >actual && | |
920 | test_cmp expect actual && | |
921 | test_must_fail git rev-parse --verify -q $c | |
922 | ' | |
923 | ||
924 | test_expect_success 'stdin -z update refs fails with wrong old value' ' | |
925 | git update-ref $c $m && | |
926 | printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "" "$Z" >stdin && | |
927 | test_must_fail git update-ref -z --stdin <stdin 2>err && | |
928 | grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err && | |
929 | git rev-parse $m >expect && | |
930 | git rev-parse $a >actual && | |
931 | test_cmp expect actual && | |
932 | git rev-parse $b >actual && | |
933 | test_cmp expect actual && | |
934 | git rev-parse $c >actual && | |
935 | test_cmp expect actual | |
936 | ' | |
937 | ||
938 | test_expect_success 'stdin -z delete refs works with packed and loose refs' ' | |
939 | git pack-refs --all && | |
940 | git update-ref $c $m~1 && | |
941 | printf $F "delete $a" "$m" "update $b" "$Z" "$m" "update $c" "" "$m~1" >stdin && | |
942 | git update-ref -z --stdin <stdin && | |
943 | test_must_fail git rev-parse --verify -q $a && | |
944 | test_must_fail git rev-parse --verify -q $b && | |
945 | test_must_fail git rev-parse --verify -q $c | |
946 | ' | |
947 | ||
6de08ae6 | 948 | test_done |