Merge branch 'so/combine-diff-simplify'
[git] / t / t6416-recursive-corner-cases.sh
1 #!/bin/sh
2
3 test_description='recursive merge corner cases involving criss-cross merges'
4
5 . ./test-lib.sh
6
7 #
8 #  L1  L2
9 #   o---o
10 #  / \ / \
11 # o   X   ?
12 #  \ / \ /
13 #   o---o
14 #  R1  R2
15 #
16
17 test_expect_success 'setup basic criss-cross + rename with no modifications' '
18         test_create_repo basic-rename &&
19         (
20                 cd basic-rename &&
21
22                 ten="0 1 2 3 4 5 6 7 8 9" &&
23                 for i in $ten
24                 do
25                         echo line $i in a sample file
26                 done >one &&
27                 for i in $ten
28                 do
29                         echo line $i in another sample file
30                 done >two &&
31                 git add one two &&
32                 test_tick && git commit -m initial &&
33
34                 git branch L1 &&
35                 git checkout -b R1 &&
36                 git mv one three &&
37                 test_tick && git commit -m R1 &&
38
39                 git checkout L1 &&
40                 git mv two three &&
41                 test_tick && git commit -m L1 &&
42
43                 git checkout L1^0 &&
44                 test_tick && git merge -s ours R1 &&
45                 git tag L2 &&
46
47                 git checkout R1^0 &&
48                 test_tick && git merge -s ours L1 &&
49                 git tag R2
50         )
51 '
52
53 test_expect_success 'merge simple rename+criss-cross with no modifications' '
54         (
55                 cd basic-rename &&
56
57                 git reset --hard &&
58                 git checkout L2^0 &&
59
60                 test_must_fail git merge -s recursive R2^0 &&
61
62                 git ls-files -s >out &&
63                 test_line_count = 5 out &&
64                 git ls-files -u >out &&
65                 test_line_count = 3 out &&
66                 git ls-files -o >out &&
67                 test_line_count = 1 out &&
68
69                 git rev-parse >expect       \
70                         L2:three   R2:three &&
71                 git rev-parse   >actual     \
72                         :2:three   :3:three &&
73                 test_cmp expect actual
74         )
75 '
76
77 #
78 # Same as before, but modify L1 slightly:
79 #
80 #  L1m L2
81 #   o---o
82 #  / \ / \
83 # o   X   ?
84 #  \ / \ /
85 #   o---o
86 #  R1  R2
87 #
88
89 test_expect_success 'setup criss-cross + rename merges with basic modification' '
90         test_create_repo rename-modify &&
91         (
92                 cd rename-modify &&
93
94                 ten="0 1 2 3 4 5 6 7 8 9" &&
95                 for i in $ten
96                 do
97                         echo line $i in a sample file
98                 done >one &&
99                 for i in $ten
100                 do
101                         echo line $i in another sample file
102                 done >two &&
103                 git add one two &&
104                 test_tick && git commit -m initial &&
105
106                 git branch L1 &&
107                 git checkout -b R1 &&
108                 git mv one three &&
109                 echo more >>two &&
110                 git add two &&
111                 test_tick && git commit -m R1 &&
112
113                 git checkout L1 &&
114                 git mv two three &&
115                 test_tick && git commit -m L1 &&
116
117                 git checkout L1^0 &&
118                 test_tick && git merge -s ours R1 &&
119                 git tag L2 &&
120
121                 git checkout R1^0 &&
122                 test_tick && git merge -s ours L1 &&
123                 git tag R2
124         )
125 '
126
127 test_expect_success 'merge criss-cross + rename merges with basic modification' '
128         (
129                 cd rename-modify &&
130
131                 git checkout L2^0 &&
132
133                 test_must_fail git merge -s recursive R2^0 &&
134
135                 git ls-files -s >out &&
136                 test_line_count = 5 out &&
137                 git ls-files -u >out &&
138                 test_line_count = 3 out &&
139                 git ls-files -o >out &&
140                 test_line_count = 1 out &&
141
142                 git rev-parse >expect       \
143                         L2:three   R2:three &&
144                 git rev-parse   >actual     \
145                         :2:three   :3:three &&
146                 test_cmp expect actual
147         )
148 '
149
150 #
151 # For the next test, we start with three commits in two lines of development
152 # which setup a rename/add conflict:
153 #   Commit A: File 'a' exists
154 #   Commit B: Rename 'a' -> 'new_a'
155 #   Commit C: Modify 'a', create different 'new_a'
156 # Later, two different people merge and resolve differently:
157 #   Commit D: Merge B & C, ignoring separately created 'new_a'
158 #   Commit E: Merge B & C making use of some piece of secondary 'new_a'
159 # Finally, someone goes to merge D & E.  Does git detect the conflict?
160 #
161 #      B   D
162 #      o---o
163 #     / \ / \
164 #  A o   X   ? F
165 #     \ / \ /
166 #      o---o
167 #      C   E
168 #
169
170 test_expect_success 'setup differently handled merges of rename/add conflict' '
171         test_create_repo rename-add &&
172         (
173                 cd rename-add &&
174
175                 printf "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n" >a &&
176                 git add a &&
177                 test_tick && git commit -m A &&
178
179                 git branch B &&
180                 git checkout -b C &&
181                 echo 10 >>a &&
182                 test_write_lines 0 1 2 3 4 5 6 7 foobar >new_a &&
183                 git add a new_a &&
184                 test_tick && git commit -m C &&
185
186                 git checkout B &&
187                 git mv a new_a &&
188                 test_tick && git commit -m B &&
189
190                 git checkout B^0 &&
191                 test_must_fail git merge C &&
192                 git show :2:new_a >new_a &&
193                 git add new_a &&
194                 test_tick && git commit -m D &&
195                 git tag D &&
196
197                 git checkout C^0 &&
198                 test_must_fail git merge B &&
199                 test_write_lines 0 1 2 3 4 5 6 7 bad_merge >new_a &&
200                 git add -u &&
201                 test_tick && git commit -m E &&
202                 git tag E
203         )
204 '
205
206 test_expect_success 'git detects differently handled merges conflict' '
207         (
208                 cd rename-add &&
209
210                 git checkout D^0 &&
211
212                 test_must_fail git merge -s recursive E^0 &&
213
214                 git ls-files -s >out &&
215                 test_line_count = 3 out &&
216                 git ls-files -u >out &&
217                 test_line_count = 3 out &&
218                 git ls-files -o >out &&
219                 test_line_count = 1 out &&
220
221                 git cat-file -p C:new_a >ours &&
222                 git cat-file -p C:a >theirs &&
223                 >empty &&
224                 test_must_fail git merge-file \
225                         -L "Temporary merge branch 1" \
226                         -L "" \
227                         -L "Temporary merge branch 2" \
228                         ours empty theirs &&
229                 sed -e "s/^\([<=>]\)/\1\1\1/" ours >ours-tweaked &&
230                 git hash-object ours-tweaked >expect &&
231                 git rev-parse >>expect      \
232                                   D:new_a  E:new_a &&
233                 git rev-parse   >actual     \
234                         :1:new_a :2:new_a :3:new_a &&
235                 test_cmp expect actual &&
236
237                 # Test that the two-way merge in new_a is as expected
238                 git cat-file -p D:new_a >ours &&
239                 git cat-file -p E:new_a >theirs &&
240                 >empty &&
241                 test_must_fail git merge-file \
242                         -L "HEAD" \
243                         -L "" \
244                         -L "E^0" \
245                         ours empty theirs &&
246                 sed -e "s/^\([<=>]\)/\1\1\1/" ours >expect &&
247                 git hash-object new_a >actual &&
248                 git hash-object ours  >expect &&
249                 test_cmp expect actual
250         )
251 '
252
253 # Repeat the above testcase with precisely the same setup, other than with
254 # the two merge bases having different orderings of commit timestamps so
255 # that they are reversed in the order they are provided to merge-recursive,
256 # so that we can improve code coverage.
257 test_expect_success 'git detects differently handled merges conflict, swapped' '
258         (
259                 cd rename-add &&
260
261                 # Difference #1: Do cleanup from previous testrun
262                 git reset --hard &&
263                 git clean -fdqx &&
264
265                 # Difference #2: Change commit timestamps
266                 btime=$(git log --no-walk --date=raw --format=%cd B | awk "{print \$1}") &&
267                 ctime=$(git log --no-walk --date=raw --format=%cd C | awk "{print \$1}") &&
268                 newctime=$(($btime+1)) &&
269                 git fast-export --no-data --all | sed -e s/$ctime/$newctime/ | git fast-import --force --quiet &&
270                 # End of most differences; rest is copy-paste of last test,
271                 # other than swapping C:a and C:new_a due to order switch
272
273                 git checkout D^0 &&
274                 test_must_fail git merge -s recursive E^0 &&
275
276                 git ls-files -s >out &&
277                 test_line_count = 3 out &&
278                 git ls-files -u >out &&
279                 test_line_count = 3 out &&
280                 git ls-files -o >out &&
281                 test_line_count = 1 out &&
282
283                 git cat-file -p C:a >ours &&
284                 git cat-file -p C:new_a >theirs &&
285                 >empty &&
286                 test_must_fail git merge-file \
287                         -L "Temporary merge branch 1" \
288                         -L "" \
289                         -L "Temporary merge branch 2" \
290                         ours empty theirs &&
291                 sed -e "s/^\([<=>]\)/\1\1\1/" ours >ours-tweaked &&
292                 git hash-object ours-tweaked >expect &&
293                 git rev-parse >>expect      \
294                                   D:new_a  E:new_a &&
295                 git rev-parse   >actual     \
296                         :1:new_a :2:new_a :3:new_a &&
297                 test_cmp expect actual &&
298
299                 # Test that the two-way merge in new_a is as expected
300                 git cat-file -p D:new_a >ours &&
301                 git cat-file -p E:new_a >theirs &&
302                 >empty &&
303                 test_must_fail git merge-file \
304                         -L "HEAD" \
305                         -L "" \
306                         -L "E^0" \
307                         ours empty theirs &&
308                 sed -e "s/^\([<=>]\)/\1\1\1/" ours >expect &&
309                 git hash-object new_a >actual &&
310                 git hash-object ours  >expect &&
311                 test_cmp expect actual
312         )
313 '
314
315 #
316 # criss-cross + modify/delete:
317 #
318 #      B   D
319 #      o---o
320 #     / \ / \
321 #  A o   X   ? F
322 #     \ / \ /
323 #      o---o
324 #      C   E
325 #
326 #   Commit A: file with contents 'A\n'
327 #   Commit B: file with contents 'B\n'
328 #   Commit C: file not present
329 #   Commit D: file with contents 'B\n'
330 #   Commit E: file not present
331 #
332 # Merging commits D & E should result in modify/delete conflict.
333
334 test_expect_success 'setup criss-cross + modify/delete resolved differently' '
335         test_create_repo modify-delete &&
336         (
337                 cd modify-delete &&
338
339                 echo A >file &&
340                 git add file &&
341                 test_tick &&
342                 git commit -m A &&
343
344                 git branch B &&
345                 git checkout -b C &&
346                 git rm file &&
347                 test_tick &&
348                 git commit -m C &&
349
350                 git checkout B &&
351                 echo B >file &&
352                 git add file &&
353                 test_tick &&
354                 git commit -m B &&
355
356                 git checkout B^0 &&
357                 test_must_fail git merge C &&
358                 echo B >file &&
359                 git add file &&
360                 test_tick &&
361                 git commit -m D &&
362                 git tag D &&
363
364                 git checkout C^0 &&
365                 test_must_fail git merge B &&
366                 git rm file &&
367                 test_tick &&
368                 git commit -m E &&
369                 git tag E
370         )
371 '
372
373 test_expect_success 'git detects conflict merging criss-cross+modify/delete' '
374         (
375                 cd modify-delete &&
376
377                 git checkout D^0 &&
378
379                 test_must_fail git merge -s recursive E^0 &&
380
381                 git ls-files -s >out &&
382                 test_line_count = 2 out &&
383                 git ls-files -u >out &&
384                 test_line_count = 2 out &&
385
386                 git rev-parse >expect       \
387                         master:file  B:file &&
388                 git rev-parse   >actual      \
389                         :1:file      :2:file &&
390                 test_cmp expect actual
391         )
392 '
393
394 test_expect_success 'git detects conflict merging criss-cross+modify/delete, reverse direction' '
395         (
396                 cd modify-delete &&
397
398                 git reset --hard &&
399                 git checkout E^0 &&
400
401                 test_must_fail git merge -s recursive D^0 &&
402
403                 git ls-files -s >out &&
404                 test_line_count = 2 out &&
405                 git ls-files -u >out &&
406                 test_line_count = 2 out &&
407
408                 git rev-parse >expect       \
409                         master:file  B:file &&
410                 git rev-parse   >actual      \
411                         :1:file      :3:file &&
412                 test_cmp expect actual
413         )
414 '
415
416 #      SORRY FOR THE SUPER LONG DESCRIPTION, BUT THIS NEXT ONE IS HAIRY
417 #
418 # criss-cross + d/f conflict via add/add:
419 #   Commit A: Neither file 'a' nor directory 'a/' exists.
420 #   Commit B: Introduce 'a'
421 #   Commit C: Introduce 'a/file'
422 #   Commit D1: Merge B & C, keeping 'a'    and deleting 'a/'
423 #   Commit E1: Merge B & C, deleting 'a' but keeping 'a/file'
424 #
425 #      B   D1 or D2
426 #      o---o
427 #     / \ / \
428 #  A o   X   ? F
429 #     \ / \ /
430 #      o---o
431 #      C   E1 or E2 or E3
432 #
433 # I'll describe D2, E2, & E3 (which are alternatives for D1 & E1) more below...
434 #
435 # Merging D1 & E1 requires we first create a virtual merge base X from
436 # merging A & B in memory.  There are several possibilities for the merge-base:
437 #   1: Keep both 'a' and 'a/file' (assuming crazy filesystem allowing a tree
438 #      with a directory and file at same path): results in merge of D1 & E1
439 #      being clean with both files deleted.  Bad (no conflict detected).
440 #   2: Keep 'a' but not 'a/file': Merging D1 & E1 is clean and matches E1.  Bad.
441 #   3: Keep 'a/file' but not 'a': Merging D1 & E1 is clean and matches D1.  Bad.
442 #   4: Keep neither file: Merging D1 & E1 reports the D/F add/add conflict.
443 #
444 # So 4 sounds good for this case, but if we were to merge D1 & E3, where E3
445 # is defined as:
446 #   Commit E3: Merge B & C, keeping modified a, and deleting a/
447 # then we'd get an add/add conflict for 'a', which seems suboptimal.  A little
448 # creativity leads us to an alternate choice:
449 #   5: Keep 'a' as 'a~$UNIQUE' and a/file; results:
450 #        Merge D1 & E1: rename/delete conflict for 'a'; a/file silently deleted
451 #        Merge D1 & E3 is clean, as expected.
452 #
453 # So choice 5 at least provides some kind of conflict for the original case,
454 # and can merge cleanly as expected with D1 and E3.  It also made things just
455 # slightly funny for merging D1 and E4, where E4 is defined as:
456 #   Commit E4: Merge B & C, modifying 'a' and renaming to 'a2', and deleting 'a/'
457 # in this case, we'll get a rename/rename(1to2) conflict because a~$UNIQUE
458 # gets renamed to 'a' in D1 and to 'a2' in E4.  But that's better than having
459 # two files (both 'a' and 'a2') sitting around without the user being notified
460 # that we could detect they were related and need to be merged.  Also, choice
461 # 5 makes the handling of 'a/file' seem suboptimal.  What if we were to merge
462 # D2 and E4, where D2 is:
463 #   Commit D2: Merge B & C, renaming 'a'->'a2', keeping 'a/file'
464 # This would result in a clean merge with 'a2' having three-way merged
465 # contents (good), and deleting 'a/' (bad) -- it doesn't detect the
466 # conflict in how the different sides treated a/file differently.
467 # Continuing down the creative route:
468 #   6: Keep 'a' as 'a~$UNIQUE1' and keep 'a/' as 'a~$UNIQUE2/'; results:
469 #        Merge D1 & E1: rename/delete conflict for 'a' and each path under 'a/'.
470 #        Merge D1 & E3: clean, as expected.
471 #        Merge D1 & E4: rename/rename(1to2) conflict on 'a' vs 'a2'.
472 #        Merge D2 & E4: clean for 'a2', rename/delete for a/file
473 #
474 # Choice 6 could cause rename detection to take longer (providing more targets
475 # that need to be searched).  Also, the conflict message for each path under
476 # 'a/' might be annoying unless we can detect it at the directory level, print
477 # it once, and then suppress it for individual filepaths underneath.
478 #
479 #
480 # As of time of writing, git uses choice 5.  Directory rename detection and
481 # rename detection performance improvements might make choice 6 a desirable
482 # improvement.  But we can at least document where we fall short for now...
483 #
484 #
485 # Historically, this testcase also used:
486 #   Commit E2: Merge B & C, deleting 'a' but keeping slightly modified 'a/file'
487 # The merge of D1 & E2 is very similar to D1 & E1 -- it has similar issues for
488 # path 'a', but should always result in a modify/delete conflict for path
489 # 'a/file'.  These tests ran the two merges
490 #   D1 & E1
491 #   D1 & E2
492 # in both directions, to check for directional issues with D/F conflict
493 # handling. Later we added
494 #   D1 & E3
495 #   D1 & E4
496 #   D2 & E4
497 # for good measure, though we only ran those one way because we had pretty
498 # good confidence in merge-recursive's directional handling of D/F issues.
499 #
500 # Just to summarize all the intermediate merge commits:
501 #   Commit D1: Merge B & C, keeping a    and deleting a/
502 #   Commit D2: Merge B & C, renaming a->a2, keeping a/file
503 #   Commit E1: Merge B & C, deleting a but keeping a/file
504 #   Commit E2: Merge B & C, deleting a but keeping slightly modified a/file
505 #   Commit E3: Merge B & C, keeping modified a, and deleting a/
506 #   Commit E4: Merge B & C, modifying 'a' and renaming to 'a2', and deleting 'a/'
507 #
508
509 test_expect_success 'setup differently handled merges of directory/file conflict' '
510         test_create_repo directory-file &&
511         (
512                 cd directory-file &&
513
514                 >ignore-me &&
515                 git add ignore-me &&
516                 test_tick &&
517                 git commit -m A &&
518                 git tag A &&
519
520                 git branch B &&
521                 git checkout -b C &&
522                 mkdir a &&
523                 test_write_lines a b c d e f g >a/file &&
524                 git add a/file &&
525                 test_tick &&
526                 git commit -m C &&
527
528                 git checkout B &&
529                 test_write_lines 1 2 3 4 5 6 7 >a &&
530                 git add a &&
531                 test_tick &&
532                 git commit -m B &&
533
534                 git checkout B^0 &&
535                 git merge -s ours -m D1 C^0 &&
536                 git tag D1 &&
537
538                 git checkout B^0 &&
539                 test_must_fail git merge C^0 &&
540                 git clean -fd &&
541                 git rm -rf a/ &&
542                 git rm a &&
543                 git cat-file -p B:a >a2 &&
544                 git add a2 &&
545                 git commit -m D2 &&
546                 git tag D2 &&
547
548                 git checkout C^0 &&
549                 git merge -s ours -m E1 B^0 &&
550                 git tag E1 &&
551
552                 git checkout C^0 &&
553                 git merge -s ours -m E2 B^0 &&
554                 test_write_lines a b c d e f g h >a/file &&
555                 git add a/file &&
556                 git commit --amend -C HEAD &&
557                 git tag E2 &&
558
559                 git checkout C^0 &&
560                 test_must_fail git merge B^0 &&
561                 git clean -fd &&
562                 git rm -rf a/ &&
563                 test_write_lines 1 2 3 4 5 6 7 8 >a &&
564                 git add a &&
565                 git commit -m E3 &&
566                 git tag E3 &&
567
568                 git checkout C^0 &&
569                 test_must_fail git merge B^0 &&
570                 git clean -fd &&
571                 git rm -rf a/ &&
572                 git rm a &&
573                 test_write_lines 1 2 3 4 5 6 7 8 >a2 &&
574                 git add a2 &&
575                 git commit -m E4 &&
576                 git tag E4
577         )
578 '
579
580 test_expect_success 'merge of D1 & E1 fails but has appropriate contents' '
581         test_when_finished "git -C directory-file reset --hard" &&
582         test_when_finished "git -C directory-file clean -fdqx" &&
583         (
584                 cd directory-file &&
585
586                 git checkout D1^0 &&
587
588                 test_must_fail git merge -s recursive E1^0 &&
589
590                 git ls-files -s >out &&
591                 test_line_count = 2 out &&
592                 git ls-files -u >out &&
593                 test_line_count = 1 out &&
594                 git ls-files -o >out &&
595                 test_line_count = 1 out &&
596
597                 git rev-parse >expect    \
598                         A:ignore-me  B:a &&
599                 git rev-parse   >actual   \
600                         :0:ignore-me :2:a &&
601                 test_cmp expect actual
602         )
603 '
604
605 test_expect_success 'merge of E1 & D1 fails but has appropriate contents' '
606         test_when_finished "git -C directory-file reset --hard" &&
607         test_when_finished "git -C directory-file clean -fdqx" &&
608         (
609                 cd directory-file &&
610
611                 git checkout E1^0 &&
612
613                 test_must_fail git merge -s recursive D1^0 &&
614
615                 git ls-files -s >out &&
616                 test_line_count = 2 out &&
617                 git ls-files -u >out &&
618                 test_line_count = 1 out &&
619                 git ls-files -o >out &&
620                 test_line_count = 1 out &&
621
622                 git rev-parse >expect    \
623                         A:ignore-me  B:a &&
624                 git rev-parse   >actual   \
625                         :0:ignore-me :3:a &&
626                 test_cmp expect actual
627         )
628 '
629
630 test_expect_success 'merge of D1 & E2 fails but has appropriate contents' '
631         test_when_finished "git -C directory-file reset --hard" &&
632         test_when_finished "git -C directory-file clean -fdqx" &&
633         (
634                 cd directory-file &&
635
636                 git checkout D1^0 &&
637
638                 test_must_fail git merge -s recursive E2^0 &&
639
640                 git ls-files -s >out &&
641                 test_line_count = 4 out &&
642                 git ls-files -u >out &&
643                 test_line_count = 3 out &&
644                 git ls-files -o >out &&
645                 test_line_count = 2 out &&
646
647                 git rev-parse >expect    \
648                         B:a   E2:a/file  C:a/file   A:ignore-me &&
649                 git rev-parse   >actual   \
650                         :2:a  :3:a/file  :1:a/file  :0:ignore-me &&
651                 test_cmp expect actual &&
652
653                 test_path_is_file a~HEAD
654         )
655 '
656
657 test_expect_success 'merge of E2 & D1 fails but has appropriate contents' '
658         test_when_finished "git -C directory-file reset --hard" &&
659         test_when_finished "git -C directory-file clean -fdqx" &&
660         (
661                 cd directory-file &&
662
663                 git checkout E2^0 &&
664
665                 test_must_fail git merge -s recursive D1^0 &&
666
667                 git ls-files -s >out &&
668                 test_line_count = 4 out &&
669                 git ls-files -u >out &&
670                 test_line_count = 3 out &&
671                 git ls-files -o >out &&
672                 test_line_count = 2 out &&
673
674                 git rev-parse >expect    \
675                         B:a   E2:a/file  C:a/file   A:ignore-me &&
676                 git rev-parse   >actual   \
677                         :3:a  :2:a/file  :1:a/file  :0:ignore-me &&
678                 test_cmp expect actual &&
679
680                 test_path_is_file a~D1^0
681         )
682 '
683
684 test_expect_success 'merge of D1 & E3 succeeds' '
685         test_when_finished "git -C directory-file reset --hard" &&
686         test_when_finished "git -C directory-file clean -fdqx" &&
687         (
688                 cd directory-file &&
689
690                 git checkout D1^0 &&
691
692                 git merge -s recursive E3^0 &&
693
694                 git ls-files -s >out &&
695                 test_line_count = 2 out &&
696                 git ls-files -u >out &&
697                 test_line_count = 0 out &&
698                 git ls-files -o >out &&
699                 test_line_count = 1 out &&
700
701                 git rev-parse >expect    \
702                         A:ignore-me  E3:a &&
703                 git rev-parse   >actual   \
704                         :0:ignore-me :0:a &&
705                 test_cmp expect actual
706         )
707 '
708
709 test_expect_success 'merge of D1 & E4 notifies user a and a2 are related' '
710         test_when_finished "git -C directory-file reset --hard" &&
711         test_when_finished "git -C directory-file clean -fdqx" &&
712         (
713                 cd directory-file &&
714
715                 git checkout D1^0 &&
716
717                 test_must_fail git merge -s recursive E4^0 &&
718
719                 git ls-files -s >out &&
720                 test_line_count = 4 out &&
721                 git ls-files -u >out &&
722                 test_line_count = 3 out &&
723                 git ls-files -o >out &&
724                 test_line_count = 1 out &&
725
726                 git rev-parse >expect                  \
727                         A:ignore-me  B:a   D1:a  E4:a2 &&
728                 git rev-parse   >actual                \
729                         :0:ignore-me :1:a~Temporary\ merge\ branch\ 2  :2:a  :3:a2 &&
730                 test_cmp expect actual
731         )
732 '
733
734 test_expect_failure 'merge of D2 & E4 merges a2s & reports conflict for a/file' '
735         test_when_finished "git -C directory-file reset --hard" &&
736         test_when_finished "git -C directory-file clean -fdqx" &&
737         (
738                 cd directory-file &&
739
740                 git checkout D2^0 &&
741
742                 test_must_fail git merge -s recursive E4^0 &&
743
744                 git ls-files -s >out &&
745                 test_line_count = 3 out &&
746                 git ls-files -u >out &&
747                 test_line_count = 1 out &&
748                 git ls-files -o >out &&
749                 test_line_count = 1 out &&
750
751                 git rev-parse >expect                 \
752                         A:ignore-me  E4:a2  D2:a/file &&
753                 git rev-parse   >actual               \
754                         :0:ignore-me :0:a2  :2:a/file &&
755                 test_cmp expect actual
756         )
757 '
758
759 #
760 # criss-cross with rename/rename(1to2)/modify followed by
761 # rename/rename(2to1)/modify:
762 #
763 #      B   D
764 #      o---o
765 #     / \ / \
766 #  A o   X   ? F
767 #     \ / \ /
768 #      o---o
769 #      C   E
770 #
771 #   Commit A: new file: a
772 #   Commit B: rename a->b, modifying by adding a line
773 #   Commit C: rename a->c
774 #   Commit D: merge B&C, resolving conflict by keeping contents in newname
775 #   Commit E: merge B&C, resolving conflict similar to D but adding another line
776 #
777 # There is a conflict merging B & C, but one of filename not of file
778 # content.  Whoever created D and E chose specific resolutions for that
779 # conflict resolution.  Now, since: (1) there is no content conflict
780 # merging B & C, (2) D does not modify that merged content further, and (3)
781 # both D & E resolve the name conflict in the same way, the modification to
782 # newname in E should not cause any conflicts when it is merged with D.
783 # (Note that this can be accomplished by having the virtual merge base have
784 # the merged contents of b and c stored in a file named a, which seems like
785 # the most logical choice anyway.)
786 #
787 # Comment from Junio: I do not necessarily agree with the choice "a", but
788 # it feels sound to say "B and C do not agree what the final pathname
789 # should be, but we know this content was derived from the common A:a so we
790 # use one path whose name is arbitrary in the virtual merge base X between
791 # D and E" and then further let the rename detection to notice that that
792 # arbitrary path gets renamed between X-D to "newname" and X-E also to
793 # "newname" to resolve it as both sides renaming it to the same new
794 # name. It is akin to what we do at the content level, i.e. "B and C do not
795 # agree what the final contents should be, so we leave the conflict marker
796 # but that may cancel out at the final merge stage".
797
798 test_expect_success 'setup rename/rename(1to2)/modify followed by what looks like rename/rename(2to1)/modify' '
799         test_create_repo rename-squared-squared &&
800         (
801                 cd rename-squared-squared &&
802
803                 printf "1\n2\n3\n4\n5\n6\n" >a &&
804                 git add a &&
805                 git commit -m A &&
806                 git tag A &&
807
808                 git checkout -b B A &&
809                 git mv a b &&
810                 echo 7 >>b &&
811                 git add -u &&
812                 git commit -m B &&
813
814                 git checkout -b C A &&
815                 git mv a c &&
816                 git commit -m C &&
817
818                 git checkout -q B^0 &&
819                 git merge --no-commit -s ours C^0 &&
820                 git mv b newname &&
821                 git commit -m "Merge commit C^0 into HEAD" &&
822                 git tag D &&
823
824                 git checkout -q C^0 &&
825                 git merge --no-commit -s ours B^0 &&
826                 git mv c newname &&
827                 printf "7\n8\n" >>newname &&
828                 git add -u &&
829                 git commit -m "Merge commit B^0 into HEAD" &&
830                 git tag E
831         )
832 '
833
834 test_expect_success 'handle rename/rename(1to2)/modify followed by what looks like rename/rename(2to1)/modify' '
835         (
836                 cd rename-squared-squared &&
837
838                 git checkout D^0 &&
839
840                 git merge -s recursive E^0 &&
841
842                 git ls-files -s >out &&
843                 test_line_count = 1 out &&
844                 git ls-files -u >out &&
845                 test_line_count = 0 out &&
846                 git ls-files -o >out &&
847                 test_line_count = 1 out &&
848
849                 test $(git rev-parse HEAD:newname) = $(git rev-parse E:newname)
850         )
851 '
852
853 #
854 # criss-cross with rename/rename(1to2)/add-source + resolvable modify/modify:
855 #
856 #      B   D
857 #      o---o
858 #     / \ / \
859 #  A o   X   ? F
860 #     \ / \ /
861 #      o---o
862 #      C   E
863 #
864 #   Commit A: new file: a
865 #   Commit B: rename a->b
866 #   Commit C: rename a->c, add different a
867 #   Commit D: merge B&C, keeping b&c and (new) a modified at beginning
868 #   Commit E: merge B&C, keeping b&c and (new) a modified at end
869 #
870 # Merging commits D & E should result in no conflict; doing so correctly
871 # requires getting the virtual merge base (from merging B&C) right, handling
872 # renaming carefully (both in the virtual merge base and later), and getting
873 # content merge handled.
874
875 test_expect_success 'setup criss-cross + rename/rename/add-source + modify/modify' '
876         test_create_repo rename-rename-add-source &&
877         (
878                 cd rename-rename-add-source &&
879
880                 printf "lots\nof\nwords\nand\ncontent\n" >a &&
881                 git add a &&
882                 git commit -m A &&
883                 git tag A &&
884
885                 git checkout -b B A &&
886                 git mv a b &&
887                 git commit -m B &&
888
889                 git checkout -b C A &&
890                 git mv a c &&
891                 printf "2\n3\n4\n5\n6\n7\n" >a &&
892                 git add a &&
893                 git commit -m C &&
894
895                 git checkout B^0 &&
896                 git merge --no-commit -s ours C^0 &&
897                 git checkout C -- a c &&
898                 mv a old_a &&
899                 echo 1 >a &&
900                 cat old_a >>a &&
901                 rm old_a &&
902                 git add -u &&
903                 git commit -m "Merge commit C^0 into HEAD" &&
904                 git tag D &&
905
906                 git checkout C^0 &&
907                 git merge --no-commit -s ours B^0 &&
908                 git checkout B -- b &&
909                 echo 8 >>a &&
910                 git add -u &&
911                 git commit -m "Merge commit B^0 into HEAD" &&
912                 git tag E
913         )
914 '
915
916 test_expect_failure 'detect rename/rename/add-source for virtual merge-base' '
917         (
918                 cd rename-rename-add-source &&
919
920                 git checkout D^0 &&
921
922                 git merge -s recursive E^0 &&
923
924                 git ls-files -s >out &&
925                 test_line_count = 3 out &&
926                 git ls-files -u >out &&
927                 test_line_count = 0 out &&
928                 git ls-files -o >out &&
929                 test_line_count = 1 out &&
930
931                 printf "1\n2\n3\n4\n5\n6\n7\n8\n" >correct &&
932                 git rev-parse >expect \
933                         A:a   A:a     \
934                         correct       &&
935                 git rev-parse   >actual  \
936                         :0:b  :0:c       &&
937                 git hash-object >>actual \
938                         a                &&
939                 test_cmp expect actual
940         )
941 '
942
943 #
944 # criss-cross with rename/rename(1to2)/add-dest + simple modify:
945 #
946 #      B   D
947 #      o---o
948 #     / \ / \
949 #  A o   X   ? F
950 #     \ / \ /
951 #      o---o
952 #      C   E
953 #
954 #   Commit A: new file: a
955 #   Commit B: rename a->b, add c
956 #   Commit C: rename a->c
957 #   Commit D: merge B&C, keeping A:a and B:c
958 #   Commit E: merge B&C, keeping A:a and slightly modified c from B
959 #
960 # Merging commits D & E should result in no conflict.  The virtual merge
961 # base of B & C needs to not delete B:c for that to work, though...
962
963 test_expect_success 'setup criss-cross+rename/rename/add-dest + simple modify' '
964         test_create_repo rename-rename-add-dest &&
965         (
966                 cd rename-rename-add-dest &&
967
968                 >a &&
969                 git add a &&
970                 git commit -m A &&
971                 git tag A &&
972
973                 git checkout -b B A &&
974                 git mv a b &&
975                 printf "1\n2\n3\n4\n5\n6\n7\n" >c &&
976                 git add c &&
977                 git commit -m B &&
978
979                 git checkout -b C A &&
980                 git mv a c &&
981                 git commit -m C &&
982
983                 git checkout B^0 &&
984                 git merge --no-commit -s ours C^0 &&
985                 git mv b a &&
986                 git commit -m "D is like B but renames b back to a" &&
987                 git tag D &&
988
989                 git checkout B^0 &&
990                 git merge --no-commit -s ours C^0 &&
991                 git mv b a &&
992                 echo 8 >>c &&
993                 git add c &&
994                 git commit -m "E like D but has mod in c" &&
995                 git tag E
996         )
997 '
998
999 test_expect_success 'virtual merge base handles rename/rename(1to2)/add-dest' '
1000         (
1001                 cd rename-rename-add-dest &&
1002
1003                 git checkout D^0 &&
1004
1005                 git merge -s recursive E^0 &&
1006
1007                 git ls-files -s >out &&
1008                 test_line_count = 2 out &&
1009                 git ls-files -u >out &&
1010                 test_line_count = 0 out &&
1011                 git ls-files -o >out &&
1012                 test_line_count = 1 out &&
1013
1014                 git rev-parse >expect \
1015                         A:a   E:c     &&
1016                 git rev-parse   >actual \
1017                         :0:a  :0:c      &&
1018                 test_cmp expect actual
1019         )
1020 '
1021
1022 #
1023 # criss-cross with modify/modify on a symlink:
1024 #
1025 #      B   D
1026 #      o---o
1027 #     / \ / \
1028 #  A o   X   ? F
1029 #     \ / \ /
1030 #      o---o
1031 #      C   E
1032 #
1033 #   Commit A: simple simlink fickle->lagoon
1034 #   Commit B: redirect fickle->disneyland
1035 #   Commit C: redirect fickle->home
1036 #   Commit D: merge B&C, resolving in favor of B
1037 #   Commit E: merge B&C, resolving in favor of C
1038 #
1039 # This is an obvious modify/modify conflict for the symlink 'fickle'.  Can
1040 # git detect it?
1041
1042 test_expect_success 'setup symlink modify/modify' '
1043         test_create_repo symlink-modify-modify &&
1044         (
1045                 cd symlink-modify-modify &&
1046
1047                 test_ln_s_add lagoon fickle &&
1048                 git commit -m A &&
1049                 git tag A &&
1050
1051                 git checkout -b B A &&
1052                 git rm fickle &&
1053                 test_ln_s_add disneyland fickle &&
1054                 git commit -m B &&
1055
1056                 git checkout -b C A &&
1057                 git rm fickle &&
1058                 test_ln_s_add home fickle &&
1059                 git add fickle &&
1060                 git commit -m C &&
1061
1062                 git checkout -q B^0 &&
1063                 git merge -s ours -m D C^0 &&
1064                 git tag D &&
1065
1066                 git checkout -q C^0 &&
1067                 git merge -s ours -m E B^0 &&
1068                 git tag E
1069         )
1070 '
1071
1072 test_expect_failure 'check symlink modify/modify' '
1073         (
1074                 cd symlink-modify-modify &&
1075
1076                 git checkout D^0 &&
1077
1078                 test_must_fail git merge -s recursive E^0 &&
1079
1080                 git ls-files -s >out &&
1081                 test_line_count = 3 out &&
1082                 git ls-files -u >out &&
1083                 test_line_count = 3 out &&
1084                 git ls-files -o >out &&
1085                 test_line_count = 1 out
1086         )
1087 '
1088
1089 #
1090 # criss-cross with add/add of a symlink:
1091 #
1092 #      B   D
1093 #      o---o
1094 #     / \ / \
1095 #  A o   X   ? F
1096 #     \ / \ /
1097 #      o---o
1098 #      C   E
1099 #
1100 #   Commit A: No symlink or path exists yet
1101 #   Commit B: set up symlink: fickle->disneyland
1102 #   Commit C: set up symlink: fickle->home
1103 #   Commit D: merge B&C, resolving in favor of B
1104 #   Commit E: merge B&C, resolving in favor of C
1105 #
1106 # This is an obvious add/add conflict for the symlink 'fickle'.  Can
1107 # git detect it?
1108
1109 test_expect_success 'setup symlink add/add' '
1110         test_create_repo symlink-add-add &&
1111         (
1112                 cd symlink-add-add &&
1113
1114                 touch ignoreme &&
1115                 git add ignoreme &&
1116                 git commit -m A &&
1117                 git tag A &&
1118
1119                 git checkout -b B A &&
1120                 test_ln_s_add disneyland fickle &&
1121                 git commit -m B &&
1122
1123                 git checkout -b C A &&
1124                 test_ln_s_add home fickle &&
1125                 git add fickle &&
1126                 git commit -m C &&
1127
1128                 git checkout -q B^0 &&
1129                 git merge -s ours -m D C^0 &&
1130                 git tag D &&
1131
1132                 git checkout -q C^0 &&
1133                 git merge -s ours -m E B^0 &&
1134                 git tag E
1135         )
1136 '
1137
1138 test_expect_failure 'check symlink add/add' '
1139         (
1140                 cd symlink-add-add &&
1141
1142                 git checkout D^0 &&
1143
1144                 test_must_fail git merge -s recursive E^0 &&
1145
1146                 git ls-files -s >out &&
1147                 test_line_count = 3 out &&
1148                 git ls-files -u >out &&
1149                 test_line_count = 2 out &&
1150                 git ls-files -o >out &&
1151                 test_line_count = 1 out
1152         )
1153 '
1154
1155 #
1156 # criss-cross with modify/modify on a submodule:
1157 #
1158 #      B   D
1159 #      o---o
1160 #     / \ / \
1161 #  A o   X   ? F
1162 #     \ / \ /
1163 #      o---o
1164 #      C   E
1165 #
1166 #   Commit A: simple submodule repo
1167 #   Commit B: update repo
1168 #   Commit C: update repo differently
1169 #   Commit D: merge B&C, resolving in favor of B
1170 #   Commit E: merge B&C, resolving in favor of C
1171 #
1172 # This is an obvious modify/modify conflict for the submodule 'repo'.  Can
1173 # git detect it?
1174
1175 test_expect_success 'setup submodule modify/modify' '
1176         test_create_repo submodule-modify-modify &&
1177         (
1178                 cd submodule-modify-modify &&
1179
1180                 test_create_repo submod &&
1181                 (
1182                         cd submod &&
1183                         touch file-A &&
1184                         git add file-A &&
1185                         git commit -m A &&
1186                         git tag A &&
1187
1188                         git checkout -b B A &&
1189                         touch file-B &&
1190                         git add file-B &&
1191                         git commit -m B &&
1192                         git tag B &&
1193
1194                         git checkout -b C A &&
1195                         touch file-C &&
1196                         git add file-C &&
1197                         git commit -m C &&
1198                         git tag C
1199                 ) &&
1200
1201                 git -C submod reset --hard A &&
1202                 git add submod &&
1203                 git commit -m A &&
1204                 git tag A &&
1205
1206                 git checkout -b B A &&
1207                 git -C submod reset --hard B &&
1208                 git add submod &&
1209                 git commit -m B &&
1210
1211                 git checkout -b C A &&
1212                 git -C submod reset --hard C &&
1213                 git add submod &&
1214                 git commit -m C &&
1215
1216                 git checkout -q B^0 &&
1217                 git merge -s ours -m D C^0 &&
1218                 git tag D &&
1219
1220                 git checkout -q C^0 &&
1221                 git merge -s ours -m E B^0 &&
1222                 git tag E
1223         )
1224 '
1225
1226 test_expect_failure 'check submodule modify/modify' '
1227         (
1228                 cd submodule-modify-modify &&
1229
1230                 git checkout D^0 &&
1231
1232                 test_must_fail git merge -s recursive E^0 &&
1233
1234                 git ls-files -s >out &&
1235                 test_line_count = 3 out &&
1236                 git ls-files -u >out &&
1237                 test_line_count = 3 out &&
1238                 git ls-files -o >out &&
1239                 test_line_count = 1 out
1240         )
1241 '
1242
1243 #
1244 # criss-cross with add/add on a submodule:
1245 #
1246 #      B   D
1247 #      o---o
1248 #     / \ / \
1249 #  A o   X   ? F
1250 #     \ / \ /
1251 #      o---o
1252 #      C   E
1253 #
1254 #   Commit A: nothing of note
1255 #   Commit B: introduce submodule repo
1256 #   Commit C: introduce submodule repo at different commit
1257 #   Commit D: merge B&C, resolving in favor of B
1258 #   Commit E: merge B&C, resolving in favor of C
1259 #
1260 # This is an obvious add/add conflict for the submodule 'repo'.  Can
1261 # git detect it?
1262
1263 test_expect_success 'setup submodule add/add' '
1264         test_create_repo submodule-add-add &&
1265         (
1266                 cd submodule-add-add &&
1267
1268                 test_create_repo submod &&
1269                 (
1270                         cd submod &&
1271                         touch file-A &&
1272                         git add file-A &&
1273                         git commit -m A &&
1274                         git tag A &&
1275
1276                         git checkout -b B A &&
1277                         touch file-B &&
1278                         git add file-B &&
1279                         git commit -m B &&
1280                         git tag B &&
1281
1282                         git checkout -b C A &&
1283                         touch file-C &&
1284                         git add file-C &&
1285                         git commit -m C &&
1286                         git tag C
1287                 ) &&
1288
1289                 touch irrelevant-file &&
1290                 git add irrelevant-file &&
1291                 git commit -m A &&
1292                 git tag A &&
1293
1294                 git checkout -b B A &&
1295                 git -C submod reset --hard B &&
1296                 git add submod &&
1297                 git commit -m B &&
1298
1299                 git checkout -b C A &&
1300                 git -C submod reset --hard C &&
1301                 git add submod &&
1302                 git commit -m C &&
1303
1304                 git checkout -q B^0 &&
1305                 git merge -s ours -m D C^0 &&
1306                 git tag D &&
1307
1308                 git checkout -q C^0 &&
1309                 git merge -s ours -m E B^0 &&
1310                 git tag E
1311         )
1312 '
1313
1314 test_expect_failure 'check submodule add/add' '
1315         (
1316                 cd submodule-add-add &&
1317
1318                 git checkout D^0 &&
1319
1320                 test_must_fail git merge -s recursive E^0 &&
1321
1322                 git ls-files -s >out &&
1323                 test_line_count = 3 out &&
1324                 git ls-files -u >out &&
1325                 test_line_count = 2 out &&
1326                 git ls-files -o >out &&
1327                 test_line_count = 1 out
1328         )
1329 '
1330
1331 #
1332 # criss-cross with conflicting entry types:
1333 #
1334 #      B   D
1335 #      o---o
1336 #     / \ / \
1337 #  A o   X   ? F
1338 #     \ / \ /
1339 #      o---o
1340 #      C   E
1341 #
1342 #   Commit A: nothing of note
1343 #   Commit B: introduce submodule 'path'
1344 #   Commit C: introduce symlink 'path'
1345 #   Commit D: merge B&C, resolving in favor of B
1346 #   Commit E: merge B&C, resolving in favor of C
1347 #
1348 # This is an obvious add/add conflict for 'path'.  Can git detect it?
1349
1350 test_expect_success 'setup conflicting entry types (submodule vs symlink)' '
1351         test_create_repo submodule-symlink-add-add &&
1352         (
1353                 cd submodule-symlink-add-add &&
1354
1355                 test_create_repo path &&
1356                 (
1357                         cd path &&
1358                         touch file-B &&
1359                         git add file-B &&
1360                         git commit -m B &&
1361                         git tag B
1362                 ) &&
1363
1364                 touch irrelevant-file &&
1365                 git add irrelevant-file &&
1366                 git commit -m A &&
1367                 git tag A &&
1368
1369                 git checkout -b B A &&
1370                 git -C path reset --hard B &&
1371                 git add path &&
1372                 git commit -m B &&
1373
1374                 git checkout -b C A &&
1375                 rm -rf path/ &&
1376                 test_ln_s_add irrelevant-file path &&
1377                 git commit -m C &&
1378
1379                 git checkout -q B^0 &&
1380                 git merge -s ours -m D C^0 &&
1381                 git tag D &&
1382
1383                 git checkout -q C^0 &&
1384                 git merge -s ours -m E B^0 &&
1385                 git tag E
1386         )
1387 '
1388
1389 test_expect_failure 'check conflicting entry types (submodule vs symlink)' '
1390         (
1391                 cd submodule-symlink-add-add &&
1392
1393                 git checkout D^0 &&
1394
1395                 test_must_fail git merge -s recursive E^0 &&
1396
1397                 git ls-files -s >out &&
1398                 test_line_count = 3 out &&
1399                 git ls-files -u >out &&
1400                 test_line_count = 2 out &&
1401                 git ls-files -o >out &&
1402                 test_line_count = 1 out
1403         )
1404 '
1405
1406 #
1407 # criss-cross with regular files that have conflicting modes:
1408 #
1409 #      B   D
1410 #      o---o
1411 #     / \ / \
1412 #  A o   X   ? F
1413 #     \ / \ /
1414 #      o---o
1415 #      C   E
1416 #
1417 #   Commit A: nothing of note
1418 #   Commit B: introduce file source_me.bash, not executable
1419 #   Commit C: introduce file source_me.bash, executable
1420 #   Commit D: merge B&C, resolving in favor of B
1421 #   Commit E: merge B&C, resolving in favor of C
1422 #
1423 # This is an obvious add/add mode conflict.  Can git detect it?
1424
1425 test_expect_success 'setup conflicting modes for regular file' '
1426         test_create_repo regular-file-mode-conflict &&
1427         (
1428                 cd regular-file-mode-conflict &&
1429
1430                 touch irrelevant-file &&
1431                 git add irrelevant-file &&
1432                 git commit -m A &&
1433                 git tag A &&
1434
1435                 git checkout -b B A &&
1436                 echo "command_to_run" >source_me.bash &&
1437                 git add source_me.bash &&
1438                 git commit -m B &&
1439
1440                 git checkout -b C A &&
1441                 echo "command_to_run" >source_me.bash &&
1442                 git add source_me.bash &&
1443                 test_chmod +x source_me.bash &&
1444                 git commit -m C &&
1445
1446                 git checkout -q B^0 &&
1447                 git merge -s ours -m D C^0 &&
1448                 git tag D &&
1449
1450                 git checkout -q C^0 &&
1451                 git merge -s ours -m E B^0 &&
1452                 git tag E
1453         )
1454 '
1455
1456 test_expect_failure 'check conflicting modes for regular file' '
1457         (
1458                 cd regular-file-mode-conflict &&
1459
1460                 git checkout D^0 &&
1461
1462                 test_must_fail git merge -s recursive E^0 &&
1463
1464                 git ls-files -s >out &&
1465                 test_line_count = 3 out &&
1466                 git ls-files -u >out &&
1467                 test_line_count = 2 out &&
1468                 git ls-files -o >out &&
1469                 test_line_count = 1 out
1470         )
1471 '
1472
1473 # Setup:
1474 #          L1---L2
1475 #         /  \ /  \
1476 #   master    X    ?
1477 #         \  / \  /
1478 #          R1---R2
1479 #
1480 # Where:
1481 #   master has two files, named 'b' and 'a'
1482 #   branches L1 and R1 both modify each of the two files in conflicting ways
1483 #
1484 #   L2 is a merge of R1 into L1; more on it later.
1485 #   R2 is a merge of L1 into R1; more on it later.
1486 #
1487 #   X is an auto-generated merge-base used when merging L2 and R2.
1488 #   since X is a merge of L1 and R1, it has conflicting versions of each file
1489 #
1490 #   More about L2 and R2:
1491 #     - both resolve the conflicts in 'b' and 'a' differently
1492 #     - L2 renames 'b' to 'm'
1493 #     - R2 renames 'a' to 'm'
1494 #
1495 #   In the end, in file 'm' we have four different conflicting files (from
1496 #   two versions of 'b' and two of 'a').  In addition, if
1497 #   merge.conflictstyle is diff3, then the base version also has
1498 #   conflict markers of its own, leading to a total of three levels of
1499 #   conflict markers.  This is a pretty weird corner case, but we just want
1500 #   to ensure that we handle it as well as practical.
1501
1502 test_expect_success 'setup nested conflicts' '
1503         test_create_repo nested_conflicts &&
1504         (
1505                 cd nested_conflicts &&
1506
1507                 # Create some related files now
1508                 for i in $(test_seq 1 10)
1509                 do
1510                         echo Random base content line $i
1511                 done >initial &&
1512
1513                 cp initial b_L1 &&
1514                 cp initial b_R1 &&
1515                 cp initial b_L2 &&
1516                 cp initial b_R2 &&
1517                 cp initial a_L1 &&
1518                 cp initial a_R1 &&
1519                 cp initial a_L2 &&
1520                 cp initial a_R2 &&
1521
1522                 test_write_lines b b_L1 >>b_L1 &&
1523                 test_write_lines b b_R1 >>b_R1 &&
1524                 test_write_lines b b_L2 >>b_L2 &&
1525                 test_write_lines b b_R2 >>b_R2 &&
1526                 test_write_lines a a_L1 >>a_L1 &&
1527                 test_write_lines a a_R1 >>a_R1 &&
1528                 test_write_lines a a_L2 >>a_L2 &&
1529                 test_write_lines a a_R2 >>a_R2 &&
1530
1531                 # Setup original commit (or merge-base), consisting of
1532                 # files named "b" and "a"
1533                 cp initial b &&
1534                 cp initial a &&
1535                 echo b >>b &&
1536                 echo a >>a &&
1537                 git add b a &&
1538                 test_tick && git commit -m initial &&
1539
1540                 git branch L &&
1541                 git branch R &&
1542
1543                 # Handle the left side
1544                 git checkout L &&
1545                 mv -f b_L1 b &&
1546                 mv -f a_L1 a &&
1547                 git add b a &&
1548                 test_tick && git commit -m "version L1 of files" &&
1549                 git tag L1 &&
1550
1551                 # Handle the right side
1552                 git checkout R &&
1553                 mv -f b_R1 b &&
1554                 mv -f a_R1 a &&
1555                 git add b a &&
1556                 test_tick && git commit -m "version R1 of files" &&
1557                 git tag R1 &&
1558
1559                 # Create first merge on left side
1560                 git checkout L &&
1561                 test_must_fail git merge R1 &&
1562                 mv -f b_L2 b &&
1563                 mv -f a_L2 a &&
1564                 git add b a &&
1565                 git mv b m &&
1566                 test_tick && git commit -m "left merge, rename b->m" &&
1567                 git tag L2 &&
1568
1569                 # Create first merge on right side
1570                 git checkout R &&
1571                 test_must_fail git merge L1 &&
1572                 mv -f b_R2 b &&
1573                 mv -f a_R2 a &&
1574                 git add b a &&
1575                 git mv a m &&
1576                 test_tick && git commit -m "right merge, rename a->m" &&
1577                 git tag R2
1578         )
1579 '
1580
1581 test_expect_success 'check nested conflicts' '
1582         (
1583                 cd nested_conflicts &&
1584
1585                 git clean -f &&
1586                 MASTER=$(git rev-parse --short master) &&
1587                 git checkout L2^0 &&
1588
1589                 # Merge must fail; there is a conflict
1590                 test_must_fail git -c merge.conflictstyle=diff3 merge -s recursive R2^0 &&
1591
1592                 # Make sure the index has the right number of entries
1593                 git ls-files -s >out &&
1594                 test_line_count = 2 out &&
1595                 git ls-files -u >out &&
1596                 test_line_count = 2 out &&
1597                 # Ensure we have the correct number of untracked files
1598                 git ls-files -o >out &&
1599                 test_line_count = 1 out &&
1600
1601                 # Create a and b from virtual merge base X
1602                 git cat-file -p master:a >base &&
1603                 git cat-file -p L1:a >ours &&
1604                 git cat-file -p R1:a >theirs &&
1605                 test_must_fail git merge-file --diff3 \
1606                         -L "Temporary merge branch 1" \
1607                         -L "$MASTER"  \
1608                         -L "Temporary merge branch 2" \
1609                         ours  \
1610                         base  \
1611                         theirs &&
1612                 sed -e "s/^\([<|=>]\)/\1\1/" ours >vmb_a &&
1613
1614                 git cat-file -p master:b >base &&
1615                 git cat-file -p L1:b >ours &&
1616                 git cat-file -p R1:b >theirs &&
1617                 test_must_fail git merge-file --diff3 \
1618                         -L "Temporary merge branch 1" \
1619                         -L "$MASTER"  \
1620                         -L "Temporary merge branch 2" \
1621                         ours  \
1622                         base  \
1623                         theirs &&
1624                 sed -e "s/^\([<|=>]\)/\1\1/" ours >vmb_b &&
1625
1626                 # Compare :2:m to expected values
1627                 git cat-file -p L2:m >ours &&
1628                 git cat-file -p R2:b >theirs &&
1629                 test_must_fail git merge-file --diff3  \
1630                         -L "HEAD:m"                    \
1631                         -L "merged common ancestors:b" \
1632                         -L "R2^0:b"                    \
1633                         ours                           \
1634                         vmb_b                          \
1635                         theirs                         &&
1636                 sed -e "s/^\([<|=>]\)/\1\1/" ours >m_stage_2 &&
1637                 git cat-file -p :2:m >actual &&
1638                 test_cmp m_stage_2 actual &&
1639
1640                 # Compare :3:m to expected values
1641                 git cat-file -p L2:a >ours &&
1642                 git cat-file -p R2:m >theirs &&
1643                 test_must_fail git merge-file --diff3  \
1644                         -L "HEAD:a"                    \
1645                         -L "merged common ancestors:a" \
1646                         -L "R2^0:m"                    \
1647                         ours                           \
1648                         vmb_a                          \
1649                         theirs                         &&
1650                 sed -e "s/^\([<|=>]\)/\1\1/" ours >m_stage_3 &&
1651                 git cat-file -p :3:m >actual &&
1652                 test_cmp m_stage_3 actual &&
1653
1654                 # Compare m to expected contents
1655                 >empty &&
1656                 cp m_stage_2 expected_final_m &&
1657                 test_must_fail git merge-file --diff3 \
1658                         -L "HEAD"                     \
1659                         -L "merged common ancestors"  \
1660                         -L "R2^0"                     \
1661                         expected_final_m              \
1662                         empty                         \
1663                         m_stage_3                     &&
1664                 test_cmp expected_final_m m
1665         )
1666 '
1667
1668 # Setup:
1669 #          L1---L2---L3
1670 #         /  \ /  \ /  \
1671 #   master    X1   X2   ?
1672 #         \  / \  / \  /
1673 #          R1---R2---R3
1674 #
1675 # Where:
1676 #   master has one file named 'content'
1677 #   branches L1 and R1 both modify each of the two files in conflicting ways
1678 #
1679 #   L<n> (n>1) is a merge of R<n-1> into L<n-1>
1680 #   R<n> (n>1) is a merge of L<n-1> into R<n-1>
1681 #   L<n> and R<n> resolve the conflicts differently.
1682 #
1683 #   X<n> is an auto-generated merge-base used when merging L<n+1> and R<n+1>.
1684 #   By construction, X1 has conflict markers due to conflicting versions.
1685 #   X2, due to using merge.conflictstyle=3, has nested conflict markers.
1686 #
1687 #   So, merging R3 into L3 using merge.conflictstyle=3 should show the
1688 #   nested conflict markers from X2 in the base version -- that means we
1689 #   have three levels of conflict markers.  Can we distinguish all three?
1690
1691 test_expect_success 'setup virtual merge base with nested conflicts' '
1692         test_create_repo virtual_merge_base_has_nested_conflicts &&
1693         (
1694                 cd virtual_merge_base_has_nested_conflicts &&
1695
1696                 # Create some related files now
1697                 for i in $(test_seq 1 10)
1698                 do
1699                         echo Random base content line $i
1700                 done >content &&
1701
1702                 # Setup original commit
1703                 git add content &&
1704                 test_tick && git commit -m initial &&
1705
1706                 git branch L &&
1707                 git branch R &&
1708
1709                 # Create L1
1710                 git checkout L &&
1711                 echo left >>content &&
1712                 git add content &&
1713                 test_tick && git commit -m "version L1 of content" &&
1714                 git tag L1 &&
1715
1716                 # Create R1
1717                 git checkout R &&
1718                 echo right >>content &&
1719                 git add content &&
1720                 test_tick && git commit -m "version R1 of content" &&
1721                 git tag R1 &&
1722
1723                 # Create L2
1724                 git checkout L &&
1725                 test_must_fail git -c merge.conflictstyle=diff3 merge R1 &&
1726                 git checkout L1 content &&
1727                 test_tick && git commit -m "version L2 of content" &&
1728                 git tag L2 &&
1729
1730                 # Create R2
1731                 git checkout R &&
1732                 test_must_fail git -c merge.conflictstyle=diff3 merge L1 &&
1733                 git checkout R1 content &&
1734                 test_tick && git commit -m "version R2 of content" &&
1735                 git tag R2 &&
1736
1737                 # Create L3
1738                 git checkout L &&
1739                 test_must_fail git -c merge.conflictstyle=diff3 merge R2 &&
1740                 git checkout L1 content &&
1741                 test_tick && git commit -m "version L3 of content" &&
1742                 git tag L3 &&
1743
1744                 # Create R3
1745                 git checkout R &&
1746                 test_must_fail git -c merge.conflictstyle=diff3 merge L2 &&
1747                 git checkout R1 content &&
1748                 test_tick && git commit -m "version R3 of content" &&
1749                 git tag R3
1750         )
1751 '
1752
1753 test_expect_success 'check virtual merge base with nested conflicts' '
1754         (
1755                 cd virtual_merge_base_has_nested_conflicts &&
1756
1757                 MASTER=$(git rev-parse --short master) &&
1758                 git checkout L3^0 &&
1759
1760                 # Merge must fail; there is a conflict
1761                 test_must_fail git -c merge.conflictstyle=diff3 merge -s recursive R3^0 &&
1762
1763                 # Make sure the index has the right number of entries
1764                 git ls-files -s >out &&
1765                 test_line_count = 3 out &&
1766                 git ls-files -u >out &&
1767                 test_line_count = 3 out &&
1768                 # Ensure we have the correct number of untracked files
1769                 git ls-files -o >out &&
1770                 test_line_count = 1 out &&
1771
1772                 # Compare :[23]:content to expected values
1773                 git rev-parse L1:content R1:content >expect &&
1774                 git rev-parse :2:content :3:content >actual &&
1775                 test_cmp expect actual &&
1776
1777                 # Imitate X1 merge base, except without long enough conflict
1778                 # markers because a subsequent sed will modify them.  Put
1779                 # result into vmb.
1780                 git cat-file -p master:content >base &&
1781                 git cat-file -p L:content >left &&
1782                 git cat-file -p R:content >right &&
1783                 cp left merged-once &&
1784                 test_must_fail git merge-file --diff3 \
1785                         -L "Temporary merge branch 1" \
1786                         -L "$MASTER"  \
1787                         -L "Temporary merge branch 2" \
1788                         merged-once \
1789                         base        \
1790                         right       &&
1791                 sed -e "s/^\([<|=>]\)/\1\1\1/" merged-once >vmb &&
1792
1793                 # Imitate X2 merge base, overwriting vmb.  Note that we
1794                 # extend both sets of conflict markers to make them longer
1795                 # with the sed command.
1796                 cp left merged-twice &&
1797                 test_must_fail git merge-file --diff3 \
1798                         -L "Temporary merge branch 1" \
1799                         -L "merged common ancestors"  \
1800                         -L "Temporary merge branch 2" \
1801                         merged-twice \
1802                         vmb          \
1803                         right        &&
1804                 sed -e "s/^\([<|=>]\)/\1\1\1/" merged-twice >vmb &&
1805
1806                 # Compare :1:content to expected value
1807                 git cat-file -p :1:content >actual &&
1808                 test_cmp vmb actual &&
1809
1810                 # Determine expected content in final outer merge, compare to
1811                 # what the merge generated.
1812                 cp -f left expect &&
1813                 test_must_fail git merge-file --diff3                      \
1814                         -L "HEAD"  -L "merged common ancestors"  -L "R3^0" \
1815                         expect     vmb                           right     &&
1816                 test_cmp expect content
1817         )
1818 '
1819
1820 test_done