[PATCH] Add debugging help for case #16 to read-tree.c
[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     diff -u 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.  The table also lists alternative semantics which is not
162 currently implemented.
163
164 "git-diff-tree -m O A B"
165
166      O       A       B         result      index requirements
167 -------------------------------------------------------------------
168   1  missing missing missing   -           must not exist.
169  ------------------------------------------------------------------
170   2  missing missing exists    no merge    must not exist.
171                                ------------------------------------
172     (ALT)                      take B*     must match B, if exists.
173  ------------------------------------------------------------------
174   3  missing exists  missing   no merge    must match A and be
175                                            up-to-date, if exists.
176                                ------------------------------------
177     (ALT)                      take A*     must match A, if exists.
178  ------------------------------------------------------------------
179   4  missing exists  A!=B      no merge    must match A and be
180                                            up-to-date, if exists.
181  ------------------------------------------------------------------
182   5  missing exists  A==B      no merge    must match A and be
183                                            up-to-date, if exists.
184                                ------------------------------------
185     (ALT)                      take A      must match A, if exists.
186  ------------------------------------------------------------------
187   6  exists  missing missing   no merge    must not exist.
188                                ------------------------------------
189     (ALT)                      remove      must not exist.
190  ------------------------------------------------------------------
191   7  exists  missing O!=B      no merge    must not exist.
192  ------------------------------------------------------------------
193   8  exists  missing O==B      no merge    must not exist.
194                                ------------------------------------
195     (ALT)                      remove      must not exist.
196  ------------------------------------------------------------------
197   9  exists  O!=A    missing   no merge    must match A and be
198                                            up-to-date, if exists.
199  ------------------------------------------------------------------
200  10  exists  O==A    missing   no merge    must match A and be
201                                            up-to-date, if exists.
202                                ------------------------------------
203     (ALT)                      remove      ditto
204  ------------------------------------------------------------------
205  11  exists  O!=A    O!=B      no merge    must match A and be
206                      A!=B                  up-to-date, if exists.
207  ------------------------------------------------------------------
208  12  exists  O!=A    O!=B      take A      must match A, if exists.
209                      A==B
210  ------------------------------------------------------------------
211  13  exists  O!=A    O==B      take A      must match A, if exists.
212  ------------------------------------------------------------------
213  14  exists  O==A    O!=B      take B      must match A and be
214                                            be up-to-date, if exists.
215                                ------------------------------------
216     (ALT)                      take B      if exists, must either (1)
217                                            match A and be up-to-date,
218                                            or (2) match B.
219  ------------------------------------------------------------------
220  15  exists  O==A    O==B      take B      must match A if exists.
221  ------------------------------------------------------------------
222  16  exists  O==A    O==B      barf        must match A if exists.
223      *multi* in one  in another
224 -------------------------------------------------------------------
225
226 Note: if we want to implement 2ALT and 3ALT we need to be careful.
227 The tree A may contain DF (file) when tree B require DF to be a
228 directory by having DF/DF (file).
229
230 END_OF_CASE_TABLE
231
232 test_expect_failure \
233     '1 - must not have an entry not in A.' \
234     "rm -f .git/index XX &&
235      echo XX >XX &&
236      git-update-index --add XX &&
237      git-read-tree -m $tree_O $tree_A $tree_B"
238
239 test_expect_success \
240     '2 - must match B in !O && !A && B case.' \
241     "rm -f .git/index NA &&
242      cp .orig-B/NA NA &&
243      git-update-index --add NA &&
244      git-read-tree -m $tree_O $tree_A $tree_B"
245
246 test_expect_success \
247     '2 - matching B alone is OK in !O && !A && B case.' \
248     "rm -f .git/index NA &&
249      cp .orig-B/NA NA &&
250      git-update-index --add NA &&
251      echo extra >>NA &&
252      git-read-tree -m $tree_O $tree_A $tree_B"
253
254 test_expect_success \
255     '3 - must match A in !O && A && !B case.' \
256     "rm -f .git/index AN &&
257      cp .orig-A/AN AN &&
258      git-update-index --add AN &&
259      git-read-tree -m $tree_O $tree_A $tree_B &&
260      check_result"
261
262 test_expect_success \
263     '3 - matching A alone is OK in !O && A && !B case.' \
264     "rm -f .git/index AN &&
265      cp .orig-A/AN AN &&
266      git-update-index --add AN &&
267      echo extra >>AN &&
268      git-read-tree -m $tree_O $tree_A $tree_B"
269
270 test_expect_failure \
271     '3 (fail) - must match A in !O && A && !B case.' \
272     "rm -f .git/index AN &&
273      cp .orig-A/AN AN &&
274      echo extra >>AN &&
275      git-update-index --add AN &&
276      git-read-tree -m $tree_O $tree_A $tree_B"
277
278 test_expect_success \
279     '4 - must match and be up-to-date in !O && A && B && A!=B case.' \
280     "rm -f .git/index AA &&
281      cp .orig-A/AA AA &&
282      git-update-index --add AA &&
283      git-read-tree -m $tree_O $tree_A $tree_B &&
284      check_result"
285
286 test_expect_failure \
287     '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' \
288     "rm -f .git/index AA &&
289      cp .orig-A/AA AA &&
290      git-update-index --add AA &&
291      echo extra >>AA &&
292      git-read-tree -m $tree_O $tree_A $tree_B"
293
294 test_expect_failure \
295     '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' \
296     "rm -f .git/index AA &&
297      cp .orig-A/AA AA &&
298      echo extra >>AA &&
299      git-update-index --add AA &&
300      git-read-tree -m $tree_O $tree_A $tree_B"
301
302 test_expect_success \
303     '5 - must match in !O && A && B && A==B case.' \
304     "rm -f .git/index LL &&
305      cp .orig-A/LL LL &&
306      git-update-index --add LL &&
307      git-read-tree -m $tree_O $tree_A $tree_B &&
308      check_result"
309
310 test_expect_success \
311     '5 - must match in !O && A && B && A==B case.' \
312     "rm -f .git/index LL &&
313      cp .orig-A/LL LL &&
314      git-update-index --add LL &&
315      echo extra >>LL &&
316      git-read-tree -m $tree_O $tree_A $tree_B &&
317      check_result"
318
319 test_expect_failure \
320     '5 (fail) - must match A in !O && A && B && A==B case.' \
321     "rm -f .git/index LL &&
322      cp .orig-A/LL LL &&
323      echo extra >>LL &&
324      git-update-index --add LL &&
325      git-read-tree -m $tree_O $tree_A $tree_B"
326
327 test_expect_failure \
328     '6 - must not exist in O && !A && !B case' \
329     "rm -f .git/index DD &&
330      echo DD >DD
331      git-update-index --add DD &&
332      git-read-tree -m $tree_O $tree_A $tree_B"
333
334 test_expect_failure \
335     '7 - must not exist in O && !A && B && O!=B case' \
336     "rm -f .git/index DM &&
337      cp .orig-B/DM DM &&
338      git-update-index --add DM &&
339      git-read-tree -m $tree_O $tree_A $tree_B"
340
341 test_expect_failure \
342     '8 - must not exist in O && !A && B && O==B case' \
343     "rm -f .git/index DN &&
344      cp .orig-B/DN DN &&
345      git-update-index --add DN &&
346      git-read-tree -m $tree_O $tree_A $tree_B"
347
348 test_expect_success \
349     '9 - must match and be up-to-date in O && A && !B && O!=A case' \
350     "rm -f .git/index MD &&
351      cp .orig-A/MD MD &&
352      git-update-index --add MD &&
353      git-read-tree -m $tree_O $tree_A $tree_B &&
354      check_result"
355
356 test_expect_failure \
357     '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' \
358     "rm -f .git/index MD &&
359      cp .orig-A/MD MD &&
360      git-update-index --add MD &&
361      echo extra >>MD &&
362      git-read-tree -m $tree_O $tree_A $tree_B"
363
364 test_expect_failure \
365     '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' \
366     "rm -f .git/index MD &&
367      cp .orig-A/MD MD &&
368      echo extra >>MD &&
369      git-update-index --add MD &&
370      git-read-tree -m $tree_O $tree_A $tree_B"
371
372 test_expect_success \
373     '10 - must match and be up-to-date in O && A && !B && O==A case' \
374     "rm -f .git/index ND &&
375      cp .orig-A/ND ND &&
376      git-update-index --add ND &&
377      git-read-tree -m $tree_O $tree_A $tree_B &&
378      check_result"
379
380 test_expect_failure \
381     '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' \
382     "rm -f .git/index ND &&
383      cp .orig-A/ND ND &&
384      git-update-index --add ND &&
385      echo extra >>ND &&
386      git-read-tree -m $tree_O $tree_A $tree_B"
387
388 test_expect_failure \
389     '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' \
390     "rm -f .git/index ND &&
391      cp .orig-A/ND ND &&
392      echo extra >>ND &&
393      git-update-index --add ND &&
394      git-read-tree -m $tree_O $tree_A $tree_B"
395
396 test_expect_success \
397     '11 - 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      git-read-tree -m $tree_O $tree_A $tree_B &&
402      check_result"
403
404 test_expect_failure \
405     '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
406     "rm -f .git/index MM &&
407      cp .orig-A/MM MM &&
408      git-update-index --add MM &&
409      echo extra >>MM &&
410      git-read-tree -m $tree_O $tree_A $tree_B"
411
412 test_expect_failure \
413     '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
414     "rm -f .git/index MM &&
415      cp .orig-A/MM MM &&
416      echo extra >>MM &&
417      git-update-index --add MM &&
418      git-read-tree -m $tree_O $tree_A $tree_B"
419
420 test_expect_success \
421     '12 - must match A in O && A && B && O!=A && A==B case' \
422     "rm -f .git/index SS &&
423      cp .orig-A/SS SS &&
424      git-update-index --add SS &&
425      git-read-tree -m $tree_O $tree_A $tree_B &&
426      check_result"
427
428 test_expect_success \
429     '12 - must match A in O && A && B && O!=A && A==B case' \
430     "rm -f .git/index SS &&
431      cp .orig-A/SS SS &&
432      git-update-index --add SS &&
433      echo extra >>SS &&
434      git-read-tree -m $tree_O $tree_A $tree_B &&
435      check_result"
436
437 test_expect_failure \
438     '12 (fail) - must match A in O && A && B && O!=A && A==B case' \
439     "rm -f .git/index SS &&
440      cp .orig-A/SS SS &&
441      echo extra >>SS &&
442      git-update-index --add SS &&
443      git-read-tree -m $tree_O $tree_A $tree_B"
444
445 test_expect_success \
446     '13 - must match A in O && A && B && O!=A && O==B case' \
447     "rm -f .git/index MN &&
448      cp .orig-A/MN MN &&
449      git-update-index --add MN &&
450      git-read-tree -m $tree_O $tree_A $tree_B &&
451      check_result"
452
453 test_expect_success \
454     '13 - must match A in O && A && B && O!=A && O==B case' \
455     "rm -f .git/index MN &&
456      cp .orig-A/MN MN &&
457      git-update-index --add MN &&
458      echo extra >>MN &&
459      git-read-tree -m $tree_O $tree_A $tree_B &&
460      check_result"
461
462 test_expect_success \
463     '14 - must match and be up-to-date in O && A && B && O==A && O!=B case' \
464     "rm -f .git/index NM &&
465      cp .orig-A/NM NM &&
466      git-update-index --add NM &&
467      git-read-tree -m $tree_O $tree_A $tree_B &&
468      check_result"
469
470 test_expect_success \
471     '14 - may match B in O && A && B && O==A && O!=B case' \
472     "rm -f .git/index NM &&
473      cp .orig-B/NM NM &&
474      git-update-index --add NM &&
475      echo extra >>NM &&
476      git-read-tree -m $tree_O $tree_A $tree_B &&
477      check_result"
478
479 test_expect_failure \
480     '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
481     "rm -f .git/index NM &&
482      cp .orig-A/NM NM &&
483      git-update-index --add NM &&
484      echo extra >>NM &&
485      git-read-tree -m $tree_O $tree_A $tree_B"
486
487 test_expect_failure \
488     '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
489     "rm -f .git/index NM &&
490      cp .orig-A/NM NM &&
491      echo extra >>NM &&
492      git-update-index --add NM &&
493      git-read-tree -m $tree_O $tree_A $tree_B"
494
495 test_expect_success \
496     '15 - must match A in O && A && B && O==A && O==B case' \
497     "rm -f .git/index NN &&
498      cp .orig-A/NN NN &&
499      git-update-index --add NN &&
500      git-read-tree -m $tree_O $tree_A $tree_B &&
501      check_result"
502
503 test_expect_success \
504     '15 - must match A in O && A && B && O==A && O==B case' \
505     "rm -f .git/index NN &&
506      cp .orig-A/NN NN &&
507      git-update-index --add NN &&
508      echo extra >>NN &&
509      git-read-tree -m $tree_O $tree_A $tree_B &&
510      check_result"
511
512 test_expect_failure \
513     '15 (fail) - must match A in O && A && B && O==A && O==B case' \
514     "rm -f .git/index NN &&
515      cp .orig-A/NN NN &&
516      echo extra >>NN &&
517      git-update-index --add NN &&
518      git-read-tree -m $tree_O $tree_A $tree_B"
519
520 # #16
521 test_expect_success \
522     '16 - A matches in one and B matches in another.' \
523     'rm -f .git/index F16 &&
524     echo F16 >F16 &&
525     git-update-index --add F16 &&
526     tree0=`git-write-tree` &&
527     echo E16 >F16 &&
528     git-update-index F16 &&
529     tree1=`git-write-tree` &&
530     git-read-tree -m $tree0 $tree1 $tree1 $tree0 &&
531     git-ls-files --stage'
532
533 test_done