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