git.oblomov.eu Git - git/blob - t/t6043-merge-rename-directories.sh

   1 #!/bin/sh
   2
   3 test_description="recursive merge with directory renames"
   4 # includes checking of many corner cases, with a similar methodology to:
   5 #   t6042: corner cases with renames but not criss-cross merges
   6 #   t6036: corner cases with both renames and criss-cross merges
   7 #
   8 # The setup for all of them, pictorially, is:
   9 #
  10 #      A
  11 #      o
  12 #     / \
  13 #  O o   ?
  14 #     \ /
  15 #      o
  16 #      B
  17 #
  18 # To help make it easier to follow the flow of tests, they have been
  19 # divided into sections and each test will start with a quick explanation
  20 # of what commits O, A, and B contain.
  21 #
  22 # Notation:
  23 #    z/{b,c}   means  files z/b and z/c both exist
  24 #    x/d_1     means  file x/d exists with content d1.  (Purpose of the
  25 #                     underscore notation is to differentiate different
  26 #                     files that might be renamed into each other's paths.)
  27
  28 . ./test-lib.sh
  29
  30
  31 ###########################################################################
  32 # SECTION 1: Basic cases we should be able to handle
  33 ###########################################################################
  34
  35 # Testcase 1a, Basic directory rename.
  36 #   Commit O: z/{b,c}
  37 #   Commit A: y/{b,c}
  38 #   Commit B: z/{b,c,d,e/f}
  39 #   Expected: y/{b,c,d,e/f}
  40
  41 test_expect_success '1a-setup: Simple directory rename detection' '
  42         test_create_repo 1a &&
  43         (
  44                 cd 1a &&
  45
  46                 mkdir z &&
  47                 echo b >z/b &&
  48                 echo c >z/c &&
  49                 git add z &&
  50                 test_tick &&
  51                 git commit -m "O" &&
  52
  53                 git branch O &&
  54                 git branch A &&
  55                 git branch B &&
  56
  57                 git checkout A &&
  58                 git mv z y &&
  59                 test_tick &&
  60                 git commit -m "A" &&
  61
  62                 git checkout B &&
  63                 echo d >z/d &&
  64                 mkdir z/e &&
  65                 echo f >z/e/f &&
  66                 git add z/d z/e/f &&
  67                 test_tick &&
  68                 git commit -m "B"
  69         )
  70 '
  71
  72 test_expect_success '1a-check: Simple directory rename detection' '
  73         (
  74                 cd 1a &&
  75
  76                 git checkout A^0 &&
  77
  78                 git merge -s recursive B^0 &&
  79
  80                 git ls-files -s >out &&
  81                 test_line_count = 4 out &&
  82
  83                 git rev-parse >actual \
  84                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:y/e/f &&
  85                 git rev-parse >expect \
  86                         O:z/b    O:z/c    B:z/d    B:z/e/f &&
  87                 test_cmp expect actual &&
  88
  89                 git hash-object y/d >actual &&
  90                 git rev-parse B:z/d >expect &&
  91                 test_cmp expect actual &&
  92
  93                 test_must_fail git rev-parse HEAD:z/d &&
  94                 test_must_fail git rev-parse HEAD:z/e/f &&
  95                 test_path_is_missing z/d &&
  96                 test_path_is_missing z/e/f
  97         )
  98 '
  99
 100 # Testcase 1b, Merge a directory with another
 101 #   Commit O: z/{b,c},   y/d
 102 #   Commit A: z/{b,c,e}, y/d
 103 #   Commit B: y/{b,c,d}
 104 #   Expected: y/{b,c,d,e}
 105
 106 test_expect_success '1b-setup: Merge a directory with another' '
 107         test_create_repo 1b &&
 108         (
 109                 cd 1b &&
 110
 111                 mkdir z &&
 112                 echo b >z/b &&
 113                 echo c >z/c &&
 114                 mkdir y &&
 115                 echo d >y/d &&
 116                 git add z y &&
 117                 test_tick &&
 118                 git commit -m "O" &&
 119
 120                 git branch O &&
 121                 git branch A &&
 122                 git branch B &&
 123
 124                 git checkout A &&
 125                 echo e >z/e &&
 126                 git add z/e &&
 127                 test_tick &&
 128                 git commit -m "A" &&
 129
 130                 git checkout B &&
 131                 git mv z/b y &&
 132                 git mv z/c y &&
 133                 rmdir z &&
 134                 test_tick &&
 135                 git commit -m "B"
 136         )
 137 '
 138
 139 test_expect_success '1b-check: Merge a directory with another' '
 140         (
 141                 cd 1b &&
 142
 143                 git checkout A^0 &&
 144
 145                 git merge -s recursive B^0 &&
 146
 147                 git ls-files -s >out &&
 148                 test_line_count = 4 out &&
 149
 150                 git rev-parse >actual \
 151                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:y/e &&
 152                 git rev-parse >expect \
 153                         O:z/b    O:z/c    O:y/d    A:z/e &&
 154                 test_cmp expect actual &&
 155                 test_must_fail git rev-parse HEAD:z/e
 156         )
 157 '
 158
 159 # Testcase 1c, Transitive renaming
 160 #   (Related to testcases 3a and 6d -- when should a transitive rename apply?)
 161 #   (Related to testcases 9c and 9d -- can transitivity repeat?)
 162 #   (Related to testcase 12b -- joint-transitivity?)
 163 #   Commit O: z/{b,c},   x/d
 164 #   Commit A: y/{b,c},   x/d
 165 #   Commit B: z/{b,c,d}
 166 #   Expected: y/{b,c,d}  (because x/d -> z/d -> y/d)
 167
 168 test_expect_success '1c-setup: Transitive renaming' '
 169         test_create_repo 1c &&
 170         (
 171                 cd 1c &&
 172
 173                 mkdir z &&
 174                 echo b >z/b &&
 175                 echo c >z/c &&
 176                 mkdir x &&
 177                 echo d >x/d &&
 178                 git add z x &&
 179                 test_tick &&
 180                 git commit -m "O" &&
 181
 182                 git branch O &&
 183                 git branch A &&
 184                 git branch B &&
 185
 186                 git checkout A &&
 187                 git mv z y &&
 188                 test_tick &&
 189                 git commit -m "A" &&
 190
 191                 git checkout B &&
 192                 git mv x/d z/d &&
 193                 test_tick &&
 194                 git commit -m "B"
 195         )
 196 '
 197
 198 test_expect_success '1c-check: Transitive renaming' '
 199         (
 200                 cd 1c &&
 201
 202                 git checkout A^0 &&
 203
 204                 git merge -s recursive B^0 &&
 205
 206                 git ls-files -s >out &&
 207                 test_line_count = 3 out &&
 208
 209                 git rev-parse >actual \
 210                         HEAD:y/b HEAD:y/c HEAD:y/d &&
 211                 git rev-parse >expect \
 212                         O:z/b    O:z/c    O:x/d &&
 213                 test_cmp expect actual &&
 214                 test_must_fail git rev-parse HEAD:x/d &&
 215                 test_must_fail git rev-parse HEAD:z/d &&
 216                 test_path_is_missing z/d
 217         )
 218 '
 219
 220 # Testcase 1d, Directory renames (merging two directories into one new one)
 221 #              cause a rename/rename(2to1) conflict
 222 #   (Related to testcases 1c and 7b)
 223 #   Commit O. z/{b,c},        y/{d,e}
 224 #   Commit A. x/{b,c},        y/{d,e,m,wham_1}
 225 #   Commit B. z/{b,c,n,wham_2}, x/{d,e}
 226 #   Expected: x/{b,c,d,e,m,n}, CONFLICT:(y/wham_1 & z/wham_2 -> x/wham)
 227 #   Note: y/m & z/n should definitely move into x.  By the same token, both
 228 #         y/wham_1 & z/wham_2 should too...giving us a conflict.
 229
 230 test_expect_success '1d-setup: Directory renames cause a rename/rename(2to1) conflict' '
 231         test_create_repo 1d &&
 232         (
 233                 cd 1d &&
 234
 235                 mkdir z &&
 236                 echo b >z/b &&
 237                 echo c >z/c &&
 238                 mkdir y &&
 239                 echo d >y/d &&
 240                 echo e >y/e &&
 241                 git add z y &&
 242                 test_tick &&
 243                 git commit -m "O" &&
 244
 245                 git branch O &&
 246                 git branch A &&
 247                 git branch B &&
 248
 249                 git checkout A &&
 250                 git mv z x &&
 251                 echo m >y/m &&
 252                 echo wham1 >y/wham &&
 253                 git add y &&
 254                 test_tick &&
 255                 git commit -m "A" &&
 256
 257                 git checkout B &&
 258                 git mv y x &&
 259                 echo n >z/n &&
 260                 echo wham2 >z/wham &&
 261                 git add z &&
 262                 test_tick &&
 263                 git commit -m "B"
 264         )
 265 '
 266
 267 test_expect_success '1d-check: Directory renames cause a rename/rename(2to1) conflict' '
 268         (
 269                 cd 1d &&
 270
 271                 git checkout A^0 &&
 272
 273                 test_must_fail git merge -s recursive B^0 >out &&
 274                 test_i18ngrep "CONFLICT (rename/rename)" out &&
 275
 276                 git ls-files -s >out &&
 277                 test_line_count = 8 out &&
 278                 git ls-files -u >out &&
 279                 test_line_count = 2 out &&
 280                 git ls-files -o >out &&
 281                 test_line_count = 3 out &&
 282
 283                 git rev-parse >actual \
 284                         :0:x/b :0:x/c :0:x/d :0:x/e :0:x/m :0:x/n &&
 285                 git rev-parse >expect \
 286                          O:z/b  O:z/c  O:y/d  O:y/e  A:y/m  B:z/n &&
 287                 test_cmp expect actual &&
 288
 289                 test_must_fail git rev-parse :0:x/wham &&
 290                 git rev-parse >actual \
 291                         :2:x/wham :3:x/wham &&
 292                 git rev-parse >expect \
 293                          A:y/wham  B:z/wham &&
 294                 test_cmp expect actual &&
 295
 296                 test_path_is_missing x/wham &&
 297                 test_path_is_file x/wham~HEAD &&
 298                 test_path_is_file x/wham~B^0 &&
 299
 300                 git hash-object >actual \
 301                         x/wham~HEAD x/wham~B^0 &&
 302                 git rev-parse >expect \
 303                         A:y/wham    B:z/wham &&
 304                 test_cmp expect actual
 305         )
 306 '
 307
 308 # Testcase 1e, Renamed directory, with all filenames being renamed too
 309 #   (Related to testcases 9f & 9g)
 310 #   Commit O: z/{oldb,oldc}
 311 #   Commit A: y/{newb,newc}
 312 #   Commit B: z/{oldb,oldc,d}
 313 #   Expected: y/{newb,newc,d}
 314
 315 test_expect_success '1e-setup: Renamed directory, with all files being renamed too' '
 316         test_create_repo 1e &&
 317         (
 318                 cd 1e &&
 319
 320                 mkdir z &&
 321                 echo b >z/oldb &&
 322                 echo c >z/oldc &&
 323                 git add z &&
 324                 test_tick &&
 325                 git commit -m "O" &&
 326
 327                 git branch O &&
 328                 git branch A &&
 329                 git branch B &&
 330
 331                 git checkout A &&
 332                 mkdir y &&
 333                 git mv z/oldb y/newb &&
 334                 git mv z/oldc y/newc &&
 335                 test_tick &&
 336                 git commit -m "A" &&
 337
 338                 git checkout B &&
 339                 echo d >z/d &&
 340                 git add z/d &&
 341                 test_tick &&
 342                 git commit -m "B"
 343         )
 344 '
 345
 346 test_expect_success '1e-check: Renamed directory, with all files being renamed too' '
 347         (
 348                 cd 1e &&
 349
 350                 git checkout A^0 &&
 351
 352                 git merge -s recursive B^0 &&
 353
 354                 git ls-files -s >out &&
 355                 test_line_count = 3 out &&
 356
 357                 git rev-parse >actual \
 358                         HEAD:y/newb HEAD:y/newc HEAD:y/d &&
 359                 git rev-parse >expect \
 360                         O:z/oldb    O:z/oldc    B:z/d &&
 361                 test_cmp expect actual &&
 362                 test_must_fail git rev-parse HEAD:z/d
 363         )
 364 '
 365
 366 # Testcase 1f, Split a directory into two other directories
 367 #   (Related to testcases 3a, all of section 2, and all of section 4)
 368 #   Commit O: z/{b,c,d,e,f}
 369 #   Commit A: z/{b,c,d,e,f,g}
 370 #   Commit B: y/{b,c}, x/{d,e,f}
 371 #   Expected: y/{b,c}, x/{d,e,f,g}
 372
 373 test_expect_success '1f-setup: Split a directory into two other directories' '
 374         test_create_repo 1f &&
 375         (
 376                 cd 1f &&
 377
 378                 mkdir z &&
 379                 echo b >z/b &&
 380                 echo c >z/c &&
 381                 echo d >z/d &&
 382                 echo e >z/e &&
 383                 echo f >z/f &&
 384                 git add z &&
 385                 test_tick &&
 386                 git commit -m "O" &&
 387
 388                 git branch O &&
 389                 git branch A &&
 390                 git branch B &&
 391
 392                 git checkout A &&
 393                 echo g >z/g &&
 394                 git add z/g &&
 395                 test_tick &&
 396                 git commit -m "A" &&
 397
 398                 git checkout B &&
 399                 mkdir y &&
 400                 mkdir x &&
 401                 git mv z/b y/ &&
 402                 git mv z/c y/ &&
 403                 git mv z/d x/ &&
 404                 git mv z/e x/ &&
 405                 git mv z/f x/ &&
 406                 rmdir z &&
 407                 test_tick &&
 408                 git commit -m "B"
 409         )
 410 '
 411
 412 test_expect_success '1f-check: Split a directory into two other directories' '
 413         (
 414                 cd 1f &&
 415
 416                 git checkout A^0 &&
 417
 418                 git merge -s recursive B^0 &&
 419
 420                 git ls-files -s >out &&
 421                 test_line_count = 6 out &&
 422
 423                 git rev-parse >actual \
 424                         HEAD:y/b HEAD:y/c HEAD:x/d HEAD:x/e HEAD:x/f HEAD:x/g &&
 425                 git rev-parse >expect \
 426                         O:z/b    O:z/c    O:z/d    O:z/e    O:z/f    A:z/g &&
 427                 test_cmp expect actual &&
 428                 test_path_is_missing z/g &&
 429                 test_must_fail git rev-parse HEAD:z/g
 430         )
 431 '
 432
 433 ###########################################################################
 434 # Rules suggested by testcases in section 1:
 435 #
 436 #   We should still detect the directory rename even if it wasn't just
 437 #   the directory renamed, but the files within it. (see 1b)
 438 #
 439 #   If renames split a directory into two or more others, the directory
 440 #   with the most renames, "wins" (see 1c).  However, see the testcases
 441 #   in section 2, plus testcases 3a and 4a.
 442 ###########################################################################
 443
 444
 445 ###########################################################################
 446 # SECTION 2: Split into multiple directories, with equal number of paths
 447 #
 448 # Explore the splitting-a-directory rules a bit; what happens in the
 449 # edge cases?
 450 #
 451 # Note that there is a closely related case of a directory not being
 452 # split on either side of history, but being renamed differently on
 453 # each side.  See testcase 8e for that.
 454 ###########################################################################
 455
 456 # Testcase 2a, Directory split into two on one side, with equal numbers of paths
 457 #   Commit O: z/{b,c}
 458 #   Commit A: y/b, w/c
 459 #   Commit B: z/{b,c,d}
 460 #   Expected: y/b, w/c, z/d, with warning about z/ -> (y/ vs. w/) conflict
 461 test_expect_success '2a-setup: Directory split into two on one side, with equal numbers of paths' '
 462         test_create_repo 2a &&
 463         (
 464                 cd 2a &&
 465
 466                 mkdir z &&
 467                 echo b >z/b &&
 468                 echo c >z/c &&
 469                 git add z &&
 470                 test_tick &&
 471                 git commit -m "O" &&
 472
 473                 git branch O &&
 474                 git branch A &&
 475                 git branch B &&
 476
 477                 git checkout A &&
 478                 mkdir y &&
 479                 mkdir w &&
 480                 git mv z/b y/ &&
 481                 git mv z/c w/ &&
 482                 test_tick &&
 483                 git commit -m "A" &&
 484
 485                 git checkout B &&
 486                 echo d >z/d &&
 487                 git add z/d &&
 488                 test_tick &&
 489                 git commit -m "B"
 490         )
 491 '
 492
 493 test_expect_success '2a-check: Directory split into two on one side, with equal numbers of paths' '
 494         (
 495                 cd 2a &&
 496
 497                 git checkout A^0 &&
 498
 499                 test_must_fail git merge -s recursive B^0 >out &&
 500                 test_i18ngrep "CONFLICT.*directory rename split" out &&
 501
 502                 git ls-files -s >out &&
 503                 test_line_count = 3 out &&
 504                 git ls-files -u >out &&
 505                 test_line_count = 0 out &&
 506                 git ls-files -o >out &&
 507                 test_line_count = 1 out &&
 508
 509                 git rev-parse >actual \
 510                         :0:y/b :0:w/c :0:z/d &&
 511                 git rev-parse >expect \
 512                          O:z/b  O:z/c  B:z/d &&
 513                 test_cmp expect actual
 514         )
 515 '
 516
 517 # Testcase 2b, Directory split into two on one side, with equal numbers of paths
 518 #   Commit O: z/{b,c}
 519 #   Commit A: y/b, w/c
 520 #   Commit B: z/{b,c}, x/d
 521 #   Expected: y/b, w/c, x/d; No warning about z/ -> (y/ vs. w/) conflict
 522 test_expect_success '2b-setup: Directory split into two on one side, with equal numbers of paths' '
 523         test_create_repo 2b &&
 524         (
 525                 cd 2b &&
 526
 527                 mkdir z &&
 528                 echo b >z/b &&
 529                 echo c >z/c &&
 530                 git add z &&
 531                 test_tick &&
 532                 git commit -m "O" &&
 533
 534                 git branch O &&
 535                 git branch A &&
 536                 git branch B &&
 537
 538                 git checkout A &&
 539                 mkdir y &&
 540                 mkdir w &&
 541                 git mv z/b y/ &&
 542                 git mv z/c w/ &&
 543                 test_tick &&
 544                 git commit -m "A" &&
 545
 546                 git checkout B &&
 547                 mkdir x &&
 548                 echo d >x/d &&
 549                 git add x/d &&
 550                 test_tick &&
 551                 git commit -m "B"
 552         )
 553 '
 554
 555 test_expect_success '2b-check: Directory split into two on one side, with equal numbers of paths' '
 556         (
 557                 cd 2b &&
 558
 559                 git checkout A^0 &&
 560
 561                 git merge -s recursive B^0 >out &&
 562
 563                 git ls-files -s >out &&
 564                 test_line_count = 3 out &&
 565                 git ls-files -u >out &&
 566                 test_line_count = 0 out &&
 567                 git ls-files -o >out &&
 568                 test_line_count = 1 out &&
 569
 570                 git rev-parse >actual \
 571                         :0:y/b :0:w/c :0:x/d &&
 572                 git rev-parse >expect \
 573                          O:z/b  O:z/c  B:x/d &&
 574                 test_cmp expect actual &&
 575                 test_i18ngrep ! "CONFLICT.*directory rename split" out
 576         )
 577 '
 578
 579 ###########################################################################
 580 # Rules suggested by section 2:
 581 #
 582 #   None; the rule was already covered in section 1.  These testcases are
 583 #   here just to make sure the conflict resolution and necessary warning
 584 #   messages are handled correctly.
 585 ###########################################################################
 586
 587
 588 ###########################################################################
 589 # SECTION 3: Path in question is the source path for some rename already
 590 #
 591 # Combining cases from Section 1 and trying to handle them could lead to
 592 # directory renaming detection being over-applied.  So, this section
 593 # provides some good testcases to check that the implementation doesn't go
 594 # too far.
 595 ###########################################################################
 596
 597 # Testcase 3a, Avoid implicit rename if involved as source on other side
 598 #   (Related to testcases 1c, 1f, and 9h)
 599 #   Commit O: z/{b,c,d}
 600 #   Commit A: z/{b,c,d} (no change)
 601 #   Commit B: y/{b,c}, x/d
 602 #   Expected: y/{b,c}, x/d
 603 test_expect_success '3a-setup: Avoid implicit rename if involved as source on other side' '
 604         test_create_repo 3a &&
 605         (
 606                 cd 3a &&
 607
 608                 mkdir z &&
 609                 echo b >z/b &&
 610                 echo c >z/c &&
 611                 echo d >z/d &&
 612                 git add z &&
 613                 test_tick &&
 614                 git commit -m "O" &&
 615
 616                 git branch O &&
 617                 git branch A &&
 618                 git branch B &&
 619
 620                 git checkout A &&
 621                 test_tick &&
 622                 git commit --allow-empty -m "A" &&
 623
 624                 git checkout B &&
 625                 mkdir y &&
 626                 mkdir x &&
 627                 git mv z/b y/ &&
 628                 git mv z/c y/ &&
 629                 git mv z/d x/ &&
 630                 rmdir z &&
 631                 test_tick &&
 632                 git commit -m "B"
 633         )
 634 '
 635
 636 test_expect_success '3a-check: Avoid implicit rename if involved as source on other side' '
 637         (
 638                 cd 3a &&
 639
 640                 git checkout A^0 &&
 641
 642                 git merge -s recursive B^0 &&
 643
 644                 git ls-files -s >out &&
 645                 test_line_count = 3 out &&
 646
 647                 git rev-parse >actual \
 648                         HEAD:y/b HEAD:y/c HEAD:x/d &&
 649                 git rev-parse >expect \
 650                         O:z/b    O:z/c    O:z/d &&
 651                 test_cmp expect actual
 652         )
 653 '
 654
 655 # Testcase 3b, Avoid implicit rename if involved as source on other side
 656 #   (Related to testcases 5c and 7c, also kind of 1e and 1f)
 657 #   Commit O: z/{b,c,d}
 658 #   Commit A: y/{b,c}, x/d
 659 #   Commit B: z/{b,c}, w/d
 660 #   Expected: y/{b,c}, CONFLICT:(z/d -> x/d vs. w/d)
 661 #   NOTE: We're particularly checking that since z/d is already involved as
 662 #         a source in a file rename on the same side of history, that we don't
 663 #         get it involved in directory rename detection.  If it were, we might
 664 #         end up with CONFLICT:(z/d -> y/d vs. x/d vs. w/d), i.e. a
 665 #         rename/rename/rename(1to3) conflict, which is just weird.
 666 test_expect_success '3b-setup: Avoid implicit rename if involved as source on current side' '
 667         test_create_repo 3b &&
 668         (
 669                 cd 3b &&
 670
 671                 mkdir z &&
 672                 echo b >z/b &&
 673                 echo c >z/c &&
 674                 echo d >z/d &&
 675                 git add z &&
 676                 test_tick &&
 677                 git commit -m "O" &&
 678
 679                 git branch O &&
 680                 git branch A &&
 681                 git branch B &&
 682
 683                 git checkout A &&
 684                 mkdir y &&
 685                 mkdir x &&
 686                 git mv z/b y/ &&
 687                 git mv z/c y/ &&
 688                 git mv z/d x/ &&
 689                 rmdir z &&
 690                 test_tick &&
 691                 git commit -m "A" &&
 692
 693                 git checkout B &&
 694                 mkdir w &&
 695                 git mv z/d w/ &&
 696                 test_tick &&
 697                 git commit -m "B"
 698         )
 699 '
 700
 701 test_expect_success '3b-check: Avoid implicit rename if involved as source on current side' '
 702         (
 703                 cd 3b &&
 704
 705                 git checkout A^0 &&
 706
 707                 test_must_fail git merge -s recursive B^0 >out &&
 708                 test_i18ngrep CONFLICT.*rename/rename.*z/d.*x/d.*w/d out &&
 709                 test_i18ngrep ! CONFLICT.*rename/rename.*y/d out &&
 710
 711                 git ls-files -s >out &&
 712                 test_line_count = 5 out &&
 713                 git ls-files -u >out &&
 714                 test_line_count = 3 out &&
 715                 git ls-files -o >out &&
 716                 test_line_count = 1 out &&
 717
 718                 git rev-parse >actual \
 719                         :0:y/b :0:y/c :1:z/d :2:x/d :3:w/d &&
 720                 git rev-parse >expect \
 721                          O:z/b  O:z/c  O:z/d  O:z/d  O:z/d &&
 722                 test_cmp expect actual &&
 723
 724                 test_path_is_missing z/d &&
 725                 git hash-object >actual \
 726                         x/d   w/d &&
 727                 git rev-parse >expect \
 728                         O:z/d O:z/d &&
 729                 test_cmp expect actual
 730         )
 731 '
 732
 733 ###########################################################################
 734 # Rules suggested by section 3:
 735 #
 736 #   Avoid directory-rename-detection for a path, if that path is the source
 737 #   of a rename on either side of a merge.
 738 ###########################################################################
 739
 740
 741 ###########################################################################
 742 # SECTION 4: Partially renamed directory; still exists on both sides of merge
 743 #
 744 # What if we were to attempt to do directory rename detection when someone
 745 # "mostly" moved a directory but still left some files around, or,
 746 # equivalently, fully renamed a directory in one commmit and then recreated
 747 # that directory in a later commit adding some new files and then tried to
 748 # merge?
 749 #
 750 # It's hard to divine user intent in these cases, because you can make an
 751 # argument that, depending on the intermediate history of the side being
 752 # merged, that some users will want files in that directory to
 753 # automatically be detected and renamed, while users with a different
 754 # intermediate history wouldn't want that rename to happen.
 755 #
 756 # I think that it is best to simply not have directory rename detection
 757 # apply to such cases.  My reasoning for this is four-fold: (1) it's
 758 # easiest for users in general to figure out what happened if we don't
 759 # apply directory rename detection in any such case, (2) it's an easy rule
 760 # to explain ["We don't do directory rename detection if the directory
 761 # still exists on both sides of the merge"], (3) we can get some hairy
 762 # edge/corner cases that would be really confusing and possibly not even
 763 # representable in the index if we were to even try, and [related to 3] (4)
 764 # attempting to resolve this issue of divining user intent by examining
 765 # intermediate history goes against the spirit of three-way merges and is a
 766 # path towards crazy corner cases that are far more complex than what we're
 767 # already dealing with.
 768 #
 769 # Note that the wording of the rule ("We don't do directory rename
 770 # detection if the directory still exists on both sides of the merge.")
 771 # also excludes "renaming" of a directory into a subdirectory of itself
 772 # (e.g. /some/dir/* -> /some/dir/subdir/*).  It may be possible to carve
 773 # out an exception for "renaming"-beneath-itself cases without opening
 774 # weird edge/corner cases for other partial directory renames, but for now
 775 # we are keeping the rule simple.
 776 #
 777 # This section contains a test for a partially-renamed-directory case.
 778 ###########################################################################
 779
 780 # Testcase 4a, Directory split, with original directory still present
 781 #   (Related to testcase 1f)
 782 #   Commit O: z/{b,c,d,e}
 783 #   Commit A: y/{b,c,d}, z/e
 784 #   Commit B: z/{b,c,d,e,f}
 785 #   Expected: y/{b,c,d}, z/{e,f}
 786 #   NOTE: Even though most files from z moved to y, we don't want f to follow.
 787
 788 test_expect_success '4a-setup: Directory split, with original directory still present' '
 789         test_create_repo 4a &&
 790         (
 791                 cd 4a &&
 792
 793                 mkdir z &&
 794                 echo b >z/b &&
 795                 echo c >z/c &&
 796                 echo d >z/d &&
 797                 echo e >z/e &&
 798                 git add z &&
 799                 test_tick &&
 800                 git commit -m "O" &&
 801
 802                 git branch O &&
 803                 git branch A &&
 804                 git branch B &&
 805
 806                 git checkout A &&
 807                 mkdir y &&
 808                 git mv z/b y/ &&
 809                 git mv z/c y/ &&
 810                 git mv z/d y/ &&
 811                 test_tick &&
 812                 git commit -m "A" &&
 813
 814                 git checkout B &&
 815                 echo f >z/f &&
 816                 git add z/f &&
 817                 test_tick &&
 818                 git commit -m "B"
 819         )
 820 '
 821
 822 test_expect_success '4a-check: Directory split, with original directory still present' '
 823         (
 824                 cd 4a &&
 825
 826                 git checkout A^0 &&
 827
 828                 git merge -s recursive B^0 &&
 829
 830                 git ls-files -s >out &&
 831                 test_line_count = 5 out &&
 832                 git ls-files -u >out &&
 833                 test_line_count = 0 out &&
 834                 git ls-files -o >out &&
 835                 test_line_count = 1 out &&
 836
 837                 git rev-parse >actual \
 838                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:z/e HEAD:z/f &&
 839                 git rev-parse >expect \
 840                         O:z/b    O:z/c    O:z/d    O:z/e    B:z/f &&
 841                 test_cmp expect actual
 842         )
 843 '
 844
 845 ###########################################################################
 846 # Rules suggested by section 4:
 847 #
 848 #   Directory-rename-detection should be turned off for any directories (as
 849 #   a source for renames) that exist on both sides of the merge.  (The "as
 850 #   a source for renames" clarification is due to cases like 1c where
 851 #   the target directory exists on both sides and we do want the rename
 852 #   detection.)  But, sadly, see testcase 8b.
 853 ###########################################################################
 854
 855
 856 ###########################################################################
 857 # SECTION 5: Files/directories in the way of subset of to-be-renamed paths
 858 #
 859 # Implicitly renaming files due to a detected directory rename could run
 860 # into problems if there are files or directories in the way of the paths
 861 # we want to rename.  Explore such cases in this section.
 862 ###########################################################################
 863
 864 # Testcase 5a, Merge directories, other side adds files to original and target
 865 #   Commit O: z/{b,c},       y/d
 866 #   Commit A: z/{b,c,e_1,f}, y/{d,e_2}
 867 #   Commit B: y/{b,c,d}
 868 #   Expected: z/e_1, y/{b,c,d,e_2,f} + CONFLICT warning
 869 #   NOTE: While directory rename detection is active here causing z/f to
 870 #         become y/f, we did not apply this for z/e_1 because that would
 871 #         give us an add/add conflict for y/e_1 vs y/e_2.  This problem with
 872 #         this add/add, is that both versions of y/e are from the same side
 873 #         of history, giving us no way to represent this conflict in the
 874 #         index.
 875
 876 test_expect_success '5a-setup: Merge directories, other side adds files to original and target' '
 877         test_create_repo 5a &&
 878         (
 879                 cd 5a &&
 880
 881                 mkdir z &&
 882                 echo b >z/b &&
 883                 echo c >z/c &&
 884                 mkdir y &&
 885                 echo d >y/d &&
 886                 git add z y &&
 887                 test_tick &&
 888                 git commit -m "O" &&
 889
 890                 git branch O &&
 891                 git branch A &&
 892                 git branch B &&
 893
 894                 git checkout A &&
 895                 echo e1 >z/e &&
 896                 echo f >z/f &&
 897                 echo e2 >y/e &&
 898                 git add z/e z/f y/e &&
 899                 test_tick &&
 900                 git commit -m "A" &&
 901
 902                 git checkout B &&
 903                 git mv z/b y/ &&
 904                 git mv z/c y/ &&
 905                 rmdir z &&
 906                 test_tick &&
 907                 git commit -m "B"
 908         )
 909 '
 910
 911 test_expect_success '5a-check: Merge directories, other side adds files to original and target' '
 912         (
 913                 cd 5a &&
 914
 915                 git checkout A^0 &&
 916
 917                 test_must_fail git merge -s recursive B^0 >out &&
 918                 test_i18ngrep "CONFLICT.*implicit dir rename" out &&
 919
 920                 git ls-files -s >out &&
 921                 test_line_count = 6 out &&
 922                 git ls-files -u >out &&
 923                 test_line_count = 0 out &&
 924                 git ls-files -o >out &&
 925                 test_line_count = 1 out &&
 926
 927                 git rev-parse >actual \
 928                         :0:y/b :0:y/c :0:y/d :0:y/e :0:z/e :0:y/f &&
 929                 git rev-parse >expect \
 930                          O:z/b  O:z/c  O:y/d  A:y/e  A:z/e  A:z/f &&
 931                 test_cmp expect actual
 932         )
 933 '
 934
 935 # Testcase 5b, Rename/delete in order to get add/add/add conflict
 936 #   (Related to testcase 8d; these may appear slightly inconsistent to users;
 937 #    Also related to testcases 7d and 7e)
 938 #   Commit O: z/{b,c,d_1}
 939 #   Commit A: y/{b,c,d_2}
 940 #   Commit B: z/{b,c,d_1,e}, y/d_3
 941 #   Expected: y/{b,c,e}, CONFLICT(add/add: y/d_2 vs. y/d_3)
 942 #   NOTE: If z/d_1 in commit B were to be involved in dir rename detection, as
 943 #         we normaly would since z/ is being renamed to y/, then this would be
 944 #         a rename/delete (z/d_1 -> y/d_1 vs. deleted) AND an add/add/add
 945 #         conflict of y/d_1 vs. y/d_2 vs. y/d_3.  Add/add/add is not
 946 #         representable in the index, so the existence of y/d_3 needs to
 947 #         cause us to bail on directory rename detection for that path, falling
 948 #         back to git behavior without the directory rename detection.
 949
 950 test_expect_success '5b-setup: Rename/delete in order to get add/add/add conflict' '
 951         test_create_repo 5b &&
 952         (
 953                 cd 5b &&
 954
 955                 mkdir z &&
 956                 echo b >z/b &&
 957                 echo c >z/c &&
 958                 echo d1 >z/d &&
 959                 git add z &&
 960                 test_tick &&
 961                 git commit -m "O" &&
 962
 963                 git branch O &&
 964                 git branch A &&
 965                 git branch B &&
 966
 967                 git checkout A &&
 968                 git rm z/d &&
 969                 git mv z y &&
 970                 echo d2 >y/d &&
 971                 git add y/d &&
 972                 test_tick &&
 973                 git commit -m "A" &&
 974
 975                 git checkout B &&
 976                 mkdir y &&
 977                 echo d3 >y/d &&
 978                 echo e >z/e &&
 979                 git add y/d z/e &&
 980                 test_tick &&
 981                 git commit -m "B"
 982         )
 983 '
 984
 985 test_expect_success '5b-check: Rename/delete in order to get add/add/add conflict' '
 986         (
 987                 cd 5b &&
 988
 989                 git checkout A^0 &&
 990
 991                 test_must_fail git merge -s recursive B^0 >out &&
 992                 test_i18ngrep "CONFLICT (add/add).* y/d" out &&
 993
 994                 git ls-files -s >out &&
 995                 test_line_count = 5 out &&
 996                 git ls-files -u >out &&
 997                 test_line_count = 2 out &&
 998                 git ls-files -o >out &&
 999                 test_line_count = 1 out &&
1000
1001                 git rev-parse >actual \
1002                         :0:y/b :0:y/c :0:y/e :2:y/d :3:y/d &&
1003                 git rev-parse >expect \
1004                          O:z/b  O:z/c  B:z/e  A:y/d  B:y/d &&
1005                 test_cmp expect actual &&
1006
1007                 test_must_fail git rev-parse :1:y/d &&
1008                 test_path_is_file y/d
1009         )
1010 '
1011
1012 # Testcase 5c, Transitive rename would cause rename/rename/rename/add/add/add
1013 #   (Directory rename detection would result in transitive rename vs.
1014 #    rename/rename(1to2) and turn it into a rename/rename(1to3).  Further,
1015 #    rename paths conflict with separate adds on the other side)
1016 #   (Related to testcases 3b and 7c)
1017 #   Commit O: z/{b,c}, x/d_1
1018 #   Commit A: y/{b,c,d_2}, w/d_1
1019 #   Commit B: z/{b,c,d_1,e}, w/d_3, y/d_4
1020 #   Expected: A mess, but only a rename/rename(1to2)/add/add mess.  Use the
1021 #             presence of y/d_4 in B to avoid doing transitive rename of
1022 #             x/d_1 -> z/d_1 -> y/d_1, so that the only paths we have at
1023 #             y/d are y/d_2 and y/d_4.  We still do the move from z/e to y/e,
1024 #             though, because it doesn't have anything in the way.
1025
1026 test_expect_success '5c-setup: Transitive rename would cause rename/rename/rename/add/add/add' '
1027         test_create_repo 5c &&
1028         (
1029                 cd 5c &&
1030
1031                 mkdir z &&
1032                 echo b >z/b &&
1033                 echo c >z/c &&
1034                 mkdir x &&
1035                 echo d1 >x/d &&
1036                 git add z x &&
1037                 test_tick &&
1038                 git commit -m "O" &&
1039
1040                 git branch O &&
1041                 git branch A &&
1042                 git branch B &&
1043
1044                 git checkout A &&
1045                 git mv z y &&
1046                 echo d2 >y/d &&
1047                 git add y/d &&
1048                 git mv x w &&
1049                 test_tick &&
1050                 git commit -m "A" &&
1051
1052                 git checkout B &&
1053                 git mv x/d z/ &&
1054                 mkdir w &&
1055                 mkdir y &&
1056                 echo d3 >w/d &&
1057                 echo d4 >y/d &&
1058                 echo e >z/e &&
1059                 git add w/ y/ z/e &&
1060                 test_tick &&
1061                 git commit -m "B"
1062         )
1063 '
1064
1065 test_expect_success '5c-check: Transitive rename would cause rename/rename/rename/add/add/add' '
1066         (
1067                 cd 5c &&
1068
1069                 git checkout A^0 &&
1070
1071                 test_must_fail git merge -s recursive B^0 >out &&
1072                 test_i18ngrep "CONFLICT (rename/rename).*x/d.*w/d.*z/d" out &&
1073                 test_i18ngrep "CONFLICT (add/add).* y/d" out &&
1074
1075                 git ls-files -s >out &&
1076                 test_line_count = 9 out &&
1077                 git ls-files -u >out &&
1078                 test_line_count = 6 out &&
1079                 git ls-files -o >out &&
1080                 test_line_count = 3 out &&
1081
1082                 git rev-parse >actual \
1083                         :0:y/b :0:y/c :0:y/e &&
1084                 git rev-parse >expect \
1085                          O:z/b  O:z/c  B:z/e &&
1086                 test_cmp expect actual &&
1087
1088                 test_must_fail git rev-parse :1:y/d &&
1089                 git rev-parse >actual \
1090                         :2:w/d :3:w/d :1:x/d :2:y/d :3:y/d :3:z/d &&
1091                 git rev-parse >expect \
1092                          O:x/d  B:w/d  O:x/d  A:y/d  B:y/d  O:x/d &&
1093                 test_cmp expect actual &&
1094
1095                 git hash-object >actual \
1096                         w/d~HEAD w/d~B^0 z/d &&
1097                 git rev-parse >expect \
1098                         O:x/d    B:w/d   O:x/d &&
1099                 test_cmp expect actual &&
1100                 test_path_is_missing x/d &&
1101                 test_path_is_file y/d &&
1102                 grep -q "<<<<" y/d  # conflict markers should be present
1103         )
1104 '
1105
1106 # Testcase 5d, Directory/file/file conflict due to directory rename
1107 #   Commit O: z/{b,c}
1108 #   Commit A: y/{b,c,d_1}
1109 #   Commit B: z/{b,c,d_2,f}, y/d/e
1110 #   Expected: y/{b,c,d/e,f}, z/d_2, CONFLICT(file/directory), y/d_1~HEAD
1111 #   Note: The fact that y/d/ exists in B makes us bail on directory rename
1112 #         detection for z/d_2, but that doesn't prevent us from applying the
1113 #         directory rename detection for z/f -> y/f.
1114
1115 test_expect_success '5d-setup: Directory/file/file conflict due to directory rename' '
1116         test_create_repo 5d &&
1117         (
1118                 cd 5d &&
1119
1120                 mkdir z &&
1121                 echo b >z/b &&
1122                 echo c >z/c &&
1123                 git add z &&
1124                 test_tick &&
1125                 git commit -m "O" &&
1126
1127                 git branch O &&
1128                 git branch A &&
1129                 git branch B &&
1130
1131                 git checkout A &&
1132                 git mv z y &&
1133                 echo d1 >y/d &&
1134                 git add y/d &&
1135                 test_tick &&
1136                 git commit -m "A" &&
1137
1138                 git checkout B &&
1139                 mkdir -p y/d &&
1140                 echo e >y/d/e &&
1141                 echo d2 >z/d &&
1142                 echo f >z/f &&
1143                 git add y/d/e z/d z/f &&
1144                 test_tick &&
1145                 git commit -m "B"
1146         )
1147 '
1148
1149 test_expect_success '5d-check: Directory/file/file conflict due to directory rename' '
1150         (
1151                 cd 5d &&
1152
1153                 git checkout A^0 &&
1154
1155                 test_must_fail git merge -s recursive B^0 >out &&
1156                 test_i18ngrep "CONFLICT (file/directory).*y/d" out &&
1157
1158                 git ls-files -s >out &&
1159                 test_line_count = 6 out &&
1160                 git ls-files -u >out &&
1161                 test_line_count = 1 out &&
1162                 git ls-files -o >out &&
1163                 test_line_count = 2 out &&
1164
1165                 git rev-parse >actual \
1166                         :0:y/b :0:y/c :0:z/d :0:y/f :2:y/d :0:y/d/e &&
1167                 git rev-parse >expect \
1168                          O:z/b  O:z/c  B:z/d  B:z/f  A:y/d  B:y/d/e &&
1169                 test_cmp expect actual &&
1170
1171                 git hash-object y/d~HEAD >actual &&
1172                 git rev-parse A:y/d >expect &&
1173                 test_cmp expect actual
1174         )
1175 '
1176
1177 ###########################################################################
1178 # Rules suggested by section 5:
1179 #
1180 #   If a subset of to-be-renamed files have a file or directory in the way,
1181 #   "turn off" the directory rename for those specific sub-paths, falling
1182 #   back to old handling.  But, sadly, see testcases 8a and 8b.
1183 ###########################################################################
1184
1185
1186 ###########################################################################
1187 # SECTION 6: Same side of the merge was the one that did the rename
1188 #
1189 # It may sound obvious that you only want to apply implicit directory
1190 # renames to directories if the _other_ side of history did the renaming.
1191 # If you did make an implementation that didn't explicitly enforce this
1192 # rule, the majority of cases that would fall under this section would
1193 # also be solved by following the rules from the above sections.  But
1194 # there are still a few that stick out, so this section covers them just
1195 # to make sure we also get them right.
1196 ###########################################################################
1197
1198 # Testcase 6a, Tricky rename/delete
1199 #   Commit O: z/{b,c,d}
1200 #   Commit A: z/b
1201 #   Commit B: y/{b,c}, z/d
1202 #   Expected: y/b, CONFLICT(rename/delete, z/c -> y/c vs. NULL)
1203 #   Note: We're just checking here that the rename of z/b and z/c to put
1204 #         them under y/ doesn't accidentally catch z/d and make it look like
1205 #         it is also involved in a rename/delete conflict.
1206
1207 test_expect_success '6a-setup: Tricky rename/delete' '
1208         test_create_repo 6a &&
1209         (
1210                 cd 6a &&
1211
1212                 mkdir z &&
1213                 echo b >z/b &&
1214                 echo c >z/c &&
1215                 echo d >z/d &&
1216                 git add z &&
1217                 test_tick &&
1218                 git commit -m "O" &&
1219
1220                 git branch O &&
1221                 git branch A &&
1222                 git branch B &&
1223
1224                 git checkout A &&
1225                 git rm z/c &&
1226                 git rm z/d &&
1227                 test_tick &&
1228                 git commit -m "A" &&
1229
1230                 git checkout B &&
1231                 mkdir y &&
1232                 git mv z/b y/ &&
1233                 git mv z/c y/ &&
1234                 test_tick &&
1235                 git commit -m "B"
1236         )
1237 '
1238
1239 test_expect_success '6a-check: Tricky rename/delete' '
1240         (
1241                 cd 6a &&
1242
1243                 git checkout A^0 &&
1244
1245                 test_must_fail git merge -s recursive B^0 >out &&
1246                 test_i18ngrep "CONFLICT (rename/delete).*z/c.*y/c" out &&
1247
1248                 git ls-files -s >out &&
1249                 test_line_count = 2 out &&
1250                 git ls-files -u >out &&
1251                 test_line_count = 1 out &&
1252                 git ls-files -o >out &&
1253                 test_line_count = 1 out &&
1254
1255                 git rev-parse >actual \
1256                         :0:y/b :3:y/c &&
1257                 git rev-parse >expect \
1258                          O:z/b  O:z/c &&
1259                 test_cmp expect actual
1260         )
1261 '
1262
1263 # Testcase 6b, Same rename done on both sides
1264 #   (Related to testcases 6c and 8e)
1265 #   Commit O: z/{b,c}
1266 #   Commit A: y/{b,c}
1267 #   Commit B: y/{b,c}, z/d
1268 #   Expected: y/{b,c}, z/d
1269 #   Note: If we did directory rename detection here, we'd move z/d into y/,
1270 #         but B did that rename and still decided to put the file into z/,
1271 #         so we probably shouldn't apply directory rename detection for it.
1272
1273 test_expect_success '6b-setup: Same rename done on both sides' '
1274         test_create_repo 6b &&
1275         (
1276                 cd 6b &&
1277
1278                 mkdir z &&
1279                 echo b >z/b &&
1280                 echo c >z/c &&
1281                 git add z &&
1282                 test_tick &&
1283                 git commit -m "O" &&
1284
1285                 git branch O &&
1286                 git branch A &&
1287                 git branch B &&
1288
1289                 git checkout A &&
1290                 git mv z y &&
1291                 test_tick &&
1292                 git commit -m "A" &&
1293
1294                 git checkout B &&
1295                 git mv z y &&
1296                 mkdir z &&
1297                 echo d >z/d &&
1298                 git add z/d &&
1299                 test_tick &&
1300                 git commit -m "B"
1301         )
1302 '
1303
1304 test_expect_success '6b-check: Same rename done on both sides' '
1305         (
1306                 cd 6b &&
1307
1308                 git checkout A^0 &&
1309
1310                 git merge -s recursive B^0 &&
1311
1312                 git ls-files -s >out &&
1313                 test_line_count = 3 out &&
1314                 git ls-files -u >out &&
1315                 test_line_count = 0 out &&
1316                 git ls-files -o >out &&
1317                 test_line_count = 1 out &&
1318
1319                 git rev-parse >actual \
1320                         HEAD:y/b HEAD:y/c HEAD:z/d &&
1321                 git rev-parse >expect \
1322                         O:z/b    O:z/c    B:z/d &&
1323                 test_cmp expect actual
1324         )
1325 '
1326
1327 # Testcase 6c, Rename only done on same side
1328 #   (Related to testcases 6b and 8e)
1329 #   Commit O: z/{b,c}
1330 #   Commit A: z/{b,c} (no change)
1331 #   Commit B: y/{b,c}, z/d
1332 #   Expected: y/{b,c}, z/d
1333 #   NOTE: Seems obvious, but just checking that the implementation doesn't
1334 #         "accidentally detect a rename" and give us y/{b,c,d}.
1335
1336 test_expect_success '6c-setup: Rename only done on same side' '
1337         test_create_repo 6c &&
1338         (
1339                 cd 6c &&
1340
1341                 mkdir z &&
1342                 echo b >z/b &&
1343                 echo c >z/c &&
1344                 git add z &&
1345                 test_tick &&
1346                 git commit -m "O" &&
1347
1348                 git branch O &&
1349                 git branch A &&
1350                 git branch B &&
1351
1352                 git checkout A &&
1353                 test_tick &&
1354                 git commit --allow-empty -m "A" &&
1355
1356                 git checkout B &&
1357                 git mv z y &&
1358                 mkdir z &&
1359                 echo d >z/d &&
1360                 git add z/d &&
1361                 test_tick &&
1362                 git commit -m "B"
1363         )
1364 '
1365
1366 test_expect_success '6c-check: Rename only done on same side' '
1367         (
1368                 cd 6c &&
1369
1370                 git checkout A^0 &&
1371
1372                 git merge -s recursive B^0 &&
1373
1374                 git ls-files -s >out &&
1375                 test_line_count = 3 out &&
1376                 git ls-files -u >out &&
1377                 test_line_count = 0 out &&
1378                 git ls-files -o >out &&
1379                 test_line_count = 1 out &&
1380
1381                 git rev-parse >actual \
1382                         HEAD:y/b HEAD:y/c HEAD:z/d &&
1383                 git rev-parse >expect \
1384                         O:z/b    O:z/c    B:z/d &&
1385                 test_cmp expect actual
1386         )
1387 '
1388
1389 # Testcase 6d, We don't always want transitive renaming
1390 #   (Related to testcase 1c)
1391 #   Commit O: z/{b,c}, x/d
1392 #   Commit A: z/{b,c}, x/d (no change)
1393 #   Commit B: y/{b,c}, z/d
1394 #   Expected: y/{b,c}, z/d
1395 #   NOTE: Again, this seems obvious but just checking that the implementation
1396 #         doesn't "accidentally detect a rename" and give us y/{b,c,d}.
1397
1398 test_expect_success '6d-setup: We do not always want transitive renaming' '
1399         test_create_repo 6d &&
1400         (
1401                 cd 6d &&
1402
1403                 mkdir z &&
1404                 echo b >z/b &&
1405                 echo c >z/c &&
1406                 mkdir x &&
1407                 echo d >x/d &&
1408                 git add z x &&
1409                 test_tick &&
1410                 git commit -m "O" &&
1411
1412                 git branch O &&
1413                 git branch A &&
1414                 git branch B &&
1415
1416                 git checkout A &&
1417                 test_tick &&
1418                 git commit --allow-empty -m "A" &&
1419
1420                 git checkout B &&
1421                 git mv z y &&
1422                 git mv x z &&
1423                 test_tick &&
1424                 git commit -m "B"
1425         )
1426 '
1427
1428 test_expect_success '6d-check: We do not always want transitive renaming' '
1429         (
1430                 cd 6d &&
1431
1432                 git checkout A^0 &&
1433
1434                 git merge -s recursive B^0 &&
1435
1436                 git ls-files -s >out &&
1437                 test_line_count = 3 out &&
1438                 git ls-files -u >out &&
1439                 test_line_count = 0 out &&
1440                 git ls-files -o >out &&
1441                 test_line_count = 1 out &&
1442
1443                 git rev-parse >actual \
1444                         HEAD:y/b HEAD:y/c HEAD:z/d &&
1445                 git rev-parse >expect \
1446                         O:z/b    O:z/c    O:x/d &&
1447                 test_cmp expect actual
1448         )
1449 '
1450
1451 # Testcase 6e, Add/add from one-side
1452 #   Commit O: z/{b,c}
1453 #   Commit A: z/{b,c} (no change)
1454 #   Commit B: y/{b,c,d_1}, z/d_2
1455 #   Expected: y/{b,c,d_1}, z/d_2
1456 #   NOTE: Again, this seems obvious but just checking that the implementation
1457 #         doesn't "accidentally detect a rename" and give us y/{b,c} +
1458 #         add/add conflict on y/d_1 vs y/d_2.
1459
1460 test_expect_success '6e-setup: Add/add from one side' '
1461         test_create_repo 6e &&
1462         (
1463                 cd 6e &&
1464
1465                 mkdir z &&
1466                 echo b >z/b &&
1467                 echo c >z/c &&
1468                 git add z &&
1469                 test_tick &&
1470                 git commit -m "O" &&
1471
1472                 git branch O &&
1473                 git branch A &&
1474                 git branch B &&
1475
1476                 git checkout A &&
1477                 test_tick &&
1478                 git commit --allow-empty -m "A" &&
1479
1480                 git checkout B &&
1481                 git mv z y &&
1482                 echo d1 > y/d &&
1483                 mkdir z &&
1484                 echo d2 > z/d &&
1485                 git add y/d z/d &&
1486                 test_tick &&
1487                 git commit -m "B"
1488         )
1489 '
1490
1491 test_expect_success '6e-check: Add/add from one side' '
1492         (
1493                 cd 6e &&
1494
1495                 git checkout A^0 &&
1496
1497                 git merge -s recursive B^0 &&
1498
1499                 git ls-files -s >out &&
1500                 test_line_count = 4 out &&
1501                 git ls-files -u >out &&
1502                 test_line_count = 0 out &&
1503                 git ls-files -o >out &&
1504                 test_line_count = 1 out &&
1505
1506                 git rev-parse >actual \
1507                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:z/d &&
1508                 git rev-parse >expect \
1509                         O:z/b    O:z/c    B:y/d    B:z/d &&
1510                 test_cmp expect actual
1511         )
1512 '
1513
1514 ###########################################################################
1515 # Rules suggested by section 6:
1516 #
1517 #   Only apply implicit directory renames to directories if the other
1518 #   side of history is the one doing the renaming.
1519 ###########################################################################
1520
1521
1522 ###########################################################################
1523 # SECTION 7: More involved Edge/Corner cases
1524 #
1525 # The ruleset we have generated in the above sections seems to provide
1526 # well-defined merges.  But can we find edge/corner cases that either (a)
1527 # are harder for users to understand, or (b) have a resolution that is
1528 # non-intuitive or suboptimal?
1529 #
1530 # The testcases in this section dive into cases that I've tried to craft in
1531 # a way to find some that might be surprising to users or difficult for
1532 # them to understand (the next section will look at non-intuitive or
1533 # suboptimal merge results).  Some of the testcases are similar to ones
1534 # from past sections, but have been simplified to try to highlight error
1535 # messages using a "modified" path (due to the directory rename).  Are
1536 # users okay with these?
1537 #
1538 # In my opinion, testcases that are difficult to understand from this
1539 # section is due to difficulty in the testcase rather than the directory
1540 # renaming (similar to how t6042 and t6036 have difficult resolutions due
1541 # to the problem setup itself being complex).  And I don't think the
1542 # error messages are a problem.
1543 #
1544 # On the other hand, the testcases in section 8 worry me slightly more...
1545 ###########################################################################
1546
1547 # Testcase 7a, rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file
1548 #   Commit O: z/{b,c}
1549 #   Commit A: y/{b,c}
1550 #   Commit B: w/b, x/c, z/d
1551 #   Expected: y/d, CONFLICT(rename/rename for both z/b and z/c)
1552 #   NOTE: There's a rename of z/ here, y/ has more renames, so z/d -> y/d.
1553
1554 test_expect_success '7a-setup: rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file' '
1555         test_create_repo 7a &&
1556         (
1557                 cd 7a &&
1558
1559                 mkdir z &&
1560                 echo b >z/b &&
1561                 echo c >z/c &&
1562                 git add z &&
1563                 test_tick &&
1564                 git commit -m "O" &&
1565
1566                 git branch O &&
1567                 git branch A &&
1568                 git branch B &&
1569
1570                 git checkout A &&
1571                 git mv z y &&
1572                 test_tick &&
1573                 git commit -m "A" &&
1574
1575                 git checkout B &&
1576                 mkdir w &&
1577                 mkdir x &&
1578                 git mv z/b w/ &&
1579                 git mv z/c x/ &&
1580                 echo d > z/d &&
1581                 git add z/d &&
1582                 test_tick &&
1583                 git commit -m "B"
1584         )
1585 '
1586
1587 test_expect_success '7a-check: rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file' '
1588         (
1589                 cd 7a &&
1590
1591                 git checkout A^0 &&
1592
1593                 test_must_fail git merge -s recursive B^0 >out &&
1594                 test_i18ngrep "CONFLICT (rename/rename).*z/b.*y/b.*w/b" out &&
1595                 test_i18ngrep "CONFLICT (rename/rename).*z/c.*y/c.*x/c" out &&
1596
1597                 git ls-files -s >out &&
1598                 test_line_count = 7 out &&
1599                 git ls-files -u >out &&
1600                 test_line_count = 6 out &&
1601                 git ls-files -o >out &&
1602                 test_line_count = 1 out &&
1603
1604                 git rev-parse >actual \
1605                         :1:z/b :2:y/b :3:w/b :1:z/c :2:y/c :3:x/c :0:y/d &&
1606                 git rev-parse >expect \
1607                          O:z/b  O:z/b  O:z/b  O:z/c  O:z/c  O:z/c  B:z/d &&
1608                 test_cmp expect actual &&
1609
1610                 git hash-object >actual \
1611                         y/b   w/b   y/c   x/c &&
1612                 git rev-parse >expect \
1613                         O:z/b O:z/b O:z/c O:z/c &&
1614                 test_cmp expect actual
1615         )
1616 '
1617
1618 # Testcase 7b, rename/rename(2to1), but only due to transitive rename
1619 #   (Related to testcase 1d)
1620 #   Commit O: z/{b,c},     x/d_1, w/d_2
1621 #   Commit A: y/{b,c,d_2}, x/d_1
1622 #   Commit B: z/{b,c,d_1},        w/d_2
1623 #   Expected: y/{b,c}, CONFLICT(rename/rename(2to1): x/d_1, w/d_2 -> y_d)
1624
1625 test_expect_success '7b-setup: rename/rename(2to1), but only due to transitive rename' '
1626         test_create_repo 7b &&
1627         (
1628                 cd 7b &&
1629
1630                 mkdir z &&
1631                 mkdir x &&
1632                 mkdir w &&
1633                 echo b >z/b &&
1634                 echo c >z/c &&
1635                 echo d1 > x/d &&
1636                 echo d2 > w/d &&
1637                 git add z x w &&
1638                 test_tick &&
1639                 git commit -m "O" &&
1640
1641                 git branch O &&
1642                 git branch A &&
1643                 git branch B &&
1644
1645                 git checkout A &&
1646                 git mv z y &&
1647                 git mv w/d y/ &&
1648                 test_tick &&
1649                 git commit -m "A" &&
1650
1651                 git checkout B &&
1652                 git mv x/d z/ &&
1653                 rmdir x &&
1654                 test_tick &&
1655                 git commit -m "B"
1656         )
1657 '
1658
1659 test_expect_success '7b-check: rename/rename(2to1), but only due to transitive rename' '
1660         (
1661                 cd 7b &&
1662
1663                 git checkout A^0 &&
1664
1665                 test_must_fail git merge -s recursive B^0 >out &&
1666                 test_i18ngrep "CONFLICT (rename/rename)" out &&
1667
1668                 git ls-files -s >out &&
1669                 test_line_count = 4 out &&
1670                 git ls-files -u >out &&
1671                 test_line_count = 2 out &&
1672                 git ls-files -o >out &&
1673                 test_line_count = 3 out &&
1674
1675                 git rev-parse >actual \
1676                         :0:y/b :0:y/c :2:y/d :3:y/d &&
1677                 git rev-parse >expect \
1678                          O:z/b  O:z/c  O:w/d  O:x/d &&
1679                 test_cmp expect actual &&
1680
1681                 test_path_is_missing y/d &&
1682                 test_path_is_file y/d~HEAD &&
1683                 test_path_is_file y/d~B^0 &&
1684
1685                 git hash-object >actual \
1686                         y/d~HEAD y/d~B^0 &&
1687                 git rev-parse >expect \
1688                         O:w/d    O:x/d &&
1689                 test_cmp expect actual
1690         )
1691 '
1692
1693 # Testcase 7c, rename/rename(1to...2or3); transitive rename may add complexity
1694 #   (Related to testcases 3b and 5c)
1695 #   Commit O: z/{b,c}, x/d
1696 #   Commit A: y/{b,c}, w/d
1697 #   Commit B: z/{b,c,d}
1698 #   Expected: y/{b,c}, CONFLICT(x/d -> w/d vs. y/d)
1699 #   NOTE: z/ was renamed to y/ so we do want to report
1700 #         neither CONFLICT(x/d -> w/d vs. z/d)
1701 #         nor CONFLiCT x/d -> w/d vs. y/d vs. z/d)
1702
1703 test_expect_success '7c-setup: rename/rename(1to...2or3); transitive rename may add complexity' '
1704         test_create_repo 7c &&
1705         (
1706                 cd 7c &&
1707
1708                 mkdir z &&
1709                 echo b >z/b &&
1710                 echo c >z/c &&
1711                 mkdir x &&
1712                 echo d >x/d &&
1713                 git add z x &&
1714                 test_tick &&
1715                 git commit -m "O" &&
1716
1717                 git branch O &&
1718                 git branch A &&
1719                 git branch B &&
1720
1721                 git checkout A &&
1722                 git mv z y &&
1723                 git mv x w &&
1724                 test_tick &&
1725                 git commit -m "A" &&
1726
1727                 git checkout B &&
1728                 git mv x/d z/ &&
1729                 rmdir x &&
1730                 test_tick &&
1731                 git commit -m "B"
1732         )
1733 '
1734
1735 test_expect_success '7c-check: rename/rename(1to...2or3); transitive rename may add complexity' '
1736         (
1737                 cd 7c &&
1738
1739                 git checkout A^0 &&
1740
1741                 test_must_fail git merge -s recursive B^0 >out &&
1742                 test_i18ngrep "CONFLICT (rename/rename).*x/d.*w/d.*y/d" out &&
1743
1744                 git ls-files -s >out &&
1745                 test_line_count = 5 out &&
1746                 git ls-files -u >out &&
1747                 test_line_count = 3 out &&
1748                 git ls-files -o >out &&
1749                 test_line_count = 1 out &&
1750
1751                 git rev-parse >actual \
1752                         :0:y/b :0:y/c :1:x/d :2:w/d :3:y/d &&
1753                 git rev-parse >expect \
1754                          O:z/b  O:z/c  O:x/d  O:x/d  O:x/d &&
1755                 test_cmp expect actual
1756         )
1757 '
1758
1759 # Testcase 7d, transitive rename involved in rename/delete; how is it reported?
1760 #   (Related somewhat to testcases 5b and 8d)
1761 #   Commit O: z/{b,c}, x/d
1762 #   Commit A: y/{b,c}
1763 #   Commit B: z/{b,c,d}
1764 #   Expected: y/{b,c}, CONFLICT(delete x/d vs rename to y/d)
1765 #   NOTE: z->y so NOT CONFLICT(delete x/d vs rename to z/d)
1766
1767 test_expect_success '7d-setup: transitive rename involved in rename/delete; how is it reported?' '
1768         test_create_repo 7d &&
1769         (
1770                 cd 7d &&
1771
1772                 mkdir z &&
1773                 echo b >z/b &&
1774                 echo c >z/c &&
1775                 mkdir x &&
1776                 echo d >x/d &&
1777                 git add z x &&
1778                 test_tick &&
1779                 git commit -m "O" &&
1780
1781                 git branch O &&
1782                 git branch A &&
1783                 git branch B &&
1784
1785                 git checkout A &&
1786                 git mv z y &&
1787                 git rm -rf x &&
1788                 test_tick &&
1789                 git commit -m "A" &&
1790
1791                 git checkout B &&
1792                 git mv x/d z/ &&
1793                 rmdir x &&
1794                 test_tick &&
1795                 git commit -m "B"
1796         )
1797 '
1798
1799 test_expect_success '7d-check: transitive rename involved in rename/delete; how is it reported?' '
1800         (
1801                 cd 7d &&
1802
1803                 git checkout A^0 &&
1804
1805                 test_must_fail git merge -s recursive B^0 >out &&
1806                 test_i18ngrep "CONFLICT (rename/delete).*x/d.*y/d" out &&
1807
1808                 git ls-files -s >out &&
1809                 test_line_count = 3 out &&
1810                 git ls-files -u >out &&
1811                 test_line_count = 1 out &&
1812                 git ls-files -o >out &&
1813                 test_line_count = 1 out &&
1814
1815                 git rev-parse >actual \
1816                         :0:y/b :0:y/c :3:y/d &&
1817                 git rev-parse >expect \
1818                          O:z/b  O:z/c  O:x/d &&
1819                 test_cmp expect actual
1820         )
1821 '
1822
1823 # Testcase 7e, transitive rename in rename/delete AND dirs in the way
1824 #   (Very similar to 'both rename source and destination involved in D/F conflict' from t6022-merge-rename.sh)
1825 #   (Also related to testcases 9c and 9d)
1826 #   Commit O: z/{b,c},     x/d_1
1827 #   Commit A: y/{b,c,d/g}, x/d/f
1828 #   Commit B: z/{b,c,d_1}
1829 #   Expected: rename/delete(x/d_1->y/d_1 vs. None) + D/F conflict on y/d
1830 #             y/{b,c,d/g}, y/d_1~B^0, x/d/f
1831
1832 #   NOTE: The main path of interest here is d_1 and where it ends up, but
1833 #         this is actually a case that has two potential directory renames
1834 #         involved and D/F conflict(s), so it makes sense to walk through
1835 #         each step.
1836 #
1837 #         Commit A renames z/ -> y/.  Thus everything that B adds to z/
1838 #         should be instead moved to y/.  This gives us the D/F conflict on
1839 #         y/d because x/d_1 -> z/d_1 -> y/d_1 conflicts with y/d/g.
1840 #
1841 #         Further, commit B renames x/ -> z/, thus everything A adds to x/
1842 #         should instead be moved to z/...BUT we removed z/ and renamed it
1843 #         to y/, so maybe everything should move not from x/ to z/, but
1844 #         from x/ to z/ to y/.  Doing so might make sense from the logic so
1845 #         far, but note that commit A had both an x/ and a y/; it did the
1846 #         renaming of z/ to y/ and created x/d/f and it clearly made these
1847 #         things separate, so it doesn't make much sense to push these
1848 #         together.  Doing so is what I'd call a doubly transitive rename;
1849 #         see testcases 9c and 9d for further discussion of this issue and
1850 #         how it's resolved.
1851
1852 test_expect_success '7e-setup: transitive rename in rename/delete AND dirs in the way' '
1853         test_create_repo 7e &&
1854         (
1855                 cd 7e &&
1856
1857                 mkdir z &&
1858                 echo b >z/b &&
1859                 echo c >z/c &&
1860                 mkdir x &&
1861                 echo d1 >x/d &&
1862                 git add z x &&
1863                 test_tick &&
1864                 git commit -m "O" &&
1865
1866                 git branch O &&
1867                 git branch A &&
1868                 git branch B &&
1869
1870                 git checkout A &&
1871                 git mv z y &&
1872                 git rm x/d &&
1873                 mkdir -p x/d &&
1874                 mkdir -p y/d &&
1875                 echo f >x/d/f &&
1876                 echo g >y/d/g &&
1877                 git add x/d/f y/d/g &&
1878                 test_tick &&
1879                 git commit -m "A" &&
1880
1881                 git checkout B &&
1882                 git mv x/d z/ &&
1883                 rmdir x &&
1884                 test_tick &&
1885                 git commit -m "B"
1886         )
1887 '
1888
1889 test_expect_success '7e-check: transitive rename in rename/delete AND dirs in the way' '
1890         (
1891                 cd 7e &&
1892
1893                 git checkout A^0 &&
1894
1895                 test_must_fail git merge -s recursive B^0 >out &&
1896                 test_i18ngrep "CONFLICT (rename/delete).*x/d.*y/d" out &&
1897
1898                 git ls-files -s >out &&
1899                 test_line_count = 5 out &&
1900                 git ls-files -u >out &&
1901                 test_line_count = 1 out &&
1902                 git ls-files -o >out &&
1903                 test_line_count = 2 out &&
1904
1905                 git rev-parse >actual \
1906                         :0:x/d/f :0:y/d/g :0:y/b :0:y/c :3:y/d &&
1907                 git rev-parse >expect \
1908                          A:x/d/f  A:y/d/g  O:z/b  O:z/c  O:x/d &&
1909                 test_cmp expect actual &&
1910
1911                 git hash-object y/d~B^0 >actual &&
1912                 git rev-parse O:x/d >expect &&
1913                 test_cmp expect actual
1914         )
1915 '
1916
1917 ###########################################################################
1918 # SECTION 8: Suboptimal merges
1919 #
1920 # As alluded to in the last section, the ruleset we have built up for
1921 # detecting directory renames unfortunately has some special cases where it
1922 # results in slightly suboptimal or non-intuitive behavior.  This section
1923 # explores these cases.
1924 #
1925 # To be fair, we already had non-intuitive or suboptimal behavior for most
1926 # of these cases in git before introducing implicit directory rename
1927 # detection, but it'd be nice if there was a modified ruleset out there
1928 # that handled these cases a bit better.
1929 ###########################################################################
1930
1931 # Testcase 8a, Dual-directory rename, one into the others' way
1932 #   Commit O. x/{a,b},   y/{c,d}
1933 #   Commit A. x/{a,b,e}, y/{c,d,f}
1934 #   Commit B. y/{a,b},   z/{c,d}
1935 #
1936 # Possible Resolutions:
1937 #   w/o dir-rename detection: y/{a,b,f},   z/{c,d},   x/e
1938 #   Currently expected:       y/{a,b,e,f}, z/{c,d}
1939 #   Optimal:                  y/{a,b,e},   z/{c,d,f}
1940 #
1941 # Note: Both x and y got renamed and it'd be nice to detect both, and we do
1942 # better with directory rename detection than git did without, but the
1943 # simple rule from section 5 prevents me from handling this as optimally as
1944 # we potentially could.
1945
1946 test_expect_success '8a-setup: Dual-directory rename, one into the others way' '
1947         test_create_repo 8a &&
1948         (
1949                 cd 8a &&
1950
1951                 mkdir x &&
1952                 mkdir y &&
1953                 echo a >x/a &&
1954                 echo b >x/b &&
1955                 echo c >y/c &&
1956                 echo d >y/d &&
1957                 git add x y &&
1958                 test_tick &&
1959                 git commit -m "O" &&
1960
1961                 git branch O &&
1962                 git branch A &&
1963                 git branch B &&
1964
1965                 git checkout A &&
1966                 echo e >x/e &&
1967                 echo f >y/f &&
1968                 git add x/e y/f &&
1969                 test_tick &&
1970                 git commit -m "A" &&
1971
1972                 git checkout B &&
1973                 git mv y z &&
1974                 git mv x y &&
1975                 test_tick &&
1976                 git commit -m "B"
1977         )
1978 '
1979
1980 test_expect_success '8a-check: Dual-directory rename, one into the others way' '
1981         (
1982                 cd 8a &&
1983
1984                 git checkout A^0 &&
1985
1986                 git merge -s recursive B^0 &&
1987
1988                 git ls-files -s >out &&
1989                 test_line_count = 6 out &&
1990                 git ls-files -u >out &&
1991                 test_line_count = 0 out &&
1992                 git ls-files -o >out &&
1993                 test_line_count = 1 out &&
1994
1995                 git rev-parse >actual \
1996                         HEAD:y/a HEAD:y/b HEAD:y/e HEAD:y/f HEAD:z/c HEAD:z/d &&
1997                 git rev-parse >expect \
1998                         O:x/a    O:x/b    A:x/e    A:y/f    O:y/c    O:y/d &&
1999                 test_cmp expect actual
2000         )
2001 '
2002
2003 # Testcase 8b, Dual-directory rename, one into the others' way, with conflicting filenames
2004 #   Commit O. x/{a_1,b_1},     y/{a_2,b_2}
2005 #   Commit A. x/{a_1,b_1,e_1}, y/{a_2,b_2,e_2}
2006 #   Commit B. y/{a_1,b_1},     z/{a_2,b_2}
2007 #
2008 #   w/o dir-rename detection: y/{a_1,b_1,e_2}, z/{a_2,b_2}, x/e_1
2009 #   Currently expected:       <same>
2010 #   Scary:                    y/{a_1,b_1},     z/{a_2,b_2}, CONFLICT(add/add, e_1 vs. e_2)
2011 #   Optimal:                  y/{a_1,b_1,e_1}, z/{a_2,b_2,e_2}
2012 #
2013 # Note: Very similar to 8a, except instead of 'e' and 'f' in directories x and
2014 # y, both are named 'e'.  Without directory rename detection, neither file
2015 # moves directories.  Implement directory rename detection suboptimally, and
2016 # you get an add/add conflict, but both files were added in commit A, so this
2017 # is an add/add conflict where one side of history added both files --
2018 # something we can't represent in the index.  Obviously, we'd prefer the last
2019 # resolution, but our previous rules are too coarse to allow it.  Using both
2020 # the rules from section 4 and section 5 save us from the Scary resolution,
2021 # making us fall back to pre-directory-rename-detection behavior for both
2022 # e_1 and e_2.
2023
2024 test_expect_success '8b-setup: Dual-directory rename, one into the others way, with conflicting filenames' '
2025         test_create_repo 8b &&
2026         (
2027                 cd 8b &&
2028
2029                 mkdir x &&
2030                 mkdir y &&
2031                 echo a1 >x/a &&
2032                 echo b1 >x/b &&
2033                 echo a2 >y/a &&
2034                 echo b2 >y/b &&
2035                 git add x y &&
2036                 test_tick &&
2037                 git commit -m "O" &&
2038
2039                 git branch O &&
2040                 git branch A &&
2041                 git branch B &&
2042
2043                 git checkout A &&
2044                 echo e1 >x/e &&
2045                 echo e2 >y/e &&
2046                 git add x/e y/e &&
2047                 test_tick &&
2048                 git commit -m "A" &&
2049
2050                 git checkout B &&
2051                 git mv y z &&
2052                 git mv x y &&
2053                 test_tick &&
2054                 git commit -m "B"
2055         )
2056 '
2057
2058 test_expect_success '8b-check: Dual-directory rename, one into the others way, with conflicting filenames' '
2059         (
2060                 cd 8b &&
2061
2062                 git checkout A^0 &&
2063
2064                 git merge -s recursive B^0 &&
2065
2066                 git ls-files -s >out &&
2067                 test_line_count = 6 out &&
2068                 git ls-files -u >out &&
2069                 test_line_count = 0 out &&
2070                 git ls-files -o >out &&
2071                 test_line_count = 1 out &&
2072
2073                 git rev-parse >actual \
2074                         HEAD:y/a HEAD:y/b HEAD:z/a HEAD:z/b HEAD:x/e HEAD:y/e &&
2075                 git rev-parse >expect \
2076                         O:x/a    O:x/b    O:y/a    O:y/b    A:x/e    A:y/e &&
2077                 test_cmp expect actual
2078         )
2079 '
2080
2081 # Testcase 8c, modify/delete or rename+modify/delete?
2082 #   (Related to testcases 5b, 8d, and 9h)
2083 #   Commit O: z/{b,c,d}
2084 #   Commit A: y/{b,c}
2085 #   Commit B: z/{b,c,d_modified,e}
2086 #   Expected: y/{b,c,e}, CONFLICT(modify/delete: on z/d)
2087 #
2088 #   Note: It could easily be argued that the correct resolution here is
2089 #         y/{b,c,e}, CONFLICT(rename/delete: z/d -> y/d vs deleted)
2090 #         and that the modifed version of d should be present in y/ after
2091 #         the merge, just marked as conflicted.  Indeed, I previously did
2092 #         argue that.  But applying directory renames to the side of
2093 #         history where a file is merely modified results in spurious
2094 #         rename/rename(1to2) conflicts -- see testcase 9h.  See also
2095 #         notes in 8d.
2096
2097 test_expect_success '8c-setup: modify/delete or rename+modify/delete?' '
2098         test_create_repo 8c &&
2099         (
2100                 cd 8c &&
2101
2102                 mkdir z &&
2103                 echo b >z/b &&
2104                 echo c >z/c &&
2105                 test_seq 1 10 >z/d &&
2106                 git add z &&
2107                 test_tick &&
2108                 git commit -m "O" &&
2109
2110                 git branch O &&
2111                 git branch A &&
2112                 git branch B &&
2113
2114                 git checkout A &&
2115                 git rm z/d &&
2116                 git mv z y &&
2117                 test_tick &&
2118                 git commit -m "A" &&
2119
2120                 git checkout B &&
2121                 echo 11 >z/d &&
2122                 test_chmod +x z/d &&
2123                 echo e >z/e &&
2124                 git add z/d z/e &&
2125                 test_tick &&
2126                 git commit -m "B"
2127         )
2128 '
2129
2130 test_expect_success '8c-check: modify/delete or rename+modify/delete' '
2131         (
2132                 cd 8c &&
2133
2134                 git checkout A^0 &&
2135
2136                 test_must_fail git merge -s recursive B^0 >out &&
2137                 test_i18ngrep "CONFLICT (modify/delete).* z/d" out &&
2138
2139                 git ls-files -s >out &&
2140                 test_line_count = 5 out &&
2141                 git ls-files -u >out &&
2142                 test_line_count = 2 out &&
2143                 git ls-files -o >out &&
2144                 test_line_count = 1 out &&
2145
2146                 git rev-parse >actual \
2147                         :0:y/b :0:y/c :0:y/e :1:z/d :3:z/d &&
2148                 git rev-parse >expect \
2149                          O:z/b  O:z/c  B:z/e  O:z/d  B:z/d &&
2150                 test_cmp expect actual &&
2151
2152                 test_must_fail git rev-parse :2:z/d &&
2153                 git ls-files -s z/d | grep ^100755 &&
2154                 test_path_is_file z/d &&
2155                 test_path_is_missing y/d
2156         )
2157 '
2158
2159 # Testcase 8d, rename/delete...or not?
2160 #   (Related to testcase 5b; these may appear slightly inconsistent to users;
2161 #    Also related to testcases 7d and 7e)
2162 #   Commit O: z/{b,c,d}
2163 #   Commit A: y/{b,c}
2164 #   Commit B: z/{b,c,d,e}
2165 #   Expected: y/{b,c,e}
2166 #
2167 #   Note: It would also be somewhat reasonable to resolve this as
2168 #             y/{b,c,e}, CONFLICT(rename/delete: x/d -> y/d or deleted)
2169 #
2170 #   In this case, I'm leaning towards: commit A was the one that deleted z/d
2171 #   and it did the rename of z to y, so the two "conflicts" (rename vs.
2172 #   delete) are both coming from commit A, which is illogical.  Conflicts
2173 #   during merging are supposed to be about opposite sides doing things
2174 #   differently.
2175
2176 test_expect_success '8d-setup: rename/delete...or not?' '
2177         test_create_repo 8d &&
2178         (
2179                 cd 8d &&
2180
2181                 mkdir z &&
2182                 echo b >z/b &&
2183                 echo c >z/c &&
2184                 test_seq 1 10 >z/d &&
2185                 git add z &&
2186                 test_tick &&
2187                 git commit -m "O" &&
2188
2189                 git branch O &&
2190                 git branch A &&
2191                 git branch B &&
2192
2193                 git checkout A &&
2194                 git rm z/d &&
2195                 git mv z y &&
2196                 test_tick &&
2197                 git commit -m "A" &&
2198
2199                 git checkout B &&
2200                 echo e >z/e &&
2201                 git add z/e &&
2202                 test_tick &&
2203                 git commit -m "B"
2204         )
2205 '
2206
2207 test_expect_success '8d-check: rename/delete...or not?' '
2208         (
2209                 cd 8d &&
2210
2211                 git checkout A^0 &&
2212
2213                 git merge -s recursive B^0 &&
2214
2215                 git ls-files -s >out &&
2216                 test_line_count = 3 out &&
2217
2218                 git rev-parse >actual \
2219                         HEAD:y/b HEAD:y/c HEAD:y/e &&
2220                 git rev-parse >expect \
2221                         O:z/b    O:z/c    B:z/e &&
2222                 test_cmp expect actual
2223         )
2224 '
2225
2226 # Testcase 8e, Both sides rename, one side adds to original directory
2227 #   Commit O: z/{b,c}
2228 #   Commit A: y/{b,c}
2229 #   Commit B: w/{b,c}, z/d
2230 #
2231 # Possible Resolutions:
2232 #   w/o dir-rename detection: z/d, CONFLICT(z/b -> y/b vs. w/b),
2233 #                                  CONFLICT(z/c -> y/c vs. w/c)
2234 #   Currently expected:       y/d, CONFLICT(z/b -> y/b vs. w/b),
2235 #                                  CONFLICT(z/c -> y/c vs. w/c)
2236 #   Optimal:                  ??
2237 #
2238 # Notes: In commit A, directory z got renamed to y.  In commit B, directory z
2239 #        did NOT get renamed; the directory is still present; instead it is
2240 #        considered to have just renamed a subset of paths in directory z
2241 #        elsewhere.  Therefore, the directory rename done in commit A to z/
2242 #        applies to z/d and maps it to y/d.
2243 #
2244 #        It's possible that users would get confused about this, but what
2245 #        should we do instead?  Silently leaving at z/d seems just as bad or
2246 #        maybe even worse.  Perhaps we could print a big warning about z/d
2247 #        and how we're moving to y/d in this case, but when I started thinking
2248 #        about the ramifications of doing that, I didn't know how to rule out
2249 #        that opening other weird edge and corner cases so I just punted.
2250
2251 test_expect_success '8e-setup: Both sides rename, one side adds to original directory' '
2252         test_create_repo 8e &&
2253         (
2254                 cd 8e &&
2255
2256                 mkdir z &&
2257                 echo b >z/b &&
2258                 echo c >z/c &&
2259                 git add z &&
2260                 test_tick &&
2261                 git commit -m "O" &&
2262
2263                 git branch O &&
2264                 git branch A &&
2265                 git branch B &&
2266
2267                 git checkout A &&
2268                 git mv z y &&
2269                 test_tick &&
2270                 git commit -m "A" &&
2271
2272                 git checkout B &&
2273                 git mv z w &&
2274                 mkdir z &&
2275                 echo d >z/d &&
2276                 git add z/d &&
2277                 test_tick &&
2278                 git commit -m "B"
2279         )
2280 '
2281
2282 test_expect_success '8e-check: Both sides rename, one side adds to original directory' '
2283         (
2284                 cd 8e &&
2285
2286                 git checkout A^0 &&
2287
2288                 test_must_fail git merge -s recursive B^0 >out 2>err &&
2289                 test_i18ngrep CONFLICT.*rename/rename.*z/c.*y/c.*w/c out &&
2290                 test_i18ngrep CONFLICT.*rename/rename.*z/b.*y/b.*w/b out &&
2291
2292                 git ls-files -s >out &&
2293                 test_line_count = 7 out &&
2294                 git ls-files -u >out &&
2295                 test_line_count = 6 out &&
2296                 git ls-files -o >out &&
2297                 test_line_count = 2 out &&
2298
2299                 git rev-parse >actual \
2300                         :1:z/b :2:y/b :3:w/b :1:z/c :2:y/c :3:w/c :0:y/d &&
2301                 git rev-parse >expect \
2302                          O:z/b  O:z/b  O:z/b  O:z/c  O:z/c  O:z/c  B:z/d &&
2303                 test_cmp expect actual &&
2304
2305                 git hash-object >actual \
2306                         y/b   w/b   y/c   w/c &&
2307                 git rev-parse >expect \
2308                         O:z/b O:z/b O:z/c O:z/c &&
2309                 test_cmp expect actual &&
2310
2311                 test_path_is_missing z/b &&
2312                 test_path_is_missing z/c
2313         )
2314 '
2315
2316 ###########################################################################
2317 # SECTION 9: Other testcases
2318 #
2319 # This section consists of miscellaneous testcases I thought of during
2320 # the implementation which round out the testing.
2321 ###########################################################################
2322
2323 # Testcase 9a, Inner renamed directory within outer renamed directory
2324 #   (Related to testcase 1f)
2325 #   Commit O: z/{b,c,d/{e,f,g}}
2326 #   Commit A: y/{b,c}, x/w/{e,f,g}
2327 #   Commit B: z/{b,c,d/{e,f,g,h},i}
2328 #   Expected: y/{b,c,i}, x/w/{e,f,g,h}
2329 #   NOTE: The only reason this one is interesting is because when a directory
2330 #         is split into multiple other directories, we determine by the weight
2331 #         of which one had the most paths going to it.  A naive implementation
2332 #         of that could take the new file in commit B at z/i to x/w/i or x/i.
2333
2334 test_expect_success '9a-setup: Inner renamed directory within outer renamed directory' '
2335         test_create_repo 9a &&
2336         (
2337                 cd 9a &&
2338
2339                 mkdir -p z/d &&
2340                 echo b >z/b &&
2341                 echo c >z/c &&
2342                 echo e >z/d/e &&
2343                 echo f >z/d/f &&
2344                 echo g >z/d/g &&
2345                 git add z &&
2346                 test_tick &&
2347                 git commit -m "O" &&
2348
2349                 git branch O &&
2350                 git branch A &&
2351                 git branch B &&
2352
2353                 git checkout A &&
2354                 mkdir x &&
2355                 git mv z/d x/w &&
2356                 git mv z y &&
2357                 test_tick &&
2358                 git commit -m "A" &&
2359
2360                 git checkout B &&
2361                 echo h >z/d/h &&
2362                 echo i >z/i &&
2363                 git add z &&
2364                 test_tick &&
2365                 git commit -m "B"
2366         )
2367 '
2368
2369 test_expect_success '9a-check: Inner renamed directory within outer renamed directory' '
2370         (
2371                 cd 9a &&
2372
2373                 git checkout A^0 &&
2374
2375                 git merge -s recursive B^0 &&
2376
2377                 git ls-files -s >out &&
2378                 test_line_count = 7 out &&
2379                 git ls-files -u >out &&
2380                 test_line_count = 0 out &&
2381                 git ls-files -o >out &&
2382                 test_line_count = 1 out &&
2383
2384                 git rev-parse >actual \
2385                         HEAD:y/b HEAD:y/c HEAD:y/i &&
2386                 git rev-parse >expect \
2387                         O:z/b    O:z/c    B:z/i &&
2388                 test_cmp expect actual &&
2389
2390                 git rev-parse >actual \
2391                         HEAD:x/w/e HEAD:x/w/f HEAD:x/w/g HEAD:x/w/h &&
2392                 git rev-parse >expect \
2393                         O:z/d/e    O:z/d/f    O:z/d/g    B:z/d/h &&
2394                 test_cmp expect actual
2395         )
2396 '
2397
2398 # Testcase 9b, Transitive rename with content merge
2399 #   (Related to testcase 1c)
2400 #   Commit O: z/{b,c},   x/d_1
2401 #   Commit A: y/{b,c},   x/d_2
2402 #   Commit B: z/{b,c,d_3}
2403 #   Expected: y/{b,c,d_merged}
2404
2405 test_expect_success '9b-setup: Transitive rename with content merge' '
2406         test_create_repo 9b &&
2407         (
2408                 cd 9b &&
2409
2410                 mkdir z &&
2411                 echo b >z/b &&
2412                 echo c >z/c &&
2413                 mkdir x &&
2414                 test_seq 1 10 >x/d &&
2415                 git add z x &&
2416                 test_tick &&
2417                 git commit -m "O" &&
2418
2419                 git branch O &&
2420                 git branch A &&
2421                 git branch B &&
2422
2423                 git checkout A &&
2424                 git mv z y &&
2425                 test_seq 1 11 >x/d &&
2426                 git add x/d &&
2427                 test_tick &&
2428                 git commit -m "A" &&
2429
2430                 git checkout B &&
2431                 test_seq 0 10 >x/d &&
2432                 git mv x/d z/d &&
2433                 git add z/d &&
2434                 test_tick &&
2435                 git commit -m "B"
2436         )
2437 '
2438
2439 test_expect_success '9b-check: Transitive rename with content merge' '
2440         (
2441                 cd 9b &&
2442
2443                 git checkout A^0 &&
2444
2445                 git merge -s recursive B^0 &&
2446
2447                 git ls-files -s >out &&
2448                 test_line_count = 3 out &&
2449
2450                 test_seq 0 11 >expected &&
2451                 test_cmp expected y/d &&
2452                 git add expected &&
2453                 git rev-parse >actual \
2454                         HEAD:y/b HEAD:y/c HEAD:y/d &&
2455                 git rev-parse >expect \
2456                         O:z/b    O:z/c    :0:expected &&
2457                 test_cmp expect actual &&
2458                 test_must_fail git rev-parse HEAD:x/d &&
2459                 test_must_fail git rev-parse HEAD:z/d &&
2460                 test_path_is_missing z/d &&
2461
2462                 test $(git rev-parse HEAD:y/d) != $(git rev-parse O:x/d) &&
2463                 test $(git rev-parse HEAD:y/d) != $(git rev-parse A:x/d) &&
2464                 test $(git rev-parse HEAD:y/d) != $(git rev-parse B:z/d)
2465         )
2466 '
2467
2468 # Testcase 9c, Doubly transitive rename?
2469 #   (Related to testcase 1c, 7e, and 9d)
2470 #   Commit O: z/{b,c},     x/{d,e},    w/f
2471 #   Commit A: y/{b,c},     x/{d,e,f,g}
2472 #   Commit B: z/{b,c,d,e},             w/f
2473 #   Expected: y/{b,c,d,e}, x/{f,g}
2474 #
2475 #   NOTE: x/f and x/g may be slightly confusing here.  The rename from w/f to
2476 #         x/f is clear.  Let's look beyond that.  Here's the logic:
2477 #            Commit B renamed x/ -> z/
2478 #            Commit A renamed z/ -> y/
2479 #         So, we could possibly further rename x/f to z/f to y/f, a doubly
2480 #         transient rename.  However, where does it end?  We can chain these
2481 #         indefinitely (see testcase 9d).  What if there is a D/F conflict
2482 #         at z/f/ or y/f/?  Or just another file conflict at one of those
2483 #         paths?  In the case of an N-long chain of transient renamings,
2484 #         where do we "abort" the rename at?  Can the user make sense of
2485 #         the resulting conflict and resolve it?
2486 #
2487 #         To avoid this confusion I use the simple rule that if the other side
2488 #         of history did a directory rename to a path that your side renamed
2489 #         away, then ignore that particular rename from the other side of
2490 #         history for any implicit directory renames.
2491
2492 test_expect_success '9c-setup: Doubly transitive rename?' '
2493         test_create_repo 9c &&
2494         (
2495                 cd 9c &&
2496
2497                 mkdir z &&
2498                 echo b >z/b &&
2499                 echo c >z/c &&
2500                 mkdir x &&
2501                 echo d >x/d &&
2502                 echo e >x/e &&
2503                 mkdir w &&
2504                 echo f >w/f &&
2505                 git add z x w &&
2506                 test_tick &&
2507                 git commit -m "O" &&
2508
2509                 git branch O &&
2510                 git branch A &&
2511                 git branch B &&
2512
2513                 git checkout A &&
2514                 git mv z y &&
2515                 git mv w/f x/ &&
2516                 echo g >x/g &&
2517                 git add x/g &&
2518                 test_tick &&
2519                 git commit -m "A" &&
2520
2521                 git checkout B &&
2522                 git mv x/d z/d &&
2523                 git mv x/e z/e &&
2524                 test_tick &&
2525                 git commit -m "B"
2526         )
2527 '
2528
2529 test_expect_success '9c-check: Doubly transitive rename?' '
2530         (
2531                 cd 9c &&
2532
2533                 git checkout A^0 &&
2534
2535                 git merge -s recursive B^0 >out &&
2536                 test_i18ngrep "WARNING: Avoiding applying x -> z rename to x/f" out &&
2537
2538                 git ls-files -s >out &&
2539                 test_line_count = 6 out &&
2540                 git ls-files -o >out &&
2541                 test_line_count = 1 out &&
2542
2543                 git rev-parse >actual \
2544                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:y/e HEAD:x/f HEAD:x/g &&
2545                 git rev-parse >expect \
2546                         O:z/b    O:z/c    O:x/d    O:x/e    O:w/f    A:x/g &&
2547                 test_cmp expect actual
2548         )
2549 '
2550
2551 # Testcase 9d, N-fold transitive rename?
2552 #   (Related to testcase 9c...and 1c and 7e)
2553 #   Commit O: z/a, y/b, x/c, w/d, v/e, u/f
2554 #   Commit A:  y/{a,b},  w/{c,d},  u/{e,f}
2555 #   Commit B: z/{a,t}, x/{b,c}, v/{d,e}, u/f
2556 #   Expected: <see NOTE first>
2557 #
2558 #   NOTE: z/ -> y/ (in commit A)
2559 #         y/ -> x/ (in commit B)
2560 #         x/ -> w/ (in commit A)
2561 #         w/ -> v/ (in commit B)
2562 #         v/ -> u/ (in commit A)
2563 #         So, if we add a file to z, say z/t, where should it end up?  In u?
2564 #         What if there's another file or directory named 't' in one of the
2565 #         intervening directories and/or in u itself?  Also, shouldn't the
2566 #         same logic that places 't' in u/ also move ALL other files to u/?
2567 #         What if there are file or directory conflicts in any of them?  If
2568 #         we attempted to do N-way (N-fold? N-ary? N-uple?) transitive renames
2569 #         like this, would the user have any hope of understanding any
2570 #         conflicts or how their working tree ended up?  I think not, so I'm
2571 #         ruling out N-ary transitive renames for N>1.
2572 #
2573 #   Therefore our expected result is:
2574 #     z/t, y/a, x/b, w/c, u/d, u/e, u/f
2575 #   The reason that v/d DOES get transitively renamed to u/d is that u/ isn't
2576 #   renamed somewhere.  A slightly sub-optimal result, but it uses fairly
2577 #   simple rules that are consistent with what we need for all the other
2578 #   testcases and simplifies things for the user.
2579
2580 test_expect_success '9d-setup: N-way transitive rename?' '
2581         test_create_repo 9d &&
2582         (
2583                 cd 9d &&
2584
2585                 mkdir z y x w v u &&
2586                 echo a >z/a &&
2587                 echo b >y/b &&
2588                 echo c >x/c &&
2589                 echo d >w/d &&
2590                 echo e >v/e &&
2591                 echo f >u/f &&
2592                 git add z y x w v u &&
2593                 test_tick &&
2594                 git commit -m "O" &&
2595
2596                 git branch O &&
2597                 git branch A &&
2598                 git branch B &&
2599
2600                 git checkout A &&
2601                 git mv z/a y/ &&
2602                 git mv x/c w/ &&
2603                 git mv v/e u/ &&
2604                 test_tick &&
2605                 git commit -m "A" &&
2606
2607                 git checkout B &&
2608                 echo t >z/t &&
2609                 git mv y/b x/ &&
2610                 git mv w/d v/ &&
2611                 git add z/t &&
2612                 test_tick &&
2613                 git commit -m "B"
2614         )
2615 '
2616
2617 test_expect_success '9d-check: N-way transitive rename?' '
2618         (
2619                 cd 9d &&
2620
2621                 git checkout A^0 &&
2622
2623                 git merge -s recursive B^0 >out &&
2624                 test_i18ngrep "WARNING: Avoiding applying z -> y rename to z/t" out &&
2625                 test_i18ngrep "WARNING: Avoiding applying y -> x rename to y/a" out &&
2626                 test_i18ngrep "WARNING: Avoiding applying x -> w rename to x/b" out &&
2627                 test_i18ngrep "WARNING: Avoiding applying w -> v rename to w/c" out &&
2628
2629                 git ls-files -s >out &&
2630                 test_line_count = 7 out &&
2631                 git ls-files -o >out &&
2632                 test_line_count = 1 out &&
2633
2634                 git rev-parse >actual \
2635                         HEAD:z/t \
2636                         HEAD:y/a HEAD:x/b HEAD:w/c \
2637                         HEAD:u/d HEAD:u/e HEAD:u/f &&
2638                 git rev-parse >expect \
2639                         B:z/t    \
2640                         O:z/a    O:y/b    O:x/c    \
2641                         O:w/d    O:v/e    A:u/f &&
2642                 test_cmp expect actual
2643         )
2644 '
2645
2646 # Testcase 9e, N-to-1 whammo
2647 #   (Related to testcase 9c...and 1c and 7e)
2648 #   Commit O: dir1/{a,b}, dir2/{d,e}, dir3/{g,h}, dirN/{j,k}
2649 #   Commit A: dir1/{a,b,c,yo}, dir2/{d,e,f,yo}, dir3/{g,h,i,yo}, dirN/{j,k,l,yo}
2650 #   Commit B: combined/{a,b,d,e,g,h,j,k}
2651 #   Expected: combined/{a,b,c,d,e,f,g,h,i,j,k,l}, CONFLICT(Nto1) warnings,
2652 #             dir1/yo, dir2/yo, dir3/yo, dirN/yo
2653
2654 test_expect_success '9e-setup: N-to-1 whammo' '
2655         test_create_repo 9e &&
2656         (
2657                 cd 9e &&
2658
2659                 mkdir dir1 dir2 dir3 dirN &&
2660                 echo a >dir1/a &&
2661                 echo b >dir1/b &&
2662                 echo d >dir2/d &&
2663                 echo e >dir2/e &&
2664                 echo g >dir3/g &&
2665                 echo h >dir3/h &&
2666                 echo j >dirN/j &&
2667                 echo k >dirN/k &&
2668                 git add dir* &&
2669                 test_tick &&
2670                 git commit -m "O" &&
2671
2672                 git branch O &&
2673                 git branch A &&
2674                 git branch B &&
2675
2676                 git checkout A &&
2677                 echo c  >dir1/c &&
2678                 echo yo >dir1/yo &&
2679                 echo f  >dir2/f &&
2680                 echo yo >dir2/yo &&
2681                 echo i  >dir3/i &&
2682                 echo yo >dir3/yo &&
2683                 echo l  >dirN/l &&
2684                 echo yo >dirN/yo &&
2685                 git add dir* &&
2686                 test_tick &&
2687                 git commit -m "A" &&
2688
2689                 git checkout B &&
2690                 git mv dir1 combined &&
2691                 git mv dir2/* combined/ &&
2692                 git mv dir3/* combined/ &&
2693                 git mv dirN/* combined/ &&
2694                 test_tick &&
2695                 git commit -m "B"
2696         )
2697 '
2698
2699 test_expect_success C_LOCALE_OUTPUT '9e-check: N-to-1 whammo' '
2700         (
2701                 cd 9e &&
2702
2703                 git checkout A^0 &&
2704
2705                 test_must_fail git merge -s recursive B^0 >out &&
2706                 grep "CONFLICT (implicit dir rename): Cannot map more than one path to combined/yo" out >error_line &&
2707                 grep -q dir1/yo error_line &&
2708                 grep -q dir2/yo error_line &&
2709                 grep -q dir3/yo error_line &&
2710                 grep -q dirN/yo error_line &&
2711
2712                 git ls-files -s >out &&
2713                 test_line_count = 16 out &&
2714                 git ls-files -u >out &&
2715                 test_line_count = 0 out &&
2716                 git ls-files -o >out &&
2717                 test_line_count = 2 out &&
2718
2719                 git rev-parse >actual \
2720                         :0:combined/a :0:combined/b :0:combined/c \
2721                         :0:combined/d :0:combined/e :0:combined/f \
2722                         :0:combined/g :0:combined/h :0:combined/i \
2723                         :0:combined/j :0:combined/k :0:combined/l &&
2724                 git rev-parse >expect \
2725                          O:dir1/a      O:dir1/b      A:dir1/c \
2726                          O:dir2/d      O:dir2/e      A:dir2/f \
2727                          O:dir3/g      O:dir3/h      A:dir3/i \
2728                          O:dirN/j      O:dirN/k      A:dirN/l &&
2729                 test_cmp expect actual &&
2730
2731                 git rev-parse >actual \
2732                         :0:dir1/yo :0:dir2/yo :0:dir3/yo :0:dirN/yo &&
2733                 git rev-parse >expect \
2734                          A:dir1/yo  A:dir2/yo  A:dir3/yo  A:dirN/yo &&
2735                 test_cmp expect actual
2736         )
2737 '
2738
2739 # Testcase 9f, Renamed directory that only contained immediate subdirs
2740 #   (Related to testcases 1e & 9g)
2741 #   Commit O: goal/{a,b}/$more_files
2742 #   Commit A: priority/{a,b}/$more_files
2743 #   Commit B: goal/{a,b}/$more_files, goal/c
2744 #   Expected: priority/{a,b}/$more_files, priority/c
2745
2746 test_expect_success '9f-setup: Renamed directory that only contained immediate subdirs' '
2747         test_create_repo 9f &&
2748         (
2749                 cd 9f &&
2750
2751                 mkdir -p goal/a &&
2752                 mkdir -p goal/b &&
2753                 echo foo >goal/a/foo &&
2754                 echo bar >goal/b/bar &&
2755                 echo baz >goal/b/baz &&
2756                 git add goal &&
2757                 test_tick &&
2758                 git commit -m "O" &&
2759
2760                 git branch O &&
2761                 git branch A &&
2762                 git branch B &&
2763
2764                 git checkout A &&
2765                 git mv goal/ priority &&
2766                 test_tick &&
2767                 git commit -m "A" &&
2768
2769                 git checkout B &&
2770                 echo c >goal/c &&
2771                 git add goal/c &&
2772                 test_tick &&
2773                 git commit -m "B"
2774         )
2775 '
2776
2777 test_expect_success '9f-check: Renamed directory that only contained immediate subdirs' '
2778         (
2779                 cd 9f &&
2780
2781                 git checkout A^0 &&
2782
2783                 git merge -s recursive B^0 &&
2784
2785                 git ls-files -s >out &&
2786                 test_line_count = 4 out &&
2787
2788                 git rev-parse >actual \
2789                         HEAD:priority/a/foo \
2790                         HEAD:priority/b/bar \
2791                         HEAD:priority/b/baz \
2792                         HEAD:priority/c &&
2793                 git rev-parse >expect \
2794                         O:goal/a/foo \
2795                         O:goal/b/bar \
2796                         O:goal/b/baz \
2797                         B:goal/c &&
2798                 test_cmp expect actual &&
2799                 test_must_fail git rev-parse HEAD:goal/c
2800         )
2801 '
2802
2803 # Testcase 9g, Renamed directory that only contained immediate subdirs, immediate subdirs renamed
2804 #   (Related to testcases 1e & 9f)
2805 #   Commit O: goal/{a,b}/$more_files
2806 #   Commit A: priority/{alpha,bravo}/$more_files
2807 #   Commit B: goal/{a,b}/$more_files, goal/c
2808 #   Expected: priority/{alpha,bravo}/$more_files, priority/c
2809
2810 test_expect_success '9g-setup: Renamed directory that only contained immediate subdirs, immediate subdirs renamed' '
2811         test_create_repo 9g &&
2812         (
2813                 cd 9g &&
2814
2815                 mkdir -p goal/a &&
2816                 mkdir -p goal/b &&
2817                 echo foo >goal/a/foo &&
2818                 echo bar >goal/b/bar &&
2819                 echo baz >goal/b/baz &&
2820                 git add goal &&
2821                 test_tick &&
2822                 git commit -m "O" &&
2823
2824                 git branch O &&
2825                 git branch A &&
2826                 git branch B &&
2827
2828                 git checkout A &&
2829                 mkdir priority &&
2830                 git mv goal/a/ priority/alpha &&
2831                 git mv goal/b/ priority/beta &&
2832                 rmdir goal/ &&
2833                 test_tick &&
2834                 git commit -m "A" &&
2835
2836                 git checkout B &&
2837                 echo c >goal/c &&
2838                 git add goal/c &&
2839                 test_tick &&
2840                 git commit -m "B"
2841         )
2842 '
2843
2844 test_expect_failure '9g-check: Renamed directory that only contained immediate subdirs, immediate subdirs renamed' '
2845         (
2846                 cd 9g &&
2847
2848                 git checkout A^0 &&
2849
2850                 git merge -s recursive B^0 &&
2851
2852                 git ls-files -s >out &&
2853                 test_line_count = 4 out &&
2854
2855                 git rev-parse >actual \
2856                         HEAD:priority/alpha/foo \
2857                         HEAD:priority/beta/bar  \
2858                         HEAD:priority/beta/baz  \
2859                         HEAD:priority/c &&
2860                 git rev-parse >expect \
2861                         O:goal/a/foo \
2862                         O:goal/b/bar \
2863                         O:goal/b/baz \
2864                         B:goal/c &&
2865                 test_cmp expect actual &&
2866                 test_must_fail git rev-parse HEAD:goal/c
2867         )
2868 '
2869
2870 # Testcase 9h, Avoid implicit rename if involved as source on other side
2871 #   (Extremely closely related to testcase 3a)
2872 #   Commit O: z/{b,c,d_1}
2873 #   Commit A: z/{b,c,d_2}
2874 #   Commit B: y/{b,c}, x/d_1
2875 #   Expected: y/{b,c}, x/d_2
2876 #   NOTE: If we applied the z/ -> y/ rename to z/d, then we'd end up with
2877 #         a rename/rename(1to2) conflict (z/d -> y/d vs. x/d)
2878 test_expect_success '9h-setup: Avoid dir rename on merely modified path' '
2879         test_create_repo 9h &&
2880         (
2881                 cd 9h &&
2882
2883                 mkdir z &&
2884                 echo b >z/b &&
2885                 echo c >z/c &&
2886                 printf "1\n2\n3\n4\n5\n6\n7\n8\nd\n" >z/d &&
2887                 git add z &&
2888                 test_tick &&
2889                 git commit -m "O" &&
2890
2891                 git branch O &&
2892                 git branch A &&
2893                 git branch B &&
2894
2895                 git checkout A &&
2896                 test_tick &&
2897                 echo more >>z/d &&
2898                 git add z/d &&
2899                 git commit -m "A" &&
2900
2901                 git checkout B &&
2902                 mkdir y &&
2903                 mkdir x &&
2904                 git mv z/b y/ &&
2905                 git mv z/c y/ &&
2906                 git mv z/d x/ &&
2907                 rmdir z &&
2908                 test_tick &&
2909                 git commit -m "B"
2910         )
2911 '
2912
2913 test_expect_success '9h-check: Avoid dir rename on merely modified path' '
2914         (
2915                 cd 9h &&
2916
2917                 git checkout A^0 &&
2918
2919                 git merge -s recursive B^0 &&
2920
2921                 git ls-files -s >out &&
2922                 test_line_count = 3 out &&
2923
2924                 git rev-parse >actual \
2925                         HEAD:y/b HEAD:y/c HEAD:x/d &&
2926                 git rev-parse >expect \
2927                         O:z/b    O:z/c    A:z/d &&
2928                 test_cmp expect actual
2929         )
2930 '
2931
2932 ###########################################################################
2933 # Rules suggested by section 9:
2934 #
2935 #   If the other side of history did a directory rename to a path that your
2936 #   side renamed away, then ignore that particular rename from the other
2937 #   side of history for any implicit directory renames.
2938 ###########################################################################
2939
2940 ###########################################################################
2941 # SECTION 10: Handling untracked files
2942 #
2943 # unpack_trees(), upon which the recursive merge algorithm is based, aborts
2944 # the operation if untracked or dirty files would be deleted or overwritten
2945 # by the merge.  Unfortunately, unpack_trees() does not understand renames,
2946 # and if it doesn't abort, then it muddies up the working directory before
2947 # we even get to the point of detecting renames, so we need some special
2948 # handling, at least in the case of directory renames.
2949 ###########################################################################
2950
2951 # Testcase 10a, Overwrite untracked: normal rename/delete
2952 #   Commit O: z/{b,c_1}
2953 #   Commit A: z/b + untracked z/c + untracked z/d
2954 #   Commit B: z/{b,d_1}
2955 #   Expected: Aborted Merge +
2956 #       ERROR_MSG(untracked working tree files would be overwritten by merge)
2957
2958 test_expect_success '10a-setup: Overwrite untracked with normal rename/delete' '
2959         test_create_repo 10a &&
2960         (
2961                 cd 10a &&
2962
2963                 mkdir z &&
2964                 echo b >z/b &&
2965                 echo c >z/c &&
2966                 git add z &&
2967                 test_tick &&
2968                 git commit -m "O" &&
2969
2970                 git branch O &&
2971                 git branch A &&
2972                 git branch B &&
2973
2974                 git checkout A &&
2975                 git rm z/c &&
2976                 test_tick &&
2977                 git commit -m "A" &&
2978
2979                 git checkout B &&
2980                 git mv z/c z/d &&
2981                 test_tick &&
2982                 git commit -m "B"
2983         )
2984 '
2985
2986 test_expect_success '10a-check: Overwrite untracked with normal rename/delete' '
2987         (
2988                 cd 10a &&
2989
2990                 git checkout A^0 &&
2991                 echo very >z/c &&
2992                 echo important >z/d &&
2993
2994                 test_must_fail git merge -s recursive B^0 >out 2>err &&
2995                 test_i18ngrep "The following untracked working tree files would be overwritten by merge" err &&
2996
2997                 git ls-files -s >out &&
2998                 test_line_count = 1 out &&
2999                 git ls-files -o >out &&
3000                 test_line_count = 4 out &&
3001
3002                 echo very >expect &&
3003                 test_cmp expect z/c &&
3004
3005                 echo important >expect &&
3006                 test_cmp expect z/d &&
3007
3008                 git rev-parse HEAD:z/b >actual &&
3009                 git rev-parse O:z/b >expect &&
3010                 test_cmp expect actual
3011         )
3012 '
3013
3014 # Testcase 10b, Overwrite untracked: dir rename + delete
3015 #   Commit O: z/{b,c_1}
3016 #   Commit A: y/b + untracked y/{c,d,e}
3017 #   Commit B: z/{b,d_1,e}
3018 #   Expected: Failed Merge; y/b + untracked y/c + untracked y/d on disk +
3019 #             z/c_1 -> z/d_1 rename recorded at stage 3 for y/d +
3020 #       ERROR_MSG(refusing to lose untracked file at 'y/d')
3021
3022 test_expect_success '10b-setup: Overwrite untracked with dir rename + delete' '
3023         test_create_repo 10b &&
3024         (
3025                 cd 10b &&
3026
3027                 mkdir z &&
3028                 echo b >z/b &&
3029                 echo c >z/c &&
3030                 git add z &&
3031                 test_tick &&
3032                 git commit -m "O" &&
3033
3034                 git branch O &&
3035                 git branch A &&
3036                 git branch B &&
3037
3038                 git checkout A &&
3039                 git rm z/c &&
3040                 git mv z/ y/ &&
3041                 test_tick &&
3042                 git commit -m "A" &&
3043
3044                 git checkout B &&
3045                 git mv z/c z/d &&
3046                 echo e >z/e &&
3047                 git add z/e &&
3048                 test_tick &&
3049                 git commit -m "B"
3050         )
3051 '
3052
3053 test_expect_success '10b-check: Overwrite untracked with dir rename + delete' '
3054         (
3055                 cd 10b &&
3056
3057                 git checkout A^0 &&
3058                 echo very >y/c &&
3059                 echo important >y/d &&
3060                 echo contents >y/e &&
3061
3062                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3063                 test_i18ngrep "CONFLICT (rename/delete).*Version B\^0 of y/d left in tree at y/d~B\^0" out &&
3064                 test_i18ngrep "Error: Refusing to lose untracked file at y/e; writing to y/e~B\^0 instead" out &&
3065
3066                 git ls-files -s >out &&
3067                 test_line_count = 3 out &&
3068                 git ls-files -u >out &&
3069                 test_line_count = 2 out &&
3070                 git ls-files -o >out &&
3071                 test_line_count = 5 out &&
3072
3073                 git rev-parse >actual \
3074                         :0:y/b :3:y/d :3:y/e &&
3075                 git rev-parse >expect \
3076                         O:z/b  O:z/c  B:z/e &&
3077                 test_cmp expect actual &&
3078
3079                 echo very >expect &&
3080                 test_cmp expect y/c &&
3081
3082                 echo important >expect &&
3083                 test_cmp expect y/d &&
3084
3085                 echo contents >expect &&
3086                 test_cmp expect y/e
3087         )
3088 '
3089
3090 # Testcase 10c, Overwrite untracked: dir rename/rename(1to2)
3091 #   Commit O: z/{a,b}, x/{c,d}
3092 #   Commit A: y/{a,b}, w/c, x/d + different untracked y/c
3093 #   Commit B: z/{a,b,c}, x/d
3094 #   Expected: Failed Merge; y/{a,b} + x/d + untracked y/c +
3095 #             CONFLICT(rename/rename) x/c -> w/c vs y/c +
3096 #             y/c~B^0 +
3097 #             ERROR_MSG(Refusing to lose untracked file at y/c)
3098
3099 test_expect_success '10c-setup: Overwrite untracked with dir rename/rename(1to2)' '
3100         test_create_repo 10c &&
3101         (
3102                 cd 10c &&
3103
3104                 mkdir z x &&
3105                 echo a >z/a &&
3106                 echo b >z/b &&
3107                 echo c >x/c &&
3108                 echo d >x/d &&
3109                 git add z x &&
3110                 test_tick &&
3111                 git commit -m "O" &&
3112
3113                 git branch O &&
3114                 git branch A &&
3115                 git branch B &&
3116
3117                 git checkout A &&
3118                 mkdir w &&
3119                 git mv x/c w/c &&
3120                 git mv z/ y/ &&
3121                 test_tick &&
3122                 git commit -m "A" &&
3123
3124                 git checkout B &&
3125                 git mv x/c z/ &&
3126                 test_tick &&
3127                 git commit -m "B"
3128         )
3129 '
3130
3131 test_expect_success '10c-check: Overwrite untracked with dir rename/rename(1to2)' '
3132         (
3133                 cd 10c &&
3134
3135                 git checkout A^0 &&
3136                 echo important >y/c &&
3137
3138                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3139                 test_i18ngrep "CONFLICT (rename/rename)" out &&
3140                 test_i18ngrep "Refusing to lose untracked file at y/c; adding as y/c~B\^0 instead" out &&
3141
3142                 git ls-files -s >out &&
3143                 test_line_count = 6 out &&
3144                 git ls-files -u >out &&
3145                 test_line_count = 3 out &&
3146                 git ls-files -o >out &&
3147                 test_line_count = 3 out &&
3148
3149                 git rev-parse >actual \
3150                         :0:y/a :0:y/b :0:x/d :1:x/c :2:w/c :3:y/c &&
3151                 git rev-parse >expect \
3152                          O:z/a  O:z/b  O:x/d  O:x/c  O:x/c  O:x/c &&
3153                 test_cmp expect actual &&
3154
3155                 git hash-object y/c~B^0 >actual &&
3156                 git rev-parse O:x/c >expect &&
3157                 test_cmp expect actual &&
3158
3159                 echo important >expect &&
3160                 test_cmp expect y/c
3161         )
3162 '
3163
3164 # Testcase 10d, Delete untracked w/ dir rename/rename(2to1)
3165 #   Commit O: z/{a,b,c_1},        x/{d,e,f_2}
3166 #   Commit A: y/{a,b},            x/{d,e,f_2,wham_1} + untracked y/wham
3167 #   Commit B: z/{a,b,c_1,wham_2}, y/{d,e}
3168 #   Expected: Failed Merge; y/{a,b,d,e} + untracked y/{wham,wham~B^0,wham~HEAD}+
3169 #             CONFLICT(rename/rename) z/c_1 vs x/f_2 -> y/wham
3170 #             ERROR_MSG(Refusing to lose untracked file at y/wham)
3171
3172 test_expect_success '10d-setup: Delete untracked with dir rename/rename(2to1)' '
3173         test_create_repo 10d &&
3174         (
3175                 cd 10d &&
3176
3177                 mkdir z x &&
3178                 echo a >z/a &&
3179                 echo b >z/b &&
3180                 echo c >z/c &&
3181                 echo d >x/d &&
3182                 echo e >x/e &&
3183                 echo f >x/f &&
3184                 git add z x &&
3185                 test_tick &&
3186                 git commit -m "O" &&
3187
3188                 git branch O &&
3189                 git branch A &&
3190                 git branch B &&
3191
3192                 git checkout A &&
3193                 git mv z/c x/wham &&
3194                 git mv z/ y/ &&
3195                 test_tick &&
3196                 git commit -m "A" &&
3197
3198                 git checkout B &&
3199                 git mv x/f z/wham &&
3200                 git mv x/ y/ &&
3201                 test_tick &&
3202                 git commit -m "B"
3203         )
3204 '
3205
3206 test_expect_success '10d-check: Delete untracked with dir rename/rename(2to1)' '
3207         (
3208                 cd 10d &&
3209
3210                 git checkout A^0 &&
3211                 echo important >y/wham &&
3212
3213                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3214                 test_i18ngrep "CONFLICT (rename/rename)" out &&
3215                 test_i18ngrep "Refusing to lose untracked file at y/wham" out &&
3216
3217                 git ls-files -s >out &&
3218                 test_line_count = 6 out &&
3219                 git ls-files -u >out &&
3220                 test_line_count = 2 out &&
3221                 git ls-files -o >out &&
3222                 test_line_count = 4 out &&
3223
3224                 git rev-parse >actual \
3225                         :0:y/a :0:y/b :0:y/d :0:y/e :2:y/wham :3:y/wham &&
3226                 git rev-parse >expect \
3227                          O:z/a  O:z/b  O:x/d  O:x/e  O:z/c     O:x/f &&
3228                 test_cmp expect actual &&
3229
3230                 test_must_fail git rev-parse :1:y/wham &&
3231
3232                 echo important >expect &&
3233                 test_cmp expect y/wham &&
3234
3235                 git hash-object >actual \
3236                         y/wham~B^0 y/wham~HEAD &&
3237                 git rev-parse >expect \
3238                         O:x/f      O:z/c &&
3239                 test_cmp expect actual
3240         )
3241 '
3242
3243 # Testcase 10e, Does git complain about untracked file that's not in the way?
3244 #   Commit O: z/{a,b}
3245 #   Commit A: y/{a,b} + untracked z/c
3246 #   Commit B: z/{a,b,c}
3247 #   Expected: y/{a,b,c} + untracked z/c
3248
3249 test_expect_success '10e-setup: Does git complain about untracked file that is not really in the way?' '
3250         test_create_repo 10e &&
3251         (
3252                 cd 10e &&
3253
3254                 mkdir z &&
3255                 echo a >z/a &&
3256                 echo b >z/b &&
3257                 git add z &&
3258                 test_tick &&
3259                 git commit -m "O" &&
3260
3261                 git branch O &&
3262                 git branch A &&
3263                 git branch B &&
3264
3265                 git checkout A &&
3266                 git mv z/ y/ &&
3267                 test_tick &&
3268                 git commit -m "A" &&
3269
3270                 git checkout B &&
3271                 echo c >z/c &&
3272                 git add z/c &&
3273                 test_tick &&
3274                 git commit -m "B"
3275         )
3276 '
3277
3278 test_expect_failure '10e-check: Does git complain about untracked file that is not really in the way?' '
3279         (
3280                 cd 10e &&
3281
3282                 git checkout A^0 &&
3283                 mkdir z &&
3284                 echo random >z/c &&
3285
3286                 git merge -s recursive B^0 >out 2>err &&
3287                 test_i18ngrep ! "following untracked working tree files would be overwritten by merge" err &&
3288
3289                 git ls-files -s >out &&
3290                 test_line_count = 3 out &&
3291                 git ls-files -u >out &&
3292                 test_line_count = 0 out &&
3293                 git ls-files -o >out &&
3294                 test_line_count = 3 out &&
3295
3296                 git rev-parse >actual \
3297                         :0:y/a :0:y/b :0:y/c &&
3298                 git rev-parse >expect \
3299                          O:z/a  O:z/b  B:z/c &&
3300                 test_cmp expect actual &&
3301
3302                 echo random >expect &&
3303                 test_cmp expect z/c
3304         )
3305 '
3306
3307 ###########################################################################
3308 # SECTION 11: Handling dirty (not up-to-date) files
3309 #
3310 # unpack_trees(), upon which the recursive merge algorithm is based, aborts
3311 # the operation if untracked or dirty files would be deleted or overwritten
3312 # by the merge.  Unfortunately, unpack_trees() does not understand renames,
3313 # and if it doesn't abort, then it muddies up the working directory before
3314 # we even get to the point of detecting renames, so we need some special
3315 # handling.  This was true even of normal renames, but there are additional
3316 # codepaths that need special handling with directory renames.  Add
3317 # testcases for both renamed-by-directory-rename-detection and standard
3318 # rename cases.
3319 ###########################################################################
3320
3321 # Testcase 11a, Avoid losing dirty contents with simple rename
3322 #   Commit O: z/{a,b_v1},
3323 #   Commit A: z/{a,c_v1}, and z/c_v1 has uncommitted mods
3324 #   Commit B: z/{a,b_v2}
3325 #   Expected: ERROR_MSG(Refusing to lose dirty file at z/c) +
3326 #             z/a, staged version of z/c has sha1sum matching B:z/b_v2,
3327 #             z/c~HEAD with contents of B:z/b_v2,
3328 #             z/c with uncommitted mods on top of A:z/c_v1
3329
3330 test_expect_success '11a-setup: Avoid losing dirty contents with simple rename' '
3331         test_create_repo 11a &&
3332         (
3333                 cd 11a &&
3334
3335                 mkdir z &&
3336                 echo a >z/a &&
3337                 test_seq 1 10 >z/b &&
3338                 git add z &&
3339                 test_tick &&
3340                 git commit -m "O" &&
3341
3342                 git branch O &&
3343                 git branch A &&
3344                 git branch B &&
3345
3346                 git checkout A &&
3347                 git mv z/b z/c &&
3348                 test_tick &&
3349                 git commit -m "A" &&
3350
3351                 git checkout B &&
3352                 echo 11 >>z/b &&
3353                 git add z/b &&
3354                 test_tick &&
3355                 git commit -m "B"
3356         )
3357 '
3358
3359 test_expect_success '11a-check: Avoid losing dirty contents with simple rename' '
3360         (
3361                 cd 11a &&
3362
3363                 git checkout A^0 &&
3364                 echo stuff >>z/c &&
3365
3366                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3367                 test_i18ngrep "Refusing to lose dirty file at z/c" out &&
3368
3369                 test_seq 1 10 >expected &&
3370                 echo stuff >>expected &&
3371                 test_cmp expected z/c &&
3372
3373                 git ls-files -s >out &&
3374                 test_line_count = 2 out &&
3375                 git ls-files -u >out &&
3376                 test_line_count = 1 out &&
3377                 git ls-files -o >out &&
3378                 test_line_count = 4 out &&
3379
3380                 git rev-parse >actual \
3381                         :0:z/a :2:z/c &&
3382                 git rev-parse >expect \
3383                          O:z/a  B:z/b &&
3384                 test_cmp expect actual &&
3385
3386                 git hash-object z/c~HEAD >actual &&
3387                 git rev-parse B:z/b >expect &&
3388                 test_cmp expect actual
3389         )
3390 '
3391
3392 # Testcase 11b, Avoid losing dirty file involved in directory rename
3393 #   Commit O: z/a,         x/{b,c_v1}
3394 #   Commit A: z/{a,c_v1},  x/b,       and z/c_v1 has uncommitted mods
3395 #   Commit B: y/a,         x/{b,c_v2}
3396 #   Expected: y/{a,c_v2}, x/b, z/c_v1 with uncommitted mods untracked,
3397 #             ERROR_MSG(Refusing to lose dirty file at z/c)
3398
3399
3400 test_expect_success '11b-setup: Avoid losing dirty file involved in directory rename' '
3401         test_create_repo 11b &&
3402         (
3403                 cd 11b &&
3404
3405                 mkdir z x &&
3406                 echo a >z/a &&
3407                 echo b >x/b &&
3408                 test_seq 1 10 >x/c &&
3409                 git add z x &&
3410                 test_tick &&
3411                 git commit -m "O" &&
3412
3413                 git branch O &&
3414                 git branch A &&
3415                 git branch B &&
3416
3417                 git checkout A &&
3418                 git mv x/c z/c &&
3419                 test_tick &&
3420                 git commit -m "A" &&
3421
3422                 git checkout B &&
3423                 git mv z y &&
3424                 echo 11 >>x/c &&
3425                 git add x/c &&
3426                 test_tick &&
3427                 git commit -m "B"
3428         )
3429 '
3430
3431 test_expect_success '11b-check: Avoid losing dirty file involved in directory rename' '
3432         (
3433                 cd 11b &&
3434
3435                 git checkout A^0 &&
3436                 echo stuff >>z/c &&
3437
3438                 git merge -s recursive B^0 >out 2>err &&
3439                 test_i18ngrep "Refusing to lose dirty file at z/c" out &&
3440
3441                 grep -q stuff z/c &&
3442                 test_seq 1 10 >expected &&
3443                 echo stuff >>expected &&
3444                 test_cmp expected z/c &&
3445
3446                 git ls-files -s >out &&
3447                 test_line_count = 3 out &&
3448                 git ls-files -u >out &&
3449                 test_line_count = 0 out &&
3450                 git ls-files -m >out &&
3451                 test_line_count = 0 out &&
3452                 git ls-files -o >out &&
3453                 test_line_count = 4 out &&
3454
3455                 git rev-parse >actual \
3456                         :0:x/b :0:y/a :0:y/c &&
3457                 git rev-parse >expect \
3458                          O:x/b  O:z/a  B:x/c &&
3459                 test_cmp expect actual &&
3460
3461                 git hash-object y/c >actual &&
3462                 git rev-parse B:x/c >expect &&
3463                 test_cmp expect actual
3464         )
3465 '
3466
3467 # Testcase 11c, Avoid losing not-up-to-date with rename + D/F conflict
3468 #   Commit O: y/a,         x/{b,c_v1}
3469 #   Commit A: y/{a,c_v1},  x/b,       and y/c_v1 has uncommitted mods
3470 #   Commit B: y/{a,c/d},   x/{b,c_v2}
3471 #   Expected: Abort_msg("following files would be overwritten by merge") +
3472 #             y/c left untouched (still has uncommitted mods)
3473
3474 test_expect_success '11c-setup: Avoid losing not-uptodate with rename + D/F conflict' '
3475         test_create_repo 11c &&
3476         (
3477                 cd 11c &&
3478
3479                 mkdir y x &&
3480                 echo a >y/a &&
3481                 echo b >x/b &&
3482                 test_seq 1 10 >x/c &&
3483                 git add y x &&
3484                 test_tick &&
3485                 git commit -m "O" &&
3486
3487                 git branch O &&
3488                 git branch A &&
3489                 git branch B &&
3490
3491                 git checkout A &&
3492                 git mv x/c y/c &&
3493                 test_tick &&
3494                 git commit -m "A" &&
3495
3496                 git checkout B &&
3497                 mkdir y/c &&
3498                 echo d >y/c/d &&
3499                 echo 11 >>x/c &&
3500                 git add x/c y/c/d &&
3501                 test_tick &&
3502                 git commit -m "B"
3503         )
3504 '
3505
3506 test_expect_success '11c-check: Avoid losing not-uptodate with rename + D/F conflict' '
3507         (
3508                 cd 11c &&
3509
3510                 git checkout A^0 &&
3511                 echo stuff >>y/c &&
3512
3513                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3514                 test_i18ngrep "following files would be overwritten by merge" err &&
3515
3516                 grep -q stuff y/c &&
3517                 test_seq 1 10 >expected &&
3518                 echo stuff >>expected &&
3519                 test_cmp expected y/c &&
3520
3521                 git ls-files -s >out &&
3522                 test_line_count = 3 out &&
3523                 git ls-files -u >out &&
3524                 test_line_count = 0 out &&
3525                 git ls-files -m >out &&
3526                 test_line_count = 1 out &&
3527                 git ls-files -o >out &&
3528                 test_line_count = 3 out
3529         )
3530 '
3531
3532 # Testcase 11d, Avoid losing not-up-to-date with rename + D/F conflict
3533 #   Commit O: z/a,         x/{b,c_v1}
3534 #   Commit A: z/{a,c_v1},  x/b,       and z/c_v1 has uncommitted mods
3535 #   Commit B: y/{a,c/d},   x/{b,c_v2}
3536 #   Expected: D/F: y/c_v2 vs y/c/d) +
3537 #             Warning_Msg("Refusing to lose dirty file at z/c) +
3538 #             y/{a,c~HEAD,c/d}, x/b, now-untracked z/c_v1 with uncommitted mods
3539
3540 test_expect_success '11d-setup: Avoid losing not-uptodate with rename + D/F conflict' '
3541         test_create_repo 11d &&
3542         (
3543                 cd 11d &&
3544
3545                 mkdir z x &&
3546                 echo a >z/a &&
3547                 echo b >x/b &&
3548                 test_seq 1 10 >x/c &&
3549                 git add z x &&
3550                 test_tick &&
3551                 git commit -m "O" &&
3552
3553                 git branch O &&
3554                 git branch A &&
3555                 git branch B &&
3556
3557                 git checkout A &&
3558                 git mv x/c z/c &&
3559                 test_tick &&
3560                 git commit -m "A" &&
3561
3562                 git checkout B &&
3563                 git mv z y &&
3564                 mkdir y/c &&
3565                 echo d >y/c/d &&
3566                 echo 11 >>x/c &&
3567                 git add x/c y/c/d &&
3568                 test_tick &&
3569                 git commit -m "B"
3570         )
3571 '
3572
3573 test_expect_success '11d-check: Avoid losing not-uptodate with rename + D/F conflict' '
3574         (
3575                 cd 11d &&
3576
3577                 git checkout A^0 &&
3578                 echo stuff >>z/c &&
3579
3580                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3581                 test_i18ngrep "Refusing to lose dirty file at z/c" out &&
3582
3583                 grep -q stuff z/c &&
3584                 test_seq 1 10 >expected &&
3585                 echo stuff >>expected &&
3586                 test_cmp expected z/c &&
3587
3588                 git ls-files -s >out &&
3589                 test_line_count = 4 out &&
3590                 git ls-files -u >out &&
3591                 test_line_count = 1 out &&
3592                 git ls-files -o >out &&
3593                 test_line_count = 5 out &&
3594
3595                 git rev-parse >actual \
3596                         :0:x/b :0:y/a :0:y/c/d :3:y/c &&
3597                 git rev-parse >expect \
3598                          O:x/b  O:z/a  B:y/c/d  B:x/c &&
3599                 test_cmp expect actual &&
3600
3601                 git hash-object y/c~HEAD >actual &&
3602                 git rev-parse B:x/c >expect &&
3603                 test_cmp expect actual
3604         )
3605 '
3606
3607 # Testcase 11e, Avoid deleting not-up-to-date with dir rename/rename(1to2)/add
3608 #   Commit O: z/{a,b},      x/{c_1,d}
3609 #   Commit A: y/{a,b,c_2},  x/d, w/c_1, and y/c_2 has uncommitted mods
3610 #   Commit B: z/{a,b,c_1},  x/d
3611 #   Expected: Failed Merge; y/{a,b} + x/d +
3612 #             CONFLICT(rename/rename) x/c_1 -> w/c_1 vs y/c_1 +
3613 #             ERROR_MSG(Refusing to lose dirty file at y/c)
3614 #             y/c~B^0 has O:x/c_1 contents
3615 #             y/c~HEAD has A:y/c_2 contents
3616 #             y/c has dirty file from before merge
3617
3618 test_expect_success '11e-setup: Avoid deleting not-uptodate with dir rename/rename(1to2)/add' '
3619         test_create_repo 11e &&
3620         (
3621                 cd 11e &&
3622
3623                 mkdir z x &&
3624                 echo a >z/a &&
3625                 echo b >z/b &&
3626                 echo c >x/c &&
3627                 echo d >x/d &&
3628                 git add z x &&
3629                 test_tick &&
3630                 git commit -m "O" &&
3631
3632                 git branch O &&
3633                 git branch A &&
3634                 git branch B &&
3635
3636                 git checkout A &&
3637                 git mv z/ y/ &&
3638                 echo different >y/c &&
3639                 mkdir w &&
3640                 git mv x/c w/ &&
3641                 git add y/c &&
3642                 test_tick &&
3643                 git commit -m "A" &&
3644
3645                 git checkout B &&
3646                 git mv x/c z/ &&
3647                 test_tick &&
3648                 git commit -m "B"
3649         )
3650 '
3651
3652 test_expect_success '11e-check: Avoid deleting not-uptodate with dir rename/rename(1to2)/add' '
3653         (
3654                 cd 11e &&
3655
3656                 git checkout A^0 &&
3657                 echo mods >>y/c &&
3658
3659                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3660                 test_i18ngrep "CONFLICT (rename/rename)" out &&
3661                 test_i18ngrep "Refusing to lose dirty file at y/c" out &&
3662
3663                 git ls-files -s >out &&
3664                 test_line_count = 7 out &&
3665                 git ls-files -u >out &&
3666                 test_line_count = 4 out &&
3667                 git ls-files -o >out &&
3668                 test_line_count = 4 out &&
3669
3670                 echo different >expected &&
3671                 echo mods >>expected &&
3672                 test_cmp expected y/c &&
3673
3674                 git rev-parse >actual \
3675                         :0:y/a :0:y/b :0:x/d :1:x/c :2:w/c :2:y/c :3:y/c &&
3676                 git rev-parse >expect \
3677                          O:z/a  O:z/b  O:x/d  O:x/c  O:x/c  A:y/c  O:x/c &&
3678                 test_cmp expect actual &&
3679
3680                 git hash-object >actual \
3681                         y/c~B^0 y/c~HEAD &&
3682                 git rev-parse >expect \
3683                         O:x/c   A:y/c &&
3684                 test_cmp expect actual
3685         )
3686 '
3687
3688 # Testcase 11f, Avoid deleting not-up-to-date w/ dir rename/rename(2to1)
3689 #   Commit O: z/{a,b},        x/{c_1,d_2}
3690 #   Commit A: y/{a,b,wham_1}, x/d_2, except y/wham has uncommitted mods
3691 #   Commit B: z/{a,b,wham_2}, x/c_1
3692 #   Expected: Failed Merge; y/{a,b} + untracked y/{wham~B^0,wham~B^HEAD} +
3693 #             y/wham with dirty changes from before merge +
3694 #             CONFLICT(rename/rename) x/c vs x/d -> y/wham
3695 #             ERROR_MSG(Refusing to lose dirty file at y/wham)
3696
3697 test_expect_success '11f-setup: Avoid deleting not-uptodate with dir rename/rename(2to1)' '
3698         test_create_repo 11f &&
3699         (
3700                 cd 11f &&
3701
3702                 mkdir z x &&
3703                 echo a >z/a &&
3704                 echo b >z/b &&
3705                 test_seq 1 10 >x/c &&
3706                 echo d >x/d &&
3707                 git add z x &&
3708                 test_tick &&
3709                 git commit -m "O" &&
3710
3711                 git branch O &&
3712                 git branch A &&
3713                 git branch B &&
3714
3715                 git checkout A &&
3716                 git mv z/ y/ &&
3717                 git mv x/c y/wham &&
3718                 test_tick &&
3719                 git commit -m "A" &&
3720
3721                 git checkout B &&
3722                 git mv x/d z/wham &&
3723                 test_tick &&
3724                 git commit -m "B"
3725         )
3726 '
3727
3728 test_expect_success '11f-check: Avoid deleting not-uptodate with dir rename/rename(2to1)' '
3729         (
3730                 cd 11f &&
3731
3732                 git checkout A^0 &&
3733                 echo important >>y/wham &&
3734
3735                 test_must_fail git merge -s recursive B^0 >out 2>err &&
3736                 test_i18ngrep "CONFLICT (rename/rename)" out &&
3737                 test_i18ngrep "Refusing to lose dirty file at y/wham" out &&
3738
3739                 git ls-files -s >out &&
3740                 test_line_count = 4 out &&
3741                 git ls-files -u >out &&
3742                 test_line_count = 2 out &&
3743                 git ls-files -o >out &&
3744                 test_line_count = 4 out &&
3745
3746                 test_seq 1 10 >expected &&
3747                 echo important >>expected &&
3748                 test_cmp expected y/wham &&
3749
3750                 test_must_fail git rev-parse :1:y/wham &&
3751                 git hash-object >actual \
3752                         y/wham~B^0 y/wham~HEAD &&
3753                 git rev-parse >expect \
3754                         O:x/d      O:x/c &&
3755                 test_cmp expect actual &&
3756
3757                 git rev-parse >actual \
3758                         :0:y/a :0:y/b :2:y/wham :3:y/wham &&
3759                 git rev-parse >expect \
3760                          O:z/a  O:z/b  O:x/c     O:x/d &&
3761                 test_cmp expect actual
3762         )
3763 '
3764
3765 ###########################################################################
3766 # SECTION 12: Everything else
3767 #
3768 # Tests suggested by others.  Tests added after implementation completed
3769 # and submitted.  Grab bag.
3770 ###########################################################################
3771
3772 # Testcase 12a, Moving one directory hierarchy into another
3773 #   (Related to testcase 9a)
3774 #   Commit O: node1/{leaf1,leaf2}, node2/{leaf3,leaf4}
3775 #   Commit A: node1/{leaf1,leaf2,node2/{leaf3,leaf4}}
3776 #   Commit B: node1/{leaf1,leaf2,leaf5}, node2/{leaf3,leaf4,leaf6}
3777 #   Expected: node1/{leaf1,leaf2,leaf5,node2/{leaf3,leaf4,leaf6}}
3778
3779 test_expect_success '12a-setup: Moving one directory hierarchy into another' '
3780         test_create_repo 12a &&
3781         (
3782                 cd 12a &&
3783
3784                 mkdir -p node1 node2 &&
3785                 echo leaf1 >node1/leaf1 &&
3786                 echo leaf2 >node1/leaf2 &&
3787                 echo leaf3 >node2/leaf3 &&
3788                 echo leaf4 >node2/leaf4 &&
3789                 git add node1 node2 &&
3790                 test_tick &&
3791                 git commit -m "O" &&
3792
3793                 git branch O &&
3794                 git branch A &&
3795                 git branch B &&
3796
3797                 git checkout A &&
3798                 git mv node2/ node1/ &&
3799                 test_tick &&
3800                 git commit -m "A" &&
3801
3802                 git checkout B &&
3803                 echo leaf5 >node1/leaf5 &&
3804                 echo leaf6 >node2/leaf6 &&
3805                 git add node1 node2 &&
3806                 test_tick &&
3807                 git commit -m "B"
3808         )
3809 '
3810
3811 test_expect_success '12a-check: Moving one directory hierarchy into another' '
3812         (
3813                 cd 12a &&
3814
3815                 git checkout A^0 &&
3816
3817                 git merge -s recursive B^0 &&
3818
3819                 git ls-files -s >out &&
3820                 test_line_count = 6 out &&
3821
3822                 git rev-parse >actual \
3823                         HEAD:node1/leaf1 HEAD:node1/leaf2 HEAD:node1/leaf5 \
3824                         HEAD:node1/node2/leaf3 \
3825                         HEAD:node1/node2/leaf4 \
3826                         HEAD:node1/node2/leaf6 &&
3827                 git rev-parse >expect \
3828                         O:node1/leaf1    O:node1/leaf2    B:node1/leaf5 \
3829                         O:node2/leaf3 \
3830                         O:node2/leaf4 \
3831                         B:node2/leaf6 &&
3832                 test_cmp expect actual
3833         )
3834 '
3835
3836 # Testcase 12b, Moving two directory hierarchies into each other
3837 #   (Related to testcases 1c and 12c)
3838 #   Commit O: node1/{leaf1, leaf2}, node2/{leaf3, leaf4}
3839 #   Commit A: node1/{leaf1, leaf2, node2/{leaf3, leaf4}}
3840 #   Commit B: node2/{leaf3, leaf4, node1/{leaf1, leaf2}}
3841 #   Expected: node1/node2/node1/{leaf1, leaf2},
3842 #             node2/node1/node2/{leaf3, leaf4}
3843 #   NOTE: Without directory renames, we would expect
3844 #                   node2/node1/{leaf1, leaf2},
3845 #                   node1/node2/{leaf3, leaf4}
3846 #         with directory rename detection, we note that
3847 #             commit A renames node2/ -> node1/node2/
3848 #             commit B renames node1/ -> node2/node1/
3849 #         therefore, applying those directory renames to the initial result
3850 #         (making all four paths experience a transitive renaming), yields
3851 #         the expected result.
3852 #
3853 #         You may ask, is it weird to have two directories rename each other?
3854 #         To which, I can do no more than shrug my shoulders and say that
3855 #         even simple rules give weird results when given weird inputs.
3856
3857 test_expect_success '12b-setup: Moving one directory hierarchy into another' '
3858         test_create_repo 12b &&
3859         (
3860                 cd 12b &&
3861
3862                 mkdir -p node1 node2 &&
3863                 echo leaf1 >node1/leaf1 &&
3864                 echo leaf2 >node1/leaf2 &&
3865                 echo leaf3 >node2/leaf3 &&
3866                 echo leaf4 >node2/leaf4 &&
3867                 git add node1 node2 &&
3868                 test_tick &&
3869                 git commit -m "O" &&
3870
3871                 git branch O &&
3872                 git branch A &&
3873                 git branch B &&
3874
3875                 git checkout A &&
3876                 git mv node2/ node1/ &&
3877                 test_tick &&
3878                 git commit -m "A" &&
3879
3880                 git checkout B &&
3881                 git mv node1/ node2/ &&
3882                 test_tick &&
3883                 git commit -m "B"
3884         )
3885 '
3886
3887 test_expect_success '12b-check: Moving one directory hierarchy into another' '
3888         (
3889                 cd 12b &&
3890
3891                 git checkout A^0 &&
3892
3893                 git merge -s recursive B^0 &&
3894
3895                 git ls-files -s >out &&
3896                 test_line_count = 4 out &&
3897
3898                 git rev-parse >actual \
3899                         HEAD:node1/node2/node1/leaf1 \
3900                         HEAD:node1/node2/node1/leaf2 \
3901                         HEAD:node2/node1/node2/leaf3 \
3902                         HEAD:node2/node1/node2/leaf4 &&
3903                 git rev-parse >expect \
3904                         O:node1/leaf1 \
3905                         O:node1/leaf2 \
3906                         O:node2/leaf3 \
3907                         O:node2/leaf4 &&
3908                 test_cmp expect actual
3909         )
3910 '
3911
3912 # Testcase 12c, Moving two directory hierarchies into each other w/ content merge
3913 #   (Related to testcase 12b)
3914 #   Commit O: node1/{       leaf1_1, leaf2_1}, node2/{leaf3_1, leaf4_1}
3915 #   Commit A: node1/{       leaf1_2, leaf2_2,  node2/{leaf3_2, leaf4_2}}
3916 #   Commit B: node2/{node1/{leaf1_3, leaf2_3},        leaf3_3, leaf4_3}
3917 #   Expected: Content merge conflicts for each of:
3918 #               node1/node2/node1/{leaf1, leaf2},
3919 #               node2/node1/node2/{leaf3, leaf4}
3920 #   NOTE: This is *exactly* like 12c, except that every path is modified on
3921 #         each side of the merge.
3922
3923 test_expect_success '12c-setup: Moving one directory hierarchy into another w/ content merge' '
3924         test_create_repo 12c &&
3925         (
3926                 cd 12c &&
3927
3928                 mkdir -p node1 node2 &&
3929                 printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf1\n" >node1/leaf1 &&
3930                 printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf2\n" >node1/leaf2 &&
3931                 printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf3\n" >node2/leaf3 &&
3932                 printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf4\n" >node2/leaf4 &&
3933                 git add node1 node2 &&
3934                 test_tick &&
3935                 git commit -m "O" &&
3936
3937                 git branch O &&
3938                 git branch A &&
3939                 git branch B &&
3940
3941                 git checkout A &&
3942                 git mv node2/ node1/ &&
3943                 for i in `git ls-files`; do echo side A >>$i; done &&
3944                 git add -u &&
3945                 test_tick &&
3946                 git commit -m "A" &&
3947
3948                 git checkout B &&
3949                 git mv node1/ node2/ &&
3950                 for i in `git ls-files`; do echo side B >>$i; done &&
3951                 git add -u &&
3952                 test_tick &&
3953                 git commit -m "B"
3954         )
3955 '
3956
3957 test_expect_success '12c-check: Moving one directory hierarchy into another w/ content merge' '
3958         (
3959                 cd 12c &&
3960
3961                 git checkout A^0 &&
3962
3963                 test_must_fail git merge -s recursive B^0 &&
3964
3965                 git ls-files -u >out &&
3966                 test_line_count = 12 out &&
3967
3968                 git rev-parse >actual \
3969                         :1:node1/node2/node1/leaf1 \
3970                         :1:node1/node2/node1/leaf2 \
3971                         :1:node2/node1/node2/leaf3 \
3972                         :1:node2/node1/node2/leaf4 \
3973                         :2:node1/node2/node1/leaf1 \
3974                         :2:node1/node2/node1/leaf2 \
3975                         :2:node2/node1/node2/leaf3 \
3976                         :2:node2/node1/node2/leaf4 \
3977                         :3:node1/node2/node1/leaf1 \
3978                         :3:node1/node2/node1/leaf2 \
3979                         :3:node2/node1/node2/leaf3 \
3980                         :3:node2/node1/node2/leaf4 &&
3981                 git rev-parse >expect \
3982                         O:node1/leaf1 \
3983                         O:node1/leaf2 \
3984                         O:node2/leaf3 \
3985                         O:node2/leaf4 \
3986                         A:node1/leaf1 \
3987                         A:node1/leaf2 \
3988                         A:node1/node2/leaf3 \
3989                         A:node1/node2/leaf4 \
3990                         B:node2/node1/leaf1 \
3991                         B:node2/node1/leaf2 \
3992                         B:node2/leaf3 \
3993                         B:node2/leaf4 &&
3994                 test_cmp expect actual
3995         )
3996 '
3997
3998 test_done