807fb83af8c65304f1dae2ee35ba0f2909ddf465
[git/git.git] / t / t1000-read-tree-m-3way.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2005 Junio C Hamano
4 #
5
6 test_description='Three way merge with read-tree -m
7
8 This test tries three-way merge with read-tree -m
9
10 There is one ancestor (called O for Original) and two branches A
11 and B derived from it. We want to do a 3-way merge between A and
12 B, using O as the common ancestor.
13
14 merge A O B
15
16 Decisions are made by comparing contents of O, A and B pathname
17 by pathname. The result is determined by the following guiding
18 principle:
19
20 - If only A does something to it and B does not touch it, take
21 whatever A does.
22
23 - If only B does something to it and A does not touch it, take
24 whatever B does.
25
26 - If both A and B does something but in the same way, take
27 whatever they do.
28
29 - If A and B does something but different things, we need a
30 3-way merge:
31
32 - We cannot do anything about the following cases:
33
34 * O does not have it. A and B both must be adding to the
35 same path independently.
36
37 * A deletes it. B must be modifying.
38
39 - Otherwise, A and B are modifying. Run 3-way merge.
40
41 First, the case matrix.
42
43 - Vertical axis is for A'\''s actions.
44 - Horizontal axis is for B'\''s actions.
45
46 .----------------------------------------------------------------.
47 | A B | No Action | Delete | Modify | Add |
48 |------------+------------+------------+------------+------------|
49 | No Action | | | | |
50 | | select O | delete | select B | select B |
51 | | | | | |
52 |------------+------------+------------+------------+------------|
53 | Delete | | | ********** | can |
54 | | delete | delete | merge | not |
55 | | | | | happen |
56 |------------+------------+------------+------------+------------|
57 | Modify | | ********** | ?????????? | can |
58 | | select A | merge | select A=B | not |
59 | | | | merge | happen |
60 |------------+------------+------------+------------+------------|
61 | Add | | can | can | ?????????? |
62 | | select A | not | not | select A=B |
63 | | | happen | happen | merge |
64 .----------------------------------------------------------------.
65
66 In addition:
67
68 SS: a special case of MM, where A and B makes the same modification.
69 LL: a special case of AA, where A and B creates the same file.
70 TT: a special case of MM, where A and B makes mergeable changes.
71 DF: a special case, where A makes a directory and B makes a file.
72
73 '
74 . ./test-lib.sh
75 . ../lib-read-tree-m-3way.sh
76
77 ################################################################
78 # Trivial "majority when 3 stages exist" merge plus #2ALT, #3ALT
79 # and #5ALT trivial merges.
80
81 cat >expected <<\EOF
82 100644 X 2 AA
83 100644 X 3 AA
84 100644 X 0 AN
85 100644 X 1 DD
86 100644 X 3 DF
87 100644 X 2 DF/DF
88 100644 X 1 DM
89 100644 X 3 DM
90 100644 X 1 DN
91 100644 X 3 DN
92 100644 X 0 LL
93 100644 X 1 MD
94 100644 X 2 MD
95 100644 X 1 MM
96 100644 X 2 MM
97 100644 X 3 MM
98 100644 X 0 MN
99 100644 X 0 NA
100 100644 X 1 ND
101 100644 X 2 ND
102 100644 X 0 NM
103 100644 X 0 NN
104 100644 X 0 SS
105 100644 X 1 TT
106 100644 X 2 TT
107 100644 X 3 TT
108 100644 X 2 Z/AA
109 100644 X 3 Z/AA
110 100644 X 0 Z/AN
111 100644 X 1 Z/DD
112 100644 X 1 Z/DM
113 100644 X 3 Z/DM
114 100644 X 1 Z/DN
115 100644 X 3 Z/DN
116 100644 X 1 Z/MD
117 100644 X 2 Z/MD
118 100644 X 1 Z/MM
119 100644 X 2 Z/MM
120 100644 X 3 Z/MM
121 100644 X 0 Z/MN
122 100644 X 0 Z/NA
123 100644 X 1 Z/ND
124 100644 X 2 Z/ND
125 100644 X 0 Z/NM
126 100644 X 0 Z/NN
127 EOF
128
129 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
130 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
131
132 check_result () {
133 git ls-files --stage | sed -e 's/ '"$_x40"' / X /' >current &&
134 test_cmp expected current
135 }
136
137 # This is done on an empty work directory, which is the normal
138 # merge person behaviour.
139 test_expect_success \
140 '3-way merge with git read-tree -m, empty cache' \
141 "rm -fr [NDMALTS][NDMALTSF] Z &&
142 rm .git/index &&
143 git read-tree -m $tree_O $tree_A $tree_B &&
144 check_result"
145
146 # This starts out with the first head, which is the normal
147 # patch submitter behaviour.
148 test_expect_success \
149 '3-way merge with git read-tree -m, match H' \
150 "rm -fr [NDMALTS][NDMALTSF] Z &&
151 rm .git/index &&
152 git read-tree $tree_A &&
153 git checkout-index -f -u -a &&
154 git read-tree -m $tree_O $tree_A $tree_B &&
155 check_result"
156
157 : <<\END_OF_CASE_TABLE
158
159 We have so far tested only empty index and clean-and-matching-A index
160 case which are trivial. Make sure index requirements are also
161 checked.
162
163 "git read-tree -m O A B"
164
165 O A B result index requirements
166 -------------------------------------------------------------------
167 1 missing missing missing - must not exist.
168 ------------------------------------------------------------------
169 2 missing missing exists take B* must match B, if exists.
170 ------------------------------------------------------------------
171 3 missing exists missing take A* must match A, if exists.
172 ------------------------------------------------------------------
173 4 missing exists A!=B no merge must match A and be
174 up-to-date, if exists.
175 ------------------------------------------------------------------
176 5 missing exists A==B take A must match A, if exists.
177 ------------------------------------------------------------------
178 6 exists missing missing remove must not exist.
179 ------------------------------------------------------------------
180 7 exists missing O!=B no merge must not exist.
181 ------------------------------------------------------------------
182 8 exists missing O==B remove must not exist.
183 ------------------------------------------------------------------
184 9 exists O!=A missing no merge must match A and be
185 up-to-date, if exists.
186 ------------------------------------------------------------------
187 10 exists O==A missing no merge must match A
188 ------------------------------------------------------------------
189 11 exists O!=A O!=B no merge must match A and be
190 A!=B up-to-date, if exists.
191 ------------------------------------------------------------------
192 12 exists O!=A O!=B take A must match A, if exists.
193 A==B
194 ------------------------------------------------------------------
195 13 exists O!=A O==B take A must match A, if exists.
196 ------------------------------------------------------------------
197 14 exists O==A O!=B take B if exists, must either (1)
198 match A and be up-to-date,
199 or (2) match B.
200 ------------------------------------------------------------------
201 15 exists O==A O==B take B must match A if exists.
202 ------------------------------------------------------------------
203 16 exists O==A O==B barf must match A if exists.
204 *multi* in one in another
205 -------------------------------------------------------------------
206
207 Note: we need to be careful in case 2 and 3. The tree A may contain
208 DF (file) when tree B require DF to be a directory by having DF/DF
209 (file).
210
211 END_OF_CASE_TABLE
212
213 test_expect_success '1 - must not have an entry not in A.' "
214 rm -f .git/index XX &&
215 echo XX >XX &&
216 git update-index --add XX &&
217 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
218 "
219
220 test_expect_success \
221 '2 - must match B in !O && !A && B case.' \
222 "rm -f .git/index NA &&
223 cp .orig-B/NA NA &&
224 git update-index --add NA &&
225 git read-tree -m $tree_O $tree_A $tree_B"
226
227 test_expect_success \
228 '2 - matching B alone is OK in !O && !A && B case.' \
229 "rm -f .git/index NA &&
230 cp .orig-B/NA NA &&
231 git update-index --add NA &&
232 echo extra >>NA &&
233 git read-tree -m $tree_O $tree_A $tree_B"
234
235 test_expect_success \
236 '3 - must match A in !O && A && !B case.' \
237 "rm -f .git/index AN &&
238 cp .orig-A/AN AN &&
239 git update-index --add AN &&
240 git read-tree -m $tree_O $tree_A $tree_B &&
241 check_result"
242
243 test_expect_success \
244 '3 - matching A alone is OK in !O && A && !B case.' \
245 "rm -f .git/index AN &&
246 cp .orig-A/AN AN &&
247 git update-index --add AN &&
248 echo extra >>AN &&
249 git read-tree -m $tree_O $tree_A $tree_B"
250
251 test_expect_success \
252 '3 (fail) - must match A in !O && A && !B case.' "
253 rm -f .git/index AN &&
254 cp .orig-A/AN AN &&
255 echo extra >>AN &&
256 git update-index --add AN &&
257 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
258 "
259
260 test_expect_success \
261 '4 - must match and be up-to-date in !O && A && B && A!=B case.' \
262 "rm -f .git/index AA &&
263 cp .orig-A/AA AA &&
264 git update-index --add AA &&
265 git read-tree -m $tree_O $tree_A $tree_B &&
266 check_result"
267
268 test_expect_success \
269 '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' "
270 rm -f .git/index AA &&
271 cp .orig-A/AA AA &&
272 git update-index --add AA &&
273 echo extra >>AA &&
274 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
275 "
276
277 test_expect_success \
278 '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' "
279 rm -f .git/index AA &&
280 cp .orig-A/AA AA &&
281 echo extra >>AA &&
282 git update-index --add AA &&
283 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
284 "
285
286 test_expect_success \
287 '5 - must match in !O && A && B && A==B case.' \
288 "rm -f .git/index LL &&
289 cp .orig-A/LL LL &&
290 git update-index --add LL &&
291 git read-tree -m $tree_O $tree_A $tree_B &&
292 check_result"
293
294 test_expect_success \
295 '5 - must match in !O && A && B && A==B case.' \
296 "rm -f .git/index LL &&
297 cp .orig-A/LL LL &&
298 git update-index --add LL &&
299 echo extra >>LL &&
300 git read-tree -m $tree_O $tree_A $tree_B &&
301 check_result"
302
303 test_expect_success \
304 '5 (fail) - must match A in !O && A && B && A==B case.' "
305 rm -f .git/index LL &&
306 cp .orig-A/LL LL &&
307 echo extra >>LL &&
308 git update-index --add LL &&
309 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
310 "
311
312 test_expect_success \
313 '6 - must not exist in O && !A && !B case' "
314 rm -f .git/index DD &&
315 echo DD >DD
316 git update-index --add DD &&
317 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
318 "
319
320 test_expect_success \
321 '7 - must not exist in O && !A && B && O!=B case' "
322 rm -f .git/index DM &&
323 cp .orig-B/DM DM &&
324 git update-index --add DM &&
325 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
326 "
327
328 test_expect_success \
329 '8 - must not exist in O && !A && B && O==B case' "
330 rm -f .git/index DN &&
331 cp .orig-B/DN DN &&
332 git update-index --add DN &&
333 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
334 "
335
336 test_expect_success \
337 '9 - must match and be up-to-date in O && A && !B && O!=A case' \
338 "rm -f .git/index MD &&
339 cp .orig-A/MD MD &&
340 git update-index --add MD &&
341 git read-tree -m $tree_O $tree_A $tree_B &&
342 check_result"
343
344 test_expect_success \
345 '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' "
346 rm -f .git/index MD &&
347 cp .orig-A/MD MD &&
348 git update-index --add MD &&
349 echo extra >>MD &&
350 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
351 "
352
353 test_expect_success \
354 '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' "
355 rm -f .git/index MD &&
356 cp .orig-A/MD MD &&
357 echo extra >>MD &&
358 git update-index --add MD &&
359 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
360 "
361
362 test_expect_success \
363 '10 - must match and be up-to-date in O && A && !B && O==A case' \
364 "rm -f .git/index ND &&
365 cp .orig-A/ND ND &&
366 git update-index --add ND &&
367 git read-tree -m $tree_O $tree_A $tree_B &&
368 check_result"
369
370 test_expect_success \
371 '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' "
372 rm -f .git/index ND &&
373 cp .orig-A/ND ND &&
374 git update-index --add ND &&
375 echo extra >>ND &&
376 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
377 "
378
379 test_expect_success \
380 '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' "
381 rm -f .git/index ND &&
382 cp .orig-A/ND ND &&
383 echo extra >>ND &&
384 git update-index --add ND &&
385 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
386 "
387
388 test_expect_success \
389 '11 - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
390 "rm -f .git/index MM &&
391 cp .orig-A/MM MM &&
392 git update-index --add MM &&
393 git read-tree -m $tree_O $tree_A $tree_B &&
394 check_result"
395
396 test_expect_success \
397 '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' "
398 rm -f .git/index MM &&
399 cp .orig-A/MM MM &&
400 git update-index --add MM &&
401 echo extra >>MM &&
402 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
403 "
404
405 test_expect_success \
406 '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' "
407 rm -f .git/index MM &&
408 cp .orig-A/MM MM &&
409 echo extra >>MM &&
410 git update-index --add MM &&
411 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
412 "
413
414 test_expect_success \
415 '12 - must match A in O && A && B && O!=A && A==B case' \
416 "rm -f .git/index SS &&
417 cp .orig-A/SS SS &&
418 git update-index --add SS &&
419 git read-tree -m $tree_O $tree_A $tree_B &&
420 check_result"
421
422 test_expect_success \
423 '12 - must match A in O && A && B && O!=A && A==B case' \
424 "rm -f .git/index SS &&
425 cp .orig-A/SS SS &&
426 git update-index --add SS &&
427 echo extra >>SS &&
428 git read-tree -m $tree_O $tree_A $tree_B &&
429 check_result"
430
431 test_expect_success \
432 '12 (fail) - must match A in O && A && B && O!=A && A==B case' "
433 rm -f .git/index SS &&
434 cp .orig-A/SS SS &&
435 echo extra >>SS &&
436 git update-index --add SS &&
437 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
438 "
439
440 test_expect_success \
441 '13 - must match A in O && A && B && O!=A && O==B case' \
442 "rm -f .git/index MN &&
443 cp .orig-A/MN MN &&
444 git update-index --add MN &&
445 git read-tree -m $tree_O $tree_A $tree_B &&
446 check_result"
447
448 test_expect_success \
449 '13 - must match A in O && A && B && O!=A && O==B case' \
450 "rm -f .git/index MN &&
451 cp .orig-A/MN MN &&
452 git update-index --add MN &&
453 echo extra >>MN &&
454 git read-tree -m $tree_O $tree_A $tree_B &&
455 check_result"
456
457 test_expect_success \
458 '14 - must match and be up-to-date in O && A && B && O==A && O!=B case' \
459 "rm -f .git/index NM &&
460 cp .orig-A/NM NM &&
461 git update-index --add NM &&
462 git read-tree -m $tree_O $tree_A $tree_B &&
463 check_result"
464
465 test_expect_success \
466 '14 - may match B in O && A && B && O==A && O!=B case' \
467 "rm -f .git/index NM &&
468 cp .orig-B/NM NM &&
469 git update-index --add NM &&
470 echo extra >>NM &&
471 git read-tree -m $tree_O $tree_A $tree_B &&
472 check_result"
473
474 test_expect_success \
475 '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' "
476 rm -f .git/index NM &&
477 cp .orig-A/NM NM &&
478 git update-index --add NM &&
479 echo extra >>NM &&
480 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
481 "
482
483 test_expect_success \
484 '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' "
485 rm -f .git/index NM &&
486 cp .orig-A/NM NM &&
487 echo extra >>NM &&
488 git update-index --add NM &&
489 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
490 "
491
492 test_expect_success \
493 '15 - must match A in O && A && B && O==A && O==B case' \
494 "rm -f .git/index NN &&
495 cp .orig-A/NN NN &&
496 git update-index --add NN &&
497 git read-tree -m $tree_O $tree_A $tree_B &&
498 check_result"
499
500 test_expect_success \
501 '15 - must match A in O && A && B && O==A && O==B case' \
502 "rm -f .git/index NN &&
503 cp .orig-A/NN NN &&
504 git update-index --add NN &&
505 echo extra >>NN &&
506 git read-tree -m $tree_O $tree_A $tree_B &&
507 check_result"
508
509 test_expect_success \
510 '15 (fail) - must match A in O && A && B && O==A && O==B case' "
511 rm -f .git/index NN &&
512 cp .orig-A/NN NN &&
513 echo extra >>NN &&
514 git update-index --add NN &&
515 test_must_fail git read-tree -m $tree_O $tree_A $tree_B
516 "
517
518 # #16
519 test_expect_success \
520 '16 - A matches in one and B matches in another.' \
521 'rm -f .git/index F16 &&
522 echo F16 >F16 &&
523 git update-index --add F16 &&
524 tree0=`git write-tree` &&
525 echo E16 >F16 &&
526 git update-index F16 &&
527 tree1=`git write-tree` &&
528 git read-tree -m $tree0 $tree1 $tree1 $tree0 &&
529 git ls-files --stage'
530
531 test_done