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