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_failure '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_failure '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 #   Commit O: z/{b,c},   x/d
 163 #   Commit A: y/{b,c},   x/d
 164 #   Commit B: z/{b,c,d}
 165 #   Expected: y/{b,c,d}  (because x/d -> z/d -> y/d)
 166
 167 test_expect_success '1c-setup: Transitive renaming' '
 168         test_create_repo 1c &&
 169         (
 170                 cd 1c &&
 171
 172                 mkdir z &&
 173                 echo b >z/b &&
 174                 echo c >z/c &&
 175                 mkdir x &&
 176                 echo d >x/d &&
 177                 git add z x &&
 178                 test_tick &&
 179                 git commit -m "O" &&
 180
 181                 git branch O &&
 182                 git branch A &&
 183                 git branch B &&
 184
 185                 git checkout A &&
 186                 git mv z y &&
 187                 test_tick &&
 188                 git commit -m "A" &&
 189
 190                 git checkout B &&
 191                 git mv x/d z/d &&
 192                 test_tick &&
 193                 git commit -m "B"
 194         )
 195 '
 196
 197 test_expect_failure '1c-check: Transitive renaming' '
 198         (
 199                 cd 1c &&
 200
 201                 git checkout A^0 &&
 202
 203                 git merge -s recursive B^0 &&
 204
 205                 git ls-files -s >out &&
 206                 test_line_count = 3 out &&
 207
 208                 git rev-parse >actual \
 209                         HEAD:y/b HEAD:y/c HEAD:y/d &&
 210                 git rev-parse >expect \
 211                         O:z/b    O:z/c    O:x/d &&
 212                 test_cmp expect actual &&
 213                 test_must_fail git rev-parse HEAD:x/d &&
 214                 test_must_fail git rev-parse HEAD:z/d &&
 215                 test_path_is_missing z/d
 216         )
 217 '
 218
 219 # Testcase 1d, Directory renames (merging two directories into one new one)
 220 #              cause a rename/rename(2to1) conflict
 221 #   (Related to testcases 1c and 7b)
 222 #   Commit O. z/{b,c},        y/{d,e}
 223 #   Commit A. x/{b,c},        y/{d,e,m,wham_1}
 224 #   Commit B. z/{b,c,n,wham_2}, x/{d,e}
 225 #   Expected: x/{b,c,d,e,m,n}, CONFLICT:(y/wham_1 & z/wham_2 -> x/wham)
 226 #   Note: y/m & z/n should definitely move into x.  By the same token, both
 227 #         y/wham_1 & z/wham_2 should too...giving us a conflict.
 228
 229 test_expect_success '1d-setup: Directory renames cause a rename/rename(2to1) conflict' '
 230         test_create_repo 1d &&
 231         (
 232                 cd 1d &&
 233
 234                 mkdir z &&
 235                 echo b >z/b &&
 236                 echo c >z/c &&
 237                 mkdir y &&
 238                 echo d >y/d &&
 239                 echo e >y/e &&
 240                 git add z y &&
 241                 test_tick &&
 242                 git commit -m "O" &&
 243
 244                 git branch O &&
 245                 git branch A &&
 246                 git branch B &&
 247
 248                 git checkout A &&
 249                 git mv z x &&
 250                 echo m >y/m &&
 251                 echo wham1 >y/wham &&
 252                 git add y &&
 253                 test_tick &&
 254                 git commit -m "A" &&
 255
 256                 git checkout B &&
 257                 git mv y x &&
 258                 echo n >z/n &&
 259                 echo wham2 >z/wham &&
 260                 git add z &&
 261                 test_tick &&
 262                 git commit -m "B"
 263         )
 264 '
 265
 266 test_expect_failure '1d-check: Directory renames cause a rename/rename(2to1) conflict' '
 267         (
 268                 cd 1d &&
 269
 270                 git checkout A^0 &&
 271
 272                 test_must_fail git merge -s recursive B^0 >out &&
 273                 test_i18ngrep "CONFLICT (rename/rename)" out &&
 274
 275                 git ls-files -s >out &&
 276                 test_line_count = 8 out &&
 277                 git ls-files -u >out &&
 278                 test_line_count = 2 out &&
 279                 git ls-files -o >out &&
 280                 test_line_count = 3 out &&
 281
 282                 git rev-parse >actual \
 283                         :0:x/b :0:x/c :0:x/d :0:x/e :0:x/m :0:x/n &&
 284                 git rev-parse >expect \
 285                          O:z/b  O:z/c  O:y/d  O:y/e  A:y/m  B:z/n &&
 286                 test_cmp expect actual &&
 287
 288                 test_must_fail git rev-parse :0:x/wham &&
 289                 git rev-parse >actual \
 290                         :2:x/wham :3:x/wham &&
 291                 git rev-parse >expect \
 292                          A:y/wham  B:z/wham &&
 293                 test_cmp expect actual &&
 294
 295                 test_path_is_missing x/wham &&
 296                 test_path_is_file x/wham~HEAD &&
 297                 test_path_is_file x/wham~B^0 &&
 298
 299                 git hash-object >actual \
 300                         x/wham~HEAD x/wham~B^0 &&
 301                 git rev-parse >expect \
 302                         A:y/wham    B:z/wham &&
 303                 test_cmp expect actual
 304         )
 305 '
 306
 307 # Testcase 1e, Renamed directory, with all filenames being renamed too
 308 #   (Related to testcases 9f & 9g)
 309 #   Commit O: z/{oldb,oldc}
 310 #   Commit A: y/{newb,newc}
 311 #   Commit B: z/{oldb,oldc,d}
 312 #   Expected: y/{newb,newc,d}
 313
 314 test_expect_success '1e-setup: Renamed directory, with all files being renamed too' '
 315         test_create_repo 1e &&
 316         (
 317                 cd 1e &&
 318
 319                 mkdir z &&
 320                 echo b >z/oldb &&
 321                 echo c >z/oldc &&
 322                 git add z &&
 323                 test_tick &&
 324                 git commit -m "O" &&
 325
 326                 git branch O &&
 327                 git branch A &&
 328                 git branch B &&
 329
 330                 git checkout A &&
 331                 mkdir y &&
 332                 git mv z/oldb y/newb &&
 333                 git mv z/oldc y/newc &&
 334                 test_tick &&
 335                 git commit -m "A" &&
 336
 337                 git checkout B &&
 338                 echo d >z/d &&
 339                 git add z/d &&
 340                 test_tick &&
 341                 git commit -m "B"
 342         )
 343 '
 344
 345 test_expect_failure '1e-check: Renamed directory, with all files being renamed too' '
 346         (
 347                 cd 1e &&
 348
 349                 git checkout A^0 &&
 350
 351                 git merge -s recursive B^0 &&
 352
 353                 git ls-files -s >out &&
 354                 test_line_count = 3 out &&
 355
 356                 git rev-parse >actual \
 357                         HEAD:y/newb HEAD:y/newc HEAD:y/d &&
 358                 git rev-parse >expect \
 359                         O:z/oldb    O:z/oldc    B:z/d &&
 360                 test_cmp expect actual &&
 361                 test_must_fail git rev-parse HEAD:z/d
 362         )
 363 '
 364
 365 # Testcase 1f, Split a directory into two other directories
 366 #   (Related to testcases 3a, all of section 2, and all of section 4)
 367 #   Commit O: z/{b,c,d,e,f}
 368 #   Commit A: z/{b,c,d,e,f,g}
 369 #   Commit B: y/{b,c}, x/{d,e,f}
 370 #   Expected: y/{b,c}, x/{d,e,f,g}
 371
 372 test_expect_success '1f-setup: Split a directory into two other directories' '
 373         test_create_repo 1f &&
 374         (
 375                 cd 1f &&
 376
 377                 mkdir z &&
 378                 echo b >z/b &&
 379                 echo c >z/c &&
 380                 echo d >z/d &&
 381                 echo e >z/e &&
 382                 echo f >z/f &&
 383                 git add z &&
 384                 test_tick &&
 385                 git commit -m "O" &&
 386
 387                 git branch O &&
 388                 git branch A &&
 389                 git branch B &&
 390
 391                 git checkout A &&
 392                 echo g >z/g &&
 393                 git add z/g &&
 394                 test_tick &&
 395                 git commit -m "A" &&
 396
 397                 git checkout B &&
 398                 mkdir y &&
 399                 mkdir x &&
 400                 git mv z/b y/ &&
 401                 git mv z/c y/ &&
 402                 git mv z/d x/ &&
 403                 git mv z/e x/ &&
 404                 git mv z/f x/ &&
 405                 rmdir z &&
 406                 test_tick &&
 407                 git commit -m "B"
 408         )
 409 '
 410
 411 test_expect_failure '1f-check: Split a directory into two other directories' '
 412         (
 413                 cd 1f &&
 414
 415                 git checkout A^0 &&
 416
 417                 git merge -s recursive B^0 &&
 418
 419                 git ls-files -s >out &&
 420                 test_line_count = 6 out &&
 421
 422                 git rev-parse >actual \
 423                         HEAD:y/b HEAD:y/c HEAD:x/d HEAD:x/e HEAD:x/f HEAD:x/g &&
 424                 git rev-parse >expect \
 425                         O:z/b    O:z/c    O:z/d    O:z/e    O:z/f    A:z/g &&
 426                 test_cmp expect actual &&
 427                 test_path_is_missing z/g &&
 428                 test_must_fail git rev-parse HEAD:z/g
 429         )
 430 '
 431
 432 ###########################################################################
 433 # Rules suggested by testcases in section 1:
 434 #
 435 #   We should still detect the directory rename even if it wasn't just
 436 #   the directory renamed, but the files within it. (see 1b)
 437 #
 438 #   If renames split a directory into two or more others, the directory
 439 #   with the most renames, "wins" (see 1c).  However, see the testcases
 440 #   in section 2, plus testcases 3a and 4a.
 441 ###########################################################################
 442
 443
 444 ###########################################################################
 445 # SECTION 2: Split into multiple directories, with equal number of paths
 446 #
 447 # Explore the splitting-a-directory rules a bit; what happens in the
 448 # edge cases?
 449 #
 450 # Note that there is a closely related case of a directory not being
 451 # split on either side of history, but being renamed differently on
 452 # each side.  See testcase 8e for that.
 453 ###########################################################################
 454
 455 # Testcase 2a, Directory split into two on one side, with equal numbers of paths
 456 #   Commit O: z/{b,c}
 457 #   Commit A: y/b, w/c
 458 #   Commit B: z/{b,c,d}
 459 #   Expected: y/b, w/c, z/d, with warning about z/ -> (y/ vs. w/) conflict
 460 test_expect_success '2a-setup: Directory split into two on one side, with equal numbers of paths' '
 461         test_create_repo 2a &&
 462         (
 463                 cd 2a &&
 464
 465                 mkdir z &&
 466                 echo b >z/b &&
 467                 echo c >z/c &&
 468                 git add z &&
 469                 test_tick &&
 470                 git commit -m "O" &&
 471
 472                 git branch O &&
 473                 git branch A &&
 474                 git branch B &&
 475
 476                 git checkout A &&
 477                 mkdir y &&
 478                 mkdir w &&
 479                 git mv z/b y/ &&
 480                 git mv z/c w/ &&
 481                 test_tick &&
 482                 git commit -m "A" &&
 483
 484                 git checkout B &&
 485                 echo d >z/d &&
 486                 git add z/d &&
 487                 test_tick &&
 488                 git commit -m "B"
 489         )
 490 '
 491
 492 test_expect_failure '2a-check: Directory split into two on one side, with equal numbers of paths' '
 493         (
 494                 cd 2a &&
 495
 496                 git checkout A^0 &&
 497
 498                 test_must_fail git merge -s recursive B^0 >out &&
 499                 test_i18ngrep "CONFLICT.*directory rename split" out &&
 500
 501                 git ls-files -s >out &&
 502                 test_line_count = 3 out &&
 503                 git ls-files -u >out &&
 504                 test_line_count = 0 out &&
 505                 git ls-files -o >out &&
 506                 test_line_count = 1 out &&
 507
 508                 git rev-parse >actual \
 509                         :0:y/b :0:w/c :0:z/d &&
 510                 git rev-parse >expect \
 511                          O:z/b  O:z/c  B:z/d &&
 512                 test_cmp expect actual
 513         )
 514 '
 515
 516 # Testcase 2b, Directory split into two on one side, with equal numbers of paths
 517 #   Commit O: z/{b,c}
 518 #   Commit A: y/b, w/c
 519 #   Commit B: z/{b,c}, x/d
 520 #   Expected: y/b, w/c, x/d; No warning about z/ -> (y/ vs. w/) conflict
 521 test_expect_success '2b-setup: Directory split into two on one side, with equal numbers of paths' '
 522         test_create_repo 2b &&
 523         (
 524                 cd 2b &&
 525
 526                 mkdir z &&
 527                 echo b >z/b &&
 528                 echo c >z/c &&
 529                 git add z &&
 530                 test_tick &&
 531                 git commit -m "O" &&
 532
 533                 git branch O &&
 534                 git branch A &&
 535                 git branch B &&
 536
 537                 git checkout A &&
 538                 mkdir y &&
 539                 mkdir w &&
 540                 git mv z/b y/ &&
 541                 git mv z/c w/ &&
 542                 test_tick &&
 543                 git commit -m "A" &&
 544
 545                 git checkout B &&
 546                 mkdir x &&
 547                 echo d >x/d &&
 548                 git add x/d &&
 549                 test_tick &&
 550                 git commit -m "B"
 551         )
 552 '
 553
 554 test_expect_success '2b-check: Directory split into two on one side, with equal numbers of paths' '
 555         (
 556                 cd 2b &&
 557
 558                 git checkout A^0 &&
 559
 560                 git merge -s recursive B^0 >out &&
 561
 562                 git ls-files -s >out &&
 563                 test_line_count = 3 out &&
 564                 git ls-files -u >out &&
 565                 test_line_count = 0 out &&
 566                 git ls-files -o >out &&
 567                 test_line_count = 1 out &&
 568
 569                 git rev-parse >actual \
 570                         :0:y/b :0:w/c :0:x/d &&
 571                 git rev-parse >expect \
 572                          O:z/b  O:z/c  B:x/d &&
 573                 test_cmp expect actual &&
 574                 test_i18ngrep ! "CONFLICT.*directory rename split" out
 575         )
 576 '
 577
 578 ###########################################################################
 579 # Rules suggested by section 2:
 580 #
 581 #   None; the rule was already covered in section 1.  These testcases are
 582 #   here just to make sure the conflict resolution and necessary warning
 583 #   messages are handled correctly.
 584 ###########################################################################
 585
 586
 587 ###########################################################################
 588 # SECTION 3: Path in question is the source path for some rename already
 589 #
 590 # Combining cases from Section 1 and trying to handle them could lead to
 591 # directory renaming detection being over-applied.  So, this section
 592 # provides some good testcases to check that the implementation doesn't go
 593 # too far.
 594 ###########################################################################
 595
 596 # Testcase 3a, Avoid implicit rename if involved as source on other side
 597 #   (Related to testcases 1c, 1f, and 9h)
 598 #   Commit O: z/{b,c,d}
 599 #   Commit A: z/{b,c,d} (no change)
 600 #   Commit B: y/{b,c}, x/d
 601 #   Expected: y/{b,c}, x/d
 602 test_expect_success '3a-setup: Avoid implicit rename if involved as source on other side' '
 603         test_create_repo 3a &&
 604         (
 605                 cd 3a &&
 606
 607                 mkdir z &&
 608                 echo b >z/b &&
 609                 echo c >z/c &&
 610                 echo d >z/d &&
 611                 git add z &&
 612                 test_tick &&
 613                 git commit -m "O" &&
 614
 615                 git branch O &&
 616                 git branch A &&
 617                 git branch B &&
 618
 619                 git checkout A &&
 620                 test_tick &&
 621                 git commit --allow-empty -m "A" &&
 622
 623                 git checkout B &&
 624                 mkdir y &&
 625                 mkdir x &&
 626                 git mv z/b y/ &&
 627                 git mv z/c y/ &&
 628                 git mv z/d x/ &&
 629                 rmdir z &&
 630                 test_tick &&
 631                 git commit -m "B"
 632         )
 633 '
 634
 635 test_expect_success '3a-check: Avoid implicit rename if involved as source on other side' '
 636         (
 637                 cd 3a &&
 638
 639                 git checkout A^0 &&
 640
 641                 git merge -s recursive B^0 &&
 642
 643                 git ls-files -s >out &&
 644                 test_line_count = 3 out &&
 645
 646                 git rev-parse >actual \
 647                         HEAD:y/b HEAD:y/c HEAD:x/d &&
 648                 git rev-parse >expect \
 649                         O:z/b    O:z/c    O:z/d &&
 650                 test_cmp expect actual
 651         )
 652 '
 653
 654 # Testcase 3b, Avoid implicit rename if involved as source on other side
 655 #   (Related to testcases 5c and 7c, also kind of 1e and 1f)
 656 #   Commit O: z/{b,c,d}
 657 #   Commit A: y/{b,c}, x/d
 658 #   Commit B: z/{b,c}, w/d
 659 #   Expected: y/{b,c}, CONFLICT:(z/d -> x/d vs. w/d)
 660 #   NOTE: We're particularly checking that since z/d is already involved as
 661 #         a source in a file rename on the same side of history, that we don't
 662 #         get it involved in directory rename detection.  If it were, we might
 663 #         end up with CONFLICT:(z/d -> y/d vs. x/d vs. w/d), i.e. a
 664 #         rename/rename/rename(1to3) conflict, which is just weird.
 665 test_expect_success '3b-setup: Avoid implicit rename if involved as source on current side' '
 666         test_create_repo 3b &&
 667         (
 668                 cd 3b &&
 669
 670                 mkdir z &&
 671                 echo b >z/b &&
 672                 echo c >z/c &&
 673                 echo d >z/d &&
 674                 git add z &&
 675                 test_tick &&
 676                 git commit -m "O" &&
 677
 678                 git branch O &&
 679                 git branch A &&
 680                 git branch B &&
 681
 682                 git checkout A &&
 683                 mkdir y &&
 684                 mkdir x &&
 685                 git mv z/b y/ &&
 686                 git mv z/c y/ &&
 687                 git mv z/d x/ &&
 688                 rmdir z &&
 689                 test_tick &&
 690                 git commit -m "A" &&
 691
 692                 git checkout B &&
 693                 mkdir w &&
 694                 git mv z/d w/ &&
 695                 test_tick &&
 696                 git commit -m "B"
 697         )
 698 '
 699
 700 test_expect_success '3b-check: Avoid implicit rename if involved as source on current side' '
 701         (
 702                 cd 3b &&
 703
 704                 git checkout A^0 &&
 705
 706                 test_must_fail git merge -s recursive B^0 >out &&
 707                 test_i18ngrep CONFLICT.*rename/rename.*z/d.*x/d.*w/d out &&
 708                 test_i18ngrep ! CONFLICT.*rename/rename.*y/d out &&
 709
 710                 git ls-files -s >out &&
 711                 test_line_count = 5 out &&
 712                 git ls-files -u >out &&
 713                 test_line_count = 3 out &&
 714                 git ls-files -o >out &&
 715                 test_line_count = 1 out &&
 716
 717                 git rev-parse >actual \
 718                         :0:y/b :0:y/c :1:z/d :2:x/d :3:w/d &&
 719                 git rev-parse >expect \
 720                          O:z/b  O:z/c  O:z/d  O:z/d  O:z/d &&
 721                 test_cmp expect actual &&
 722
 723                 test_path_is_missing z/d &&
 724                 git hash-object >actual \
 725                         x/d   w/d &&
 726                 git rev-parse >expect \
 727                         O:z/d O:z/d &&
 728                 test_cmp expect actual
 729         )
 730 '
 731
 732 ###########################################################################
 733 # Rules suggested by section 3:
 734 #
 735 #   Avoid directory-rename-detection for a path, if that path is the source
 736 #   of a rename on either side of a merge.
 737 ###########################################################################
 738
 739
 740 ###########################################################################
 741 # SECTION 4: Partially renamed directory; still exists on both sides of merge
 742 #
 743 # What if we were to attempt to do directory rename detection when someone
 744 # "mostly" moved a directory but still left some files around, or,
 745 # equivalently, fully renamed a directory in one commmit and then recreated
 746 # that directory in a later commit adding some new files and then tried to
 747 # merge?
 748 #
 749 # It's hard to divine user intent in these cases, because you can make an
 750 # argument that, depending on the intermediate history of the side being
 751 # merged, that some users will want files in that directory to
 752 # automatically be detected and renamed, while users with a different
 753 # intermediate history wouldn't want that rename to happen.
 754 #
 755 # I think that it is best to simply not have directory rename detection
 756 # apply to such cases.  My reasoning for this is four-fold: (1) it's
 757 # easiest for users in general to figure out what happened if we don't
 758 # apply directory rename detection in any such case, (2) it's an easy rule
 759 # to explain ["We don't do directory rename detection if the directory
 760 # still exists on both sides of the merge"], (3) we can get some hairy
 761 # edge/corner cases that would be really confusing and possibly not even
 762 # representable in the index if we were to even try, and [related to 3] (4)
 763 # attempting to resolve this issue of divining user intent by examining
 764 # intermediate history goes against the spirit of three-way merges and is a
 765 # path towards crazy corner cases that are far more complex than what we're
 766 # already dealing with.
 767 #
 768 # Note that the wording of the rule ("We don't do directory rename
 769 # detection if the directory still exists on both sides of the merge.")
 770 # also excludes "renaming" of a directory into a subdirectory of itself
 771 # (e.g. /some/dir/* -> /some/dir/subdir/*).  It may be possible to carve
 772 # out an exception for "renaming"-beneath-itself cases without opening
 773 # weird edge/corner cases for other partial directory renames, but for now
 774 # we are keeping the rule simple.
 775 #
 776 # This section contains a test for a partially-renamed-directory case.
 777 ###########################################################################
 778
 779 # Testcase 4a, Directory split, with original directory still present
 780 #   (Related to testcase 1f)
 781 #   Commit O: z/{b,c,d,e}
 782 #   Commit A: y/{b,c,d}, z/e
 783 #   Commit B: z/{b,c,d,e,f}
 784 #   Expected: y/{b,c,d}, z/{e,f}
 785 #   NOTE: Even though most files from z moved to y, we don't want f to follow.
 786
 787 test_expect_success '4a-setup: Directory split, with original directory still present' '
 788         test_create_repo 4a &&
 789         (
 790                 cd 4a &&
 791
 792                 mkdir z &&
 793                 echo b >z/b &&
 794                 echo c >z/c &&
 795                 echo d >z/d &&
 796                 echo e >z/e &&
 797                 git add z &&
 798                 test_tick &&
 799                 git commit -m "O" &&
 800
 801                 git branch O &&
 802                 git branch A &&
 803                 git branch B &&
 804
 805                 git checkout A &&
 806                 mkdir y &&
 807                 git mv z/b y/ &&
 808                 git mv z/c y/ &&
 809                 git mv z/d y/ &&
 810                 test_tick &&
 811                 git commit -m "A" &&
 812
 813                 git checkout B &&
 814                 echo f >z/f &&
 815                 git add z/f &&
 816                 test_tick &&
 817                 git commit -m "B"
 818         )
 819 '
 820
 821 test_expect_success '4a-check: Directory split, with original directory still present' '
 822         (
 823                 cd 4a &&
 824
 825                 git checkout A^0 &&
 826
 827                 git merge -s recursive B^0 &&
 828
 829                 git ls-files -s >out &&
 830                 test_line_count = 5 out &&
 831                 git ls-files -u >out &&
 832                 test_line_count = 0 out &&
 833                 git ls-files -o >out &&
 834                 test_line_count = 1 out &&
 835
 836                 git rev-parse >actual \
 837                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:z/e HEAD:z/f &&
 838                 git rev-parse >expect \
 839                         O:z/b    O:z/c    O:z/d    O:z/e    B:z/f &&
 840                 test_cmp expect actual
 841         )
 842 '
 843
 844 ###########################################################################
 845 # Rules suggested by section 4:
 846 #
 847 #   Directory-rename-detection should be turned off for any directories (as
 848 #   a source for renames) that exist on both sides of the merge.  (The "as
 849 #   a source for renames" clarification is due to cases like 1c where
 850 #   the target directory exists on both sides and we do want the rename
 851 #   detection.)  But, sadly, see testcase 8b.
 852 ###########################################################################
 853
 854
 855 ###########################################################################
 856 # SECTION 5: Files/directories in the way of subset of to-be-renamed paths
 857 #
 858 # Implicitly renaming files due to a detected directory rename could run
 859 # into problems if there are files or directories in the way of the paths
 860 # we want to rename.  Explore such cases in this section.
 861 ###########################################################################
 862
 863 # Testcase 5a, Merge directories, other side adds files to original and target
 864 #   Commit O: z/{b,c},       y/d
 865 #   Commit A: z/{b,c,e_1,f}, y/{d,e_2}
 866 #   Commit B: y/{b,c,d}
 867 #   Expected: z/e_1, y/{b,c,d,e_2,f} + CONFLICT warning
 868 #   NOTE: While directory rename detection is active here causing z/f to
 869 #         become y/f, we did not apply this for z/e_1 because that would
 870 #         give us an add/add conflict for y/e_1 vs y/e_2.  This problem with
 871 #         this add/add, is that both versions of y/e are from the same side
 872 #         of history, giving us no way to represent this conflict in the
 873 #         index.
 874
 875 test_expect_success '5a-setup: Merge directories, other side adds files to original and target' '
 876         test_create_repo 5a &&
 877         (
 878                 cd 5a &&
 879
 880                 mkdir z &&
 881                 echo b >z/b &&
 882                 echo c >z/c &&
 883                 mkdir y &&
 884                 echo d >y/d &&
 885                 git add z y &&
 886                 test_tick &&
 887                 git commit -m "O" &&
 888
 889                 git branch O &&
 890                 git branch A &&
 891                 git branch B &&
 892
 893                 git checkout A &&
 894                 echo e1 >z/e &&
 895                 echo f >z/f &&
 896                 echo e2 >y/e &&
 897                 git add z/e z/f y/e &&
 898                 test_tick &&
 899                 git commit -m "A" &&
 900
 901                 git checkout B &&
 902                 git mv z/b y/ &&
 903                 git mv z/c y/ &&
 904                 rmdir z &&
 905                 test_tick &&
 906                 git commit -m "B"
 907         )
 908 '
 909
 910 test_expect_failure '5a-check: Merge directories, other side adds files to original and target' '
 911         (
 912                 cd 5a &&
 913
 914                 git checkout A^0 &&
 915
 916                 test_must_fail git merge -s recursive B^0 >out &&
 917                 test_i18ngrep "CONFLICT.*implicit dir rename" out &&
 918
 919                 git ls-files -s >out &&
 920                 test_line_count = 6 out &&
 921                 git ls-files -u >out &&
 922                 test_line_count = 0 out &&
 923                 git ls-files -o >out &&
 924                 test_line_count = 1 out &&
 925
 926                 git rev-parse >actual \
 927                         :0:y/b :0:y/c :0:y/d :0:y/e :0:z/e :0:y/f &&
 928                 git rev-parse >expect \
 929                          O:z/b  O:z/c  O:y/d  A:y/e  A:z/e  A:z/f &&
 930                 test_cmp expect actual
 931         )
 932 '
 933
 934 # Testcase 5b, Rename/delete in order to get add/add/add conflict
 935 #   (Related to testcase 8d; these may appear slightly inconsistent to users;
 936 #    Also related to testcases 7d and 7e)
 937 #   Commit O: z/{b,c,d_1}
 938 #   Commit A: y/{b,c,d_2}
 939 #   Commit B: z/{b,c,d_1,e}, y/d_3
 940 #   Expected: y/{b,c,e}, CONFLICT(add/add: y/d_2 vs. y/d_3)
 941 #   NOTE: If z/d_1 in commit B were to be involved in dir rename detection, as
 942 #         we normaly would since z/ is being renamed to y/, then this would be
 943 #         a rename/delete (z/d_1 -> y/d_1 vs. deleted) AND an add/add/add
 944 #         conflict of y/d_1 vs. y/d_2 vs. y/d_3.  Add/add/add is not
 945 #         representable in the index, so the existence of y/d_3 needs to
 946 #         cause us to bail on directory rename detection for that path, falling
 947 #         back to git behavior without the directory rename detection.
 948
 949 test_expect_success '5b-setup: Rename/delete in order to get add/add/add conflict' '
 950         test_create_repo 5b &&
 951         (
 952                 cd 5b &&
 953
 954                 mkdir z &&
 955                 echo b >z/b &&
 956                 echo c >z/c &&
 957                 echo d1 >z/d &&
 958                 git add z &&
 959                 test_tick &&
 960                 git commit -m "O" &&
 961
 962                 git branch O &&
 963                 git branch A &&
 964                 git branch B &&
 965
 966                 git checkout A &&
 967                 git rm z/d &&
 968                 git mv z y &&
 969                 echo d2 >y/d &&
 970                 git add y/d &&
 971                 test_tick &&
 972                 git commit -m "A" &&
 973
 974                 git checkout B &&
 975                 mkdir y &&
 976                 echo d3 >y/d &&
 977                 echo e >z/e &&
 978                 git add y/d z/e &&
 979                 test_tick &&
 980                 git commit -m "B"
 981         )
 982 '
 983
 984 test_expect_failure '5b-check: Rename/delete in order to get add/add/add conflict' '
 985         (
 986                 cd 5b &&
 987
 988                 git checkout A^0 &&
 989
 990                 test_must_fail git merge -s recursive B^0 >out &&
 991                 test_i18ngrep "CONFLICT (add/add).* y/d" out &&
 992
 993                 git ls-files -s >out &&
 994                 test_line_count = 5 out &&
 995                 git ls-files -u >out &&
 996                 test_line_count = 2 out &&
 997                 git ls-files -o >out &&
 998                 test_line_count = 1 out &&
 999
1000                 git rev-parse >actual \
1001                         :0:y/b :0:y/c :0:y/e :2:y/d :3:y/d &&
1002                 git rev-parse >expect \
1003                          O:z/b  O:z/c  B:z/e  A:y/d  B:y/d &&
1004                 test_cmp expect actual &&
1005
1006                 test_must_fail git rev-parse :1:y/d &&
1007                 test_path_is_file y/d
1008         )
1009 '
1010
1011 # Testcase 5c, Transitive rename would cause rename/rename/rename/add/add/add
1012 #   (Directory rename detection would result in transitive rename vs.
1013 #    rename/rename(1to2) and turn it into a rename/rename(1to3).  Further,
1014 #    rename paths conflict with separate adds on the other side)
1015 #   (Related to testcases 3b and 7c)
1016 #   Commit O: z/{b,c}, x/d_1
1017 #   Commit A: y/{b,c,d_2}, w/d_1
1018 #   Commit B: z/{b,c,d_1,e}, w/d_3, y/d_4
1019 #   Expected: A mess, but only a rename/rename(1to2)/add/add mess.  Use the
1020 #             presence of y/d_4 in B to avoid doing transitive rename of
1021 #             x/d_1 -> z/d_1 -> y/d_1, so that the only paths we have at
1022 #             y/d are y/d_2 and y/d_4.  We still do the move from z/e to y/e,
1023 #             though, because it doesn't have anything in the way.
1024
1025 test_expect_success '5c-setup: Transitive rename would cause rename/rename/rename/add/add/add' '
1026         test_create_repo 5c &&
1027         (
1028                 cd 5c &&
1029
1030                 mkdir z &&
1031                 echo b >z/b &&
1032                 echo c >z/c &&
1033                 mkdir x &&
1034                 echo d1 >x/d &&
1035                 git add z x &&
1036                 test_tick &&
1037                 git commit -m "O" &&
1038
1039                 git branch O &&
1040                 git branch A &&
1041                 git branch B &&
1042
1043                 git checkout A &&
1044                 git mv z y &&
1045                 echo d2 >y/d &&
1046                 git add y/d &&
1047                 git mv x w &&
1048                 test_tick &&
1049                 git commit -m "A" &&
1050
1051                 git checkout B &&
1052                 git mv x/d z/ &&
1053                 mkdir w &&
1054                 mkdir y &&
1055                 echo d3 >w/d &&
1056                 echo d4 >y/d &&
1057                 echo e >z/e &&
1058                 git add w/ y/ z/e &&
1059                 test_tick &&
1060                 git commit -m "B"
1061         )
1062 '
1063
1064 test_expect_failure '5c-check: Transitive rename would cause rename/rename/rename/add/add/add' '
1065         (
1066                 cd 5c &&
1067
1068                 git checkout A^0 &&
1069
1070                 test_must_fail git merge -s recursive B^0 >out &&
1071                 test_i18ngrep "CONFLICT (rename/rename).*x/d.*w/d.*z/d" out &&
1072                 test_i18ngrep "CONFLICT (add/add).* y/d" out &&
1073
1074                 git ls-files -s >out &&
1075                 test_line_count = 9 out &&
1076                 git ls-files -u >out &&
1077                 test_line_count = 6 out &&
1078                 git ls-files -o >out &&
1079                 test_line_count = 3 out &&
1080
1081                 git rev-parse >actual \
1082                         :0:y/b :0:y/c :0:y/e &&
1083                 git rev-parse >expect \
1084                          O:z/b  O:z/c  B:z/e &&
1085                 test_cmp expect actual &&
1086
1087                 test_must_fail git rev-parse :1:y/d &&
1088                 git rev-parse >actual \
1089                         :2:w/d :3:w/d :1:x/d :2:y/d :3:y/d :3:z/d &&
1090                 git rev-parse >expect \
1091                          O:x/d  B:w/d  O:x/d  A:y/d  B:y/d  O:x/d &&
1092                 test_cmp expect actual &&
1093
1094                 git hash-object >actual \
1095                         w/d~HEAD w/d~B^0 z/d &&
1096                 git rev-parse >expect \
1097                         O:x/d    B:w/d   O:x/d &&
1098                 test_cmp expect actual &&
1099                 test_path_is_missing x/d &&
1100                 test_path_is_file y/d &&
1101                 grep -q "<<<<" y/d  # conflict markers should be present
1102         )
1103 '
1104
1105 # Testcase 5d, Directory/file/file conflict due to directory rename
1106 #   Commit O: z/{b,c}
1107 #   Commit A: y/{b,c,d_1}
1108 #   Commit B: z/{b,c,d_2,f}, y/d/e
1109 #   Expected: y/{b,c,d/e,f}, z/d_2, CONFLICT(file/directory), y/d_1~HEAD
1110 #   Note: The fact that y/d/ exists in B makes us bail on directory rename
1111 #         detection for z/d_2, but that doesn't prevent us from applying the
1112 #         directory rename detection for z/f -> y/f.
1113
1114 test_expect_success '5d-setup: Directory/file/file conflict due to directory rename' '
1115         test_create_repo 5d &&
1116         (
1117                 cd 5d &&
1118
1119                 mkdir z &&
1120                 echo b >z/b &&
1121                 echo c >z/c &&
1122                 git add z &&
1123                 test_tick &&
1124                 git commit -m "O" &&
1125
1126                 git branch O &&
1127                 git branch A &&
1128                 git branch B &&
1129
1130                 git checkout A &&
1131                 git mv z y &&
1132                 echo d1 >y/d &&
1133                 git add y/d &&
1134                 test_tick &&
1135                 git commit -m "A" &&
1136
1137                 git checkout B &&
1138                 mkdir -p y/d &&
1139                 echo e >y/d/e &&
1140                 echo d2 >z/d &&
1141                 echo f >z/f &&
1142                 git add y/d/e z/d z/f &&
1143                 test_tick &&
1144                 git commit -m "B"
1145         )
1146 '
1147
1148 test_expect_failure '5d-check: Directory/file/file conflict due to directory rename' '
1149         (
1150                 cd 5d &&
1151
1152                 git checkout A^0 &&
1153
1154                 test_must_fail git merge -s recursive B^0 >out &&
1155                 test_i18ngrep "CONFLICT (file/directory).*y/d" out &&
1156
1157                 git ls-files -s >out &&
1158                 test_line_count = 6 out &&
1159                 git ls-files -u >out &&
1160                 test_line_count = 1 out &&
1161                 git ls-files -o >out &&
1162                 test_line_count = 2 out &&
1163
1164                 git rev-parse >actual \
1165                         :0:y/b :0:y/c :0:z/d :0:y/f :2:y/d :0:y/d/e &&
1166                 git rev-parse >expect \
1167                          O:z/b  O:z/c  B:z/d  B:z/f  A:y/d  B:y/d/e &&
1168                 test_cmp expect actual &&
1169
1170                 git hash-object y/d~HEAD >actual &&
1171                 git rev-parse A:y/d >expect &&
1172                 test_cmp expect actual
1173         )
1174 '
1175
1176 ###########################################################################
1177 # Rules suggested by section 5:
1178 #
1179 #   If a subset of to-be-renamed files have a file or directory in the way,
1180 #   "turn off" the directory rename for those specific sub-paths, falling
1181 #   back to old handling.  But, sadly, see testcases 8a and 8b.
1182 ###########################################################################
1183
1184
1185 ###########################################################################
1186 # SECTION 6: Same side of the merge was the one that did the rename
1187 #
1188 # It may sound obvious that you only want to apply implicit directory
1189 # renames to directories if the _other_ side of history did the renaming.
1190 # If you did make an implementation that didn't explicitly enforce this
1191 # rule, the majority of cases that would fall under this section would
1192 # also be solved by following the rules from the above sections.  But
1193 # there are still a few that stick out, so this section covers them just
1194 # to make sure we also get them right.
1195 ###########################################################################
1196
1197 # Testcase 6a, Tricky rename/delete
1198 #   Commit O: z/{b,c,d}
1199 #   Commit A: z/b
1200 #   Commit B: y/{b,c}, z/d
1201 #   Expected: y/b, CONFLICT(rename/delete, z/c -> y/c vs. NULL)
1202 #   Note: We're just checking here that the rename of z/b and z/c to put
1203 #         them under y/ doesn't accidentally catch z/d and make it look like
1204 #         it is also involved in a rename/delete conflict.
1205
1206 test_expect_success '6a-setup: Tricky rename/delete' '
1207         test_create_repo 6a &&
1208         (
1209                 cd 6a &&
1210
1211                 mkdir z &&
1212                 echo b >z/b &&
1213                 echo c >z/c &&
1214                 echo d >z/d &&
1215                 git add z &&
1216                 test_tick &&
1217                 git commit -m "O" &&
1218
1219                 git branch O &&
1220                 git branch A &&
1221                 git branch B &&
1222
1223                 git checkout A &&
1224                 git rm z/c &&
1225                 git rm z/d &&
1226                 test_tick &&
1227                 git commit -m "A" &&
1228
1229                 git checkout B &&
1230                 mkdir y &&
1231                 git mv z/b y/ &&
1232                 git mv z/c y/ &&
1233                 test_tick &&
1234                 git commit -m "B"
1235         )
1236 '
1237
1238 test_expect_success '6a-check: Tricky rename/delete' '
1239         (
1240                 cd 6a &&
1241
1242                 git checkout A^0 &&
1243
1244                 test_must_fail git merge -s recursive B^0 >out &&
1245                 test_i18ngrep "CONFLICT (rename/delete).*z/c.*y/c" out &&
1246
1247                 git ls-files -s >out &&
1248                 test_line_count = 2 out &&
1249                 git ls-files -u >out &&
1250                 test_line_count = 1 out &&
1251                 git ls-files -o >out &&
1252                 test_line_count = 1 out &&
1253
1254                 git rev-parse >actual \
1255                         :0:y/b :3:y/c &&
1256                 git rev-parse >expect \
1257                          O:z/b  O:z/c &&
1258                 test_cmp expect actual
1259         )
1260 '
1261
1262 # Testcase 6b, Same rename done on both sides
1263 #   (Related to testcases 6c and 8e)
1264 #   Commit O: z/{b,c}
1265 #   Commit A: y/{b,c}
1266 #   Commit B: y/{b,c}, z/d
1267 #   Expected: y/{b,c}, z/d
1268 #   Note: If we did directory rename detection here, we'd move z/d into y/,
1269 #         but B did that rename and still decided to put the file into z/,
1270 #         so we probably shouldn't apply directory rename detection for it.
1271
1272 test_expect_success '6b-setup: Same rename done on both sides' '
1273         test_create_repo 6b &&
1274         (
1275                 cd 6b &&
1276
1277                 mkdir z &&
1278                 echo b >z/b &&
1279                 echo c >z/c &&
1280                 git add z &&
1281                 test_tick &&
1282                 git commit -m "O" &&
1283
1284                 git branch O &&
1285                 git branch A &&
1286                 git branch B &&
1287
1288                 git checkout A &&
1289                 git mv z y &&
1290                 test_tick &&
1291                 git commit -m "A" &&
1292
1293                 git checkout B &&
1294                 git mv z y &&
1295                 mkdir z &&
1296                 echo d >z/d &&
1297                 git add z/d &&
1298                 test_tick &&
1299                 git commit -m "B"
1300         )
1301 '
1302
1303 test_expect_success '6b-check: Same rename done on both sides' '
1304         (
1305                 cd 6b &&
1306
1307                 git checkout A^0 &&
1308
1309                 git merge -s recursive B^0 &&
1310
1311                 git ls-files -s >out &&
1312                 test_line_count = 3 out &&
1313                 git ls-files -u >out &&
1314                 test_line_count = 0 out &&
1315                 git ls-files -o >out &&
1316                 test_line_count = 1 out &&
1317
1318                 git rev-parse >actual \
1319                         HEAD:y/b HEAD:y/c HEAD:z/d &&
1320                 git rev-parse >expect \
1321                         O:z/b    O:z/c    B:z/d &&
1322                 test_cmp expect actual
1323         )
1324 '
1325
1326 # Testcase 6c, Rename only done on same side
1327 #   (Related to testcases 6b and 8e)
1328 #   Commit O: z/{b,c}
1329 #   Commit A: z/{b,c} (no change)
1330 #   Commit B: y/{b,c}, z/d
1331 #   Expected: y/{b,c}, z/d
1332 #   NOTE: Seems obvious, but just checking that the implementation doesn't
1333 #         "accidentally detect a rename" and give us y/{b,c,d}.
1334
1335 test_expect_success '6c-setup: Rename only done on same side' '
1336         test_create_repo 6c &&
1337         (
1338                 cd 6c &&
1339
1340                 mkdir z &&
1341                 echo b >z/b &&
1342                 echo c >z/c &&
1343                 git add z &&
1344                 test_tick &&
1345                 git commit -m "O" &&
1346
1347                 git branch O &&
1348                 git branch A &&
1349                 git branch B &&
1350
1351                 git checkout A &&
1352                 test_tick &&
1353                 git commit --allow-empty -m "A" &&
1354
1355                 git checkout B &&
1356                 git mv z y &&
1357                 mkdir z &&
1358                 echo d >z/d &&
1359                 git add z/d &&
1360                 test_tick &&
1361                 git commit -m "B"
1362         )
1363 '
1364
1365 test_expect_success '6c-check: Rename only done on same side' '
1366         (
1367                 cd 6c &&
1368
1369                 git checkout A^0 &&
1370
1371                 git merge -s recursive B^0 &&
1372
1373                 git ls-files -s >out &&
1374                 test_line_count = 3 out &&
1375                 git ls-files -u >out &&
1376                 test_line_count = 0 out &&
1377                 git ls-files -o >out &&
1378                 test_line_count = 1 out &&
1379
1380                 git rev-parse >actual \
1381                         HEAD:y/b HEAD:y/c HEAD:z/d &&
1382                 git rev-parse >expect \
1383                         O:z/b    O:z/c    B:z/d &&
1384                 test_cmp expect actual
1385         )
1386 '
1387
1388 # Testcase 6d, We don't always want transitive renaming
1389 #   (Related to testcase 1c)
1390 #   Commit O: z/{b,c}, x/d
1391 #   Commit A: z/{b,c}, x/d (no change)
1392 #   Commit B: y/{b,c}, z/d
1393 #   Expected: y/{b,c}, z/d
1394 #   NOTE: Again, this seems obvious but just checking that the implementation
1395 #         doesn't "accidentally detect a rename" and give us y/{b,c,d}.
1396
1397 test_expect_success '6d-setup: We do not always want transitive renaming' '
1398         test_create_repo 6d &&
1399         (
1400                 cd 6d &&
1401
1402                 mkdir z &&
1403                 echo b >z/b &&
1404                 echo c >z/c &&
1405                 mkdir x &&
1406                 echo d >x/d &&
1407                 git add z x &&
1408                 test_tick &&
1409                 git commit -m "O" &&
1410
1411                 git branch O &&
1412                 git branch A &&
1413                 git branch B &&
1414
1415                 git checkout A &&
1416                 test_tick &&
1417                 git commit --allow-empty -m "A" &&
1418
1419                 git checkout B &&
1420                 git mv z y &&
1421                 git mv x z &&
1422                 test_tick &&
1423                 git commit -m "B"
1424         )
1425 '
1426
1427 test_expect_success '6d-check: We do not always want transitive renaming' '
1428         (
1429                 cd 6d &&
1430
1431                 git checkout A^0 &&
1432
1433                 git merge -s recursive B^0 &&
1434
1435                 git ls-files -s >out &&
1436                 test_line_count = 3 out &&
1437                 git ls-files -u >out &&
1438                 test_line_count = 0 out &&
1439                 git ls-files -o >out &&
1440                 test_line_count = 1 out &&
1441
1442                 git rev-parse >actual \
1443                         HEAD:y/b HEAD:y/c HEAD:z/d &&
1444                 git rev-parse >expect \
1445                         O:z/b    O:z/c    O:x/d &&
1446                 test_cmp expect actual
1447         )
1448 '
1449
1450 # Testcase 6e, Add/add from one-side
1451 #   Commit O: z/{b,c}
1452 #   Commit A: z/{b,c} (no change)
1453 #   Commit B: y/{b,c,d_1}, z/d_2
1454 #   Expected: y/{b,c,d_1}, z/d_2
1455 #   NOTE: Again, this seems obvious but just checking that the implementation
1456 #         doesn't "accidentally detect a rename" and give us y/{b,c} +
1457 #         add/add conflict on y/d_1 vs y/d_2.
1458
1459 test_expect_success '6e-setup: Add/add from one side' '
1460         test_create_repo 6e &&
1461         (
1462                 cd 6e &&
1463
1464                 mkdir z &&
1465                 echo b >z/b &&
1466                 echo c >z/c &&
1467                 git add z &&
1468                 test_tick &&
1469                 git commit -m "O" &&
1470
1471                 git branch O &&
1472                 git branch A &&
1473                 git branch B &&
1474
1475                 git checkout A &&
1476                 test_tick &&
1477                 git commit --allow-empty -m "A" &&
1478
1479                 git checkout B &&
1480                 git mv z y &&
1481                 echo d1 > y/d &&
1482                 mkdir z &&
1483                 echo d2 > z/d &&
1484                 git add y/d z/d &&
1485                 test_tick &&
1486                 git commit -m "B"
1487         )
1488 '
1489
1490 test_expect_success '6e-check: Add/add from one side' '
1491         (
1492                 cd 6e &&
1493
1494                 git checkout A^0 &&
1495
1496                 git merge -s recursive B^0 &&
1497
1498                 git ls-files -s >out &&
1499                 test_line_count = 4 out &&
1500                 git ls-files -u >out &&
1501                 test_line_count = 0 out &&
1502                 git ls-files -o >out &&
1503                 test_line_count = 1 out &&
1504
1505                 git rev-parse >actual \
1506                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:z/d &&
1507                 git rev-parse >expect \
1508                         O:z/b    O:z/c    B:y/d    B:z/d &&
1509                 test_cmp expect actual
1510         )
1511 '
1512
1513 ###########################################################################
1514 # Rules suggested by section 6:
1515 #
1516 #   Only apply implicit directory renames to directories if the other
1517 #   side of history is the one doing the renaming.
1518 ###########################################################################
1519
1520
1521 ###########################################################################
1522 # SECTION 7: More involved Edge/Corner cases
1523 #
1524 # The ruleset we have generated in the above sections seems to provide
1525 # well-defined merges.  But can we find edge/corner cases that either (a)
1526 # are harder for users to understand, or (b) have a resolution that is
1527 # non-intuitive or suboptimal?
1528 #
1529 # The testcases in this section dive into cases that I've tried to craft in
1530 # a way to find some that might be surprising to users or difficult for
1531 # them to understand (the next section will look at non-intuitive or
1532 # suboptimal merge results).  Some of the testcases are similar to ones
1533 # from past sections, but have been simplified to try to highlight error
1534 # messages using a "modified" path (due to the directory rename).  Are
1535 # users okay with these?
1536 #
1537 # In my opinion, testcases that are difficult to understand from this
1538 # section is due to difficulty in the testcase rather than the directory
1539 # renaming (similar to how t6042 and t6036 have difficult resolutions due
1540 # to the problem setup itself being complex).  And I don't think the
1541 # error messages are a problem.
1542 #
1543 # On the other hand, the testcases in section 8 worry me slightly more...
1544 ###########################################################################
1545
1546 # Testcase 7a, rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file
1547 #   Commit O: z/{b,c}
1548 #   Commit A: y/{b,c}
1549 #   Commit B: w/b, x/c, z/d
1550 #   Expected: y/d, CONFLICT(rename/rename for both z/b and z/c)
1551 #   NOTE: There's a rename of z/ here, y/ has more renames, so z/d -> y/d.
1552
1553 test_expect_success '7a-setup: rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file' '
1554         test_create_repo 7a &&
1555         (
1556                 cd 7a &&
1557
1558                 mkdir z &&
1559                 echo b >z/b &&
1560                 echo c >z/c &&
1561                 git add z &&
1562                 test_tick &&
1563                 git commit -m "O" &&
1564
1565                 git branch O &&
1566                 git branch A &&
1567                 git branch B &&
1568
1569                 git checkout A &&
1570                 git mv z y &&
1571                 test_tick &&
1572                 git commit -m "A" &&
1573
1574                 git checkout B &&
1575                 mkdir w &&
1576                 mkdir x &&
1577                 git mv z/b w/ &&
1578                 git mv z/c x/ &&
1579                 echo d > z/d &&
1580                 git add z/d &&
1581                 test_tick &&
1582                 git commit -m "B"
1583         )
1584 '
1585
1586 test_expect_failure '7a-check: rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file' '
1587         (
1588                 cd 7a &&
1589
1590                 git checkout A^0 &&
1591
1592                 test_must_fail git merge -s recursive B^0 >out &&
1593                 test_i18ngrep "CONFLICT (rename/rename).*z/b.*y/b.*w/b" out &&
1594                 test_i18ngrep "CONFLICT (rename/rename).*z/c.*y/c.*x/c" out &&
1595
1596                 git ls-files -s >out &&
1597                 test_line_count = 7 out &&
1598                 git ls-files -u >out &&
1599                 test_line_count = 6 out &&
1600                 git ls-files -o >out &&
1601                 test_line_count = 1 out &&
1602
1603                 git rev-parse >actual \
1604                         :1:z/b :2:y/b :3:w/b :1:z/c :2:y/c :3:x/c :0:y/d &&
1605                 git rev-parse >expect \
1606                          O:z/b  O:z/b  O:z/b  O:z/c  O:z/c  O:z/c  B:z/d &&
1607                 test_cmp expect actual &&
1608
1609                 git hash-object >actual \
1610                         y/b   w/b   y/c   x/c &&
1611                 git rev-parse >expect \
1612                         O:z/b O:z/b O:z/c O:z/c &&
1613                 test_cmp expect actual
1614         )
1615 '
1616
1617 # Testcase 7b, rename/rename(2to1), but only due to transitive rename
1618 #   (Related to testcase 1d)
1619 #   Commit O: z/{b,c},     x/d_1, w/d_2
1620 #   Commit A: y/{b,c,d_2}, x/d_1
1621 #   Commit B: z/{b,c,d_1},        w/d_2
1622 #   Expected: y/{b,c}, CONFLICT(rename/rename(2to1): x/d_1, w/d_2 -> y_d)
1623
1624 test_expect_success '7b-setup: rename/rename(2to1), but only due to transitive rename' '
1625         test_create_repo 7b &&
1626         (
1627                 cd 7b &&
1628
1629                 mkdir z &&
1630                 mkdir x &&
1631                 mkdir w &&
1632                 echo b >z/b &&
1633                 echo c >z/c &&
1634                 echo d1 > x/d &&
1635                 echo d2 > w/d &&
1636                 git add z x w &&
1637                 test_tick &&
1638                 git commit -m "O" &&
1639
1640                 git branch O &&
1641                 git branch A &&
1642                 git branch B &&
1643
1644                 git checkout A &&
1645                 git mv z y &&
1646                 git mv w/d y/ &&
1647                 test_tick &&
1648                 git commit -m "A" &&
1649
1650                 git checkout B &&
1651                 git mv x/d z/ &&
1652                 rmdir x &&
1653                 test_tick &&
1654                 git commit -m "B"
1655         )
1656 '
1657
1658 test_expect_failure '7b-check: rename/rename(2to1), but only due to transitive rename' '
1659         (
1660                 cd 7b &&
1661
1662                 git checkout A^0 &&
1663
1664                 test_must_fail git merge -s recursive B^0 >out &&
1665                 test_i18ngrep "CONFLICT (rename/rename)" out &&
1666
1667                 git ls-files -s >out &&
1668                 test_line_count = 4 out &&
1669                 git ls-files -u >out &&
1670                 test_line_count = 2 out &&
1671                 git ls-files -o >out &&
1672                 test_line_count = 3 out &&
1673
1674                 git rev-parse >actual \
1675                         :0:y/b :0:y/c :2:y/d :3:y/d &&
1676                 git rev-parse >expect \
1677                          O:z/b  O:z/c  O:w/d  O:x/d &&
1678                 test_cmp expect actual &&
1679
1680                 test_path_is_missing y/d &&
1681                 test_path_is_file y/d~HEAD &&
1682                 test_path_is_file y/d~B^0 &&
1683
1684                 git hash-object >actual \
1685                         y/d~HEAD y/d~B^0 &&
1686                 git rev-parse >expect \
1687                         O:w/d    O:x/d &&
1688                 test_cmp expect actual
1689         )
1690 '
1691
1692 # Testcase 7c, rename/rename(1to...2or3); transitive rename may add complexity
1693 #   (Related to testcases 3b and 5c)
1694 #   Commit O: z/{b,c}, x/d
1695 #   Commit A: y/{b,c}, w/d
1696 #   Commit B: z/{b,c,d}
1697 #   Expected: y/{b,c}, CONFLICT(x/d -> w/d vs. y/d)
1698 #   NOTE: z/ was renamed to y/ so we do want to report
1699 #         neither CONFLICT(x/d -> w/d vs. z/d)
1700 #         nor CONFLiCT x/d -> w/d vs. y/d vs. z/d)
1701
1702 test_expect_success '7c-setup: rename/rename(1to...2or3); transitive rename may add complexity' '
1703         test_create_repo 7c &&
1704         (
1705                 cd 7c &&
1706
1707                 mkdir z &&
1708                 echo b >z/b &&
1709                 echo c >z/c &&
1710                 mkdir x &&
1711                 echo d >x/d &&
1712                 git add z x &&
1713                 test_tick &&
1714                 git commit -m "O" &&
1715
1716                 git branch O &&
1717                 git branch A &&
1718                 git branch B &&
1719
1720                 git checkout A &&
1721                 git mv z y &&
1722                 git mv x w &&
1723                 test_tick &&
1724                 git commit -m "A" &&
1725
1726                 git checkout B &&
1727                 git mv x/d z/ &&
1728                 rmdir x &&
1729                 test_tick &&
1730                 git commit -m "B"
1731         )
1732 '
1733
1734 test_expect_failure '7c-check: rename/rename(1to...2or3); transitive rename may add complexity' '
1735         (
1736                 cd 7c &&
1737
1738                 git checkout A^0 &&
1739
1740                 test_must_fail git merge -s recursive B^0 >out &&
1741                 test_i18ngrep "CONFLICT (rename/rename).*x/d.*w/d.*y/d" out &&
1742
1743                 git ls-files -s >out &&
1744                 test_line_count = 5 out &&
1745                 git ls-files -u >out &&
1746                 test_line_count = 3 out &&
1747                 git ls-files -o >out &&
1748                 test_line_count = 1 out &&
1749
1750                 git rev-parse >actual \
1751                         :0:y/b :0:y/c :1:x/d :2:w/d :3:y/d &&
1752                 git rev-parse >expect \
1753                          O:z/b  O:z/c  O:x/d  O:x/d  O:x/d &&
1754                 test_cmp expect actual
1755         )
1756 '
1757
1758 # Testcase 7d, transitive rename involved in rename/delete; how is it reported?
1759 #   (Related somewhat to testcases 5b and 8d)
1760 #   Commit O: z/{b,c}, x/d
1761 #   Commit A: y/{b,c}
1762 #   Commit B: z/{b,c,d}
1763 #   Expected: y/{b,c}, CONFLICT(delete x/d vs rename to y/d)
1764 #   NOTE: z->y so NOT CONFLICT(delete x/d vs rename to z/d)
1765
1766 test_expect_success '7d-setup: transitive rename involved in rename/delete; how is it reported?' '
1767         test_create_repo 7d &&
1768         (
1769                 cd 7d &&
1770
1771                 mkdir z &&
1772                 echo b >z/b &&
1773                 echo c >z/c &&
1774                 mkdir x &&
1775                 echo d >x/d &&
1776                 git add z x &&
1777                 test_tick &&
1778                 git commit -m "O" &&
1779
1780                 git branch O &&
1781                 git branch A &&
1782                 git branch B &&
1783
1784                 git checkout A &&
1785                 git mv z y &&
1786                 git rm -rf x &&
1787                 test_tick &&
1788                 git commit -m "A" &&
1789
1790                 git checkout B &&
1791                 git mv x/d z/ &&
1792                 rmdir x &&
1793                 test_tick &&
1794                 git commit -m "B"
1795         )
1796 '
1797
1798 test_expect_failure '7d-check: transitive rename involved in rename/delete; how is it reported?' '
1799         (
1800                 cd 7d &&
1801
1802                 git checkout A^0 &&
1803
1804                 test_must_fail git merge -s recursive B^0 >out &&
1805                 test_i18ngrep "CONFLICT (rename/delete).*x/d.*y/d" out &&
1806
1807                 git ls-files -s >out &&
1808                 test_line_count = 3 out &&
1809                 git ls-files -u >out &&
1810                 test_line_count = 1 out &&
1811                 git ls-files -o >out &&
1812                 test_line_count = 1 out &&
1813
1814                 git rev-parse >actual \
1815                         :0:y/b :0:y/c :3:y/d &&
1816                 git rev-parse >expect \
1817                          O:z/b  O:z/c  O:x/d &&
1818                 test_cmp expect actual
1819         )
1820 '
1821
1822 # Testcase 7e, transitive rename in rename/delete AND dirs in the way
1823 #   (Very similar to 'both rename source and destination involved in D/F conflict' from t6022-merge-rename.sh)
1824 #   (Also related to testcases 9c and 9d)
1825 #   Commit O: z/{b,c},     x/d_1
1826 #   Commit A: y/{b,c,d/g}, x/d/f
1827 #   Commit B: z/{b,c,d_1}
1828 #   Expected: rename/delete(x/d_1->y/d_1 vs. None) + D/F conflict on y/d
1829 #             y/{b,c,d/g}, y/d_1~B^0, x/d/f
1830
1831 #   NOTE: The main path of interest here is d_1 and where it ends up, but
1832 #         this is actually a case that has two potential directory renames
1833 #         involved and D/F conflict(s), so it makes sense to walk through
1834 #         each step.
1835 #
1836 #         Commit A renames z/ -> y/.  Thus everything that B adds to z/
1837 #         should be instead moved to y/.  This gives us the D/F conflict on
1838 #         y/d because x/d_1 -> z/d_1 -> y/d_1 conflicts with y/d/g.
1839 #
1840 #         Further, commit B renames x/ -> z/, thus everything A adds to x/
1841 #         should instead be moved to z/...BUT we removed z/ and renamed it
1842 #         to y/, so maybe everything should move not from x/ to z/, but
1843 #         from x/ to z/ to y/.  Doing so might make sense from the logic so
1844 #         far, but note that commit A had both an x/ and a y/; it did the
1845 #         renaming of z/ to y/ and created x/d/f and it clearly made these
1846 #         things separate, so it doesn't make much sense to push these
1847 #         together.  Doing so is what I'd call a doubly transitive rename;
1848 #         see testcases 9c and 9d for further discussion of this issue and
1849 #         how it's resolved.
1850
1851 test_expect_success '7e-setup: transitive rename in rename/delete AND dirs in the way' '
1852         test_create_repo 7e &&
1853         (
1854                 cd 7e &&
1855
1856                 mkdir z &&
1857                 echo b >z/b &&
1858                 echo c >z/c &&
1859                 mkdir x &&
1860                 echo d1 >x/d &&
1861                 git add z x &&
1862                 test_tick &&
1863                 git commit -m "O" &&
1864
1865                 git branch O &&
1866                 git branch A &&
1867                 git branch B &&
1868
1869                 git checkout A &&
1870                 git mv z y &&
1871                 git rm x/d &&
1872                 mkdir -p x/d &&
1873                 mkdir -p y/d &&
1874                 echo f >x/d/f &&
1875                 echo g >y/d/g &&
1876                 git add x/d/f y/d/g &&
1877                 test_tick &&
1878                 git commit -m "A" &&
1879
1880                 git checkout B &&
1881                 git mv x/d z/ &&
1882                 rmdir x &&
1883                 test_tick &&
1884                 git commit -m "B"
1885         )
1886 '
1887
1888 test_expect_failure '7e-check: transitive rename in rename/delete AND dirs in the way' '
1889         (
1890                 cd 7e &&
1891
1892                 git checkout A^0 &&
1893
1894                 test_must_fail git merge -s recursive B^0 >out &&
1895                 test_i18ngrep "CONFLICT (rename/delete).*x/d.*y/d" out &&
1896
1897                 git ls-files -s >out &&
1898                 test_line_count = 5 out &&
1899                 git ls-files -u >out &&
1900                 test_line_count = 1 out &&
1901                 git ls-files -o >out &&
1902                 test_line_count = 2 out &&
1903
1904                 git rev-parse >actual \
1905                         :0:x/d/f :0:y/d/g :0:y/b :0:y/c :3:y/d &&
1906                 git rev-parse >expect \
1907                          A:x/d/f  A:y/d/g  O:z/b  O:z/c  O:x/d &&
1908                 test_cmp expect actual &&
1909
1910                 git hash-object y/d~B^0 >actual &&
1911                 git rev-parse O:x/d >expect &&
1912                 test_cmp expect actual
1913         )
1914 '
1915
1916 ###########################################################################
1917 # SECTION 8: Suboptimal merges
1918 #
1919 # As alluded to in the last section, the ruleset we have built up for
1920 # detecting directory renames unfortunately has some special cases where it
1921 # results in slightly suboptimal or non-intuitive behavior.  This section
1922 # explores these cases.
1923 #
1924 # To be fair, we already had non-intuitive or suboptimal behavior for most
1925 # of these cases in git before introducing implicit directory rename
1926 # detection, but it'd be nice if there was a modified ruleset out there
1927 # that handled these cases a bit better.
1928 ###########################################################################
1929
1930 # Testcase 8a, Dual-directory rename, one into the others' way
1931 #   Commit O. x/{a,b},   y/{c,d}
1932 #   Commit A. x/{a,b,e}, y/{c,d,f}
1933 #   Commit B. y/{a,b},   z/{c,d}
1934 #
1935 # Possible Resolutions:
1936 #   w/o dir-rename detection: y/{a,b,f},   z/{c,d},   x/e
1937 #   Currently expected:       y/{a,b,e,f}, z/{c,d}
1938 #   Optimal:                  y/{a,b,e},   z/{c,d,f}
1939 #
1940 # Note: Both x and y got renamed and it'd be nice to detect both, and we do
1941 # better with directory rename detection than git did without, but the
1942 # simple rule from section 5 prevents me from handling this as optimally as
1943 # we potentially could.
1944
1945 test_expect_success '8a-setup: Dual-directory rename, one into the others way' '
1946         test_create_repo 8a &&
1947         (
1948                 cd 8a &&
1949
1950                 mkdir x &&
1951                 mkdir y &&
1952                 echo a >x/a &&
1953                 echo b >x/b &&
1954                 echo c >y/c &&
1955                 echo d >y/d &&
1956                 git add x y &&
1957                 test_tick &&
1958                 git commit -m "O" &&
1959
1960                 git branch O &&
1961                 git branch A &&
1962                 git branch B &&
1963
1964                 git checkout A &&
1965                 echo e >x/e &&
1966                 echo f >y/f &&
1967                 git add x/e y/f &&
1968                 test_tick &&
1969                 git commit -m "A" &&
1970
1971                 git checkout B &&
1972                 git mv y z &&
1973                 git mv x y &&
1974                 test_tick &&
1975                 git commit -m "B"
1976         )
1977 '
1978
1979 test_expect_failure '8a-check: Dual-directory rename, one into the others way' '
1980         (
1981                 cd 8a &&
1982
1983                 git checkout A^0 &&
1984
1985                 git merge -s recursive B^0 &&
1986
1987                 git ls-files -s >out &&
1988                 test_line_count = 6 out &&
1989                 git ls-files -u >out &&
1990                 test_line_count = 0 out &&
1991                 git ls-files -o >out &&
1992                 test_line_count = 1 out &&
1993
1994                 git rev-parse >actual \
1995                         HEAD:y/a HEAD:y/b HEAD:y/e HEAD:y/f HEAD:z/c HEAD:z/d &&
1996                 git rev-parse >expect \
1997                         O:x/a    O:x/b    A:x/e    A:y/f    O:y/c    O:y/d &&
1998                 test_cmp expect actual
1999         )
2000 '
2001
2002 # Testcase 8b, Dual-directory rename, one into the others' way, with conflicting filenames
2003 #   Commit O. x/{a_1,b_1},     y/{a_2,b_2}
2004 #   Commit A. x/{a_1,b_1,e_1}, y/{a_2,b_2,e_2}
2005 #   Commit B. y/{a_1,b_1},     z/{a_2,b_2}
2006 #
2007 #   w/o dir-rename detection: y/{a_1,b_1,e_2}, z/{a_2,b_2}, x/e_1
2008 #   Currently expected:       <same>
2009 #   Scary:                    y/{a_1,b_1},     z/{a_2,b_2}, CONFLICT(add/add, e_1 vs. e_2)
2010 #   Optimal:                  y/{a_1,b_1,e_1}, z/{a_2,b_2,e_2}
2011 #
2012 # Note: Very similar to 8a, except instead of 'e' and 'f' in directories x and
2013 # y, both are named 'e'.  Without directory rename detection, neither file
2014 # moves directories.  Implement directory rename detection suboptimally, and
2015 # you get an add/add conflict, but both files were added in commit A, so this
2016 # is an add/add conflict where one side of history added both files --
2017 # something we can't represent in the index.  Obviously, we'd prefer the last
2018 # resolution, but our previous rules are too coarse to allow it.  Using both
2019 # the rules from section 4 and section 5 save us from the Scary resolution,
2020 # making us fall back to pre-directory-rename-detection behavior for both
2021 # e_1 and e_2.
2022
2023 test_expect_success '8b-setup: Dual-directory rename, one into the others way, with conflicting filenames' '
2024         test_create_repo 8b &&
2025         (
2026                 cd 8b &&
2027
2028                 mkdir x &&
2029                 mkdir y &&
2030                 echo a1 >x/a &&
2031                 echo b1 >x/b &&
2032                 echo a2 >y/a &&
2033                 echo b2 >y/b &&
2034                 git add x y &&
2035                 test_tick &&
2036                 git commit -m "O" &&
2037
2038                 git branch O &&
2039                 git branch A &&
2040                 git branch B &&
2041
2042                 git checkout A &&
2043                 echo e1 >x/e &&
2044                 echo e2 >y/e &&
2045                 git add x/e y/e &&
2046                 test_tick &&
2047                 git commit -m "A" &&
2048
2049                 git checkout B &&
2050                 git mv y z &&
2051                 git mv x y &&
2052                 test_tick &&
2053                 git commit -m "B"
2054         )
2055 '
2056
2057 test_expect_success '8b-check: Dual-directory rename, one into the others way, with conflicting filenames' '
2058         (
2059                 cd 8b &&
2060
2061                 git checkout A^0 &&
2062
2063                 git merge -s recursive B^0 &&
2064
2065                 git ls-files -s >out &&
2066                 test_line_count = 6 out &&
2067                 git ls-files -u >out &&
2068                 test_line_count = 0 out &&
2069                 git ls-files -o >out &&
2070                 test_line_count = 1 out &&
2071
2072                 git rev-parse >actual \
2073                         HEAD:y/a HEAD:y/b HEAD:z/a HEAD:z/b HEAD:x/e HEAD:y/e &&
2074                 git rev-parse >expect \
2075                         O:x/a    O:x/b    O:y/a    O:y/b    A:x/e    A:y/e &&
2076                 test_cmp expect actual
2077         )
2078 '
2079
2080 # Testcase 8c, rename+modify/delete
2081 #   (Related to testcases 5b and 8d)
2082 #   Commit O: z/{b,c,d}
2083 #   Commit A: y/{b,c}
2084 #   Commit B: z/{b,c,d_modified,e}
2085 #   Expected: y/{b,c,e}, CONFLICT(rename+modify/delete: x/d -> y/d or deleted)
2086 #
2087 #   Note: This testcase doesn't present any concerns for me...until you
2088 #         compare it with testcases 5b and 8d.  See notes in 8d for more
2089 #         details.
2090
2091 test_expect_success '8c-setup: rename+modify/delete' '
2092         test_create_repo 8c &&
2093         (
2094                 cd 8c &&
2095
2096                 mkdir z &&
2097                 echo b >z/b &&
2098                 echo c >z/c &&
2099                 test_seq 1 10 >z/d &&
2100                 git add z &&
2101                 test_tick &&
2102                 git commit -m "O" &&
2103
2104                 git branch O &&
2105                 git branch A &&
2106                 git branch B &&
2107
2108                 git checkout A &&
2109                 git rm z/d &&
2110                 git mv z y &&
2111                 test_tick &&
2112                 git commit -m "A" &&
2113
2114                 git checkout B &&
2115                 echo 11 >z/d &&
2116                 test_chmod +x z/d &&
2117                 echo e >z/e &&
2118                 git add z/d z/e &&
2119                 test_tick &&
2120                 git commit -m "B"
2121         )
2122 '
2123
2124 test_expect_failure '8c-check: rename+modify/delete' '
2125         (
2126                 cd 8c &&
2127
2128                 git checkout A^0 &&
2129
2130                 test_must_fail git merge -s recursive B^0 >out &&
2131                 test_i18ngrep "CONFLICT (rename/delete).* z/d.*y/d" out &&
2132
2133                 git ls-files -s >out &&
2134                 test_line_count = 4 out &&
2135                 git ls-files -u >out &&
2136                 test_line_count = 1 out &&
2137                 git ls-files -o >out &&
2138                 test_line_count = 1 out &&
2139
2140                 git rev-parse >actual \
2141                         :0:y/b :0:y/c :0:y/e :3:y/d &&
2142                 git rev-parse >expect \
2143                          O:z/b  O:z/c  B:z/e  B:z/d &&
2144                 test_cmp expect actual &&
2145
2146                 test_must_fail git rev-parse :1:y/d &&
2147                 test_must_fail git rev-parse :2:y/d &&
2148                 git ls-files -s y/d | grep ^100755 &&
2149                 test_path_is_file y/d
2150         )
2151 '
2152
2153 # Testcase 8d, rename/delete...or not?
2154 #   (Related to testcase 5b; these may appear slightly inconsistent to users;
2155 #    Also related to testcases 7d and 7e)
2156 #   Commit O: z/{b,c,d}
2157 #   Commit A: y/{b,c}
2158 #   Commit B: z/{b,c,d,e}
2159 #   Expected: y/{b,c,e}
2160 #
2161 #   Note: It would also be somewhat reasonable to resolve this as
2162 #             y/{b,c,e}, CONFLICT(rename/delete: x/d -> y/d or deleted)
2163 #   The logic being that the only difference between this testcase and 8c
2164 #   is that there is no modification to d.  That suggests that instead of a
2165 #   rename/modify vs. delete conflict, we should just have a rename/delete
2166 #   conflict, otherwise we are being inconsistent.
2167 #
2168 #   However...as far as consistency goes, we didn't report a conflict for
2169 #   path d_1 in testcase 5b due to a different file being in the way.  So,
2170 #   we seem to be forced to have cases where users can change things
2171 #   slightly and get what they may perceive as inconsistent results.  It
2172 #   would be nice to avoid that, but I'm not sure I see how.
2173 #
2174 #   In this case, I'm leaning towards: commit A was the one that deleted z/d
2175 #   and it did the rename of z to y, so the two "conflicts" (rename vs.
2176 #   delete) are both coming from commit A, which is illogical.  Conflicts
2177 #   during merging are supposed to be about opposite sides doing things
2178 #   differently.
2179
2180 test_expect_success '8d-setup: rename/delete...or not?' '
2181         test_create_repo 8d &&
2182         (
2183                 cd 8d &&
2184
2185                 mkdir z &&
2186                 echo b >z/b &&
2187                 echo c >z/c &&
2188                 test_seq 1 10 >z/d &&
2189                 git add z &&
2190                 test_tick &&
2191                 git commit -m "O" &&
2192
2193                 git branch O &&
2194                 git branch A &&
2195                 git branch B &&
2196
2197                 git checkout A &&
2198                 git rm z/d &&
2199                 git mv z y &&
2200                 test_tick &&
2201                 git commit -m "A" &&
2202
2203                 git checkout B &&
2204                 echo e >z/e &&
2205                 git add z/e &&
2206                 test_tick &&
2207                 git commit -m "B"
2208         )
2209 '
2210
2211 test_expect_failure '8d-check: rename/delete...or not?' '
2212         (
2213                 cd 8d &&
2214
2215                 git checkout A^0 &&
2216
2217                 git merge -s recursive B^0 &&
2218
2219                 git ls-files -s >out &&
2220                 test_line_count = 3 out &&
2221
2222                 git rev-parse >actual \
2223                         HEAD:y/b HEAD:y/c HEAD:y/e &&
2224                 git rev-parse >expect \
2225                         O:z/b    O:z/c    B:z/e &&
2226                 test_cmp expect actual
2227         )
2228 '
2229
2230 # Testcase 8e, Both sides rename, one side adds to original directory
2231 #   Commit O: z/{b,c}
2232 #   Commit A: y/{b,c}
2233 #   Commit B: w/{b,c}, z/d
2234 #
2235 # Possible Resolutions:
2236 #   w/o dir-rename detection: z/d, CONFLICT(z/b -> y/b vs. w/b),
2237 #                                  CONFLICT(z/c -> y/c vs. w/c)
2238 #   Currently expected:       y/d, CONFLICT(z/b -> y/b vs. w/b),
2239 #                                  CONFLICT(z/c -> y/c vs. w/c)
2240 #   Optimal:                  ??
2241 #
2242 # Notes: In commit A, directory z got renamed to y.  In commit B, directory z
2243 #        did NOT get renamed; the directory is still present; instead it is
2244 #        considered to have just renamed a subset of paths in directory z
2245 #        elsewhere.  Therefore, the directory rename done in commit A to z/
2246 #        applies to z/d and maps it to y/d.
2247 #
2248 #        It's possible that users would get confused about this, but what
2249 #        should we do instead?  Silently leaving at z/d seems just as bad or
2250 #        maybe even worse.  Perhaps we could print a big warning about z/d
2251 #        and how we're moving to y/d in this case, but when I started thinking
2252 #        about the ramifications of doing that, I didn't know how to rule out
2253 #        that opening other weird edge and corner cases so I just punted.
2254
2255 test_expect_success '8e-setup: Both sides rename, one side adds to original directory' '
2256         test_create_repo 8e &&
2257         (
2258                 cd 8e &&
2259
2260                 mkdir z &&
2261                 echo b >z/b &&
2262                 echo c >z/c &&
2263                 git add z &&
2264                 test_tick &&
2265                 git commit -m "O" &&
2266
2267                 git branch O &&
2268                 git branch A &&
2269                 git branch B &&
2270
2271                 git checkout A &&
2272                 git mv z y &&
2273                 test_tick &&
2274                 git commit -m "A" &&
2275
2276                 git checkout B &&
2277                 git mv z w &&
2278                 mkdir z &&
2279                 echo d >z/d &&
2280                 git add z/d &&
2281                 test_tick &&
2282                 git commit -m "B"
2283         )
2284 '
2285
2286 test_expect_failure '8e-check: Both sides rename, one side adds to original directory' '
2287         (
2288                 cd 8e &&
2289
2290                 git checkout A^0 &&
2291
2292                 test_must_fail git merge -s recursive B^0 >out 2>err &&
2293                 test_i18ngrep CONFLICT.*rename/rename.*z/c.*y/c.*w/c out &&
2294                 test_i18ngrep CONFLICT.*rename/rename.*z/b.*y/b.*w/b out &&
2295
2296                 git ls-files -s >out &&
2297                 test_line_count = 7 out &&
2298                 git ls-files -u >out &&
2299                 test_line_count = 6 out &&
2300                 git ls-files -o >out &&
2301                 test_line_count = 2 out &&
2302
2303                 git rev-parse >actual \
2304                         :1:z/b :2:y/b :3:w/b :1:z/c :2:y/c :3:w/c :0:y/d &&
2305                 git rev-parse >expect \
2306                          O:z/b  O:z/b  O:z/b  O:z/c  O:z/c  O:z/c  B:z/d &&
2307                 test_cmp expect actual &&
2308
2309                 git hash-object >actual \
2310                         y/b   w/b   y/c   w/c &&
2311                 git rev-parse >expect \
2312                         O:z/b O:z/b O:z/c O:z/c &&
2313                 test_cmp expect actual &&
2314
2315                 test_path_is_missing z/b &&
2316                 test_path_is_missing z/c
2317         )
2318 '
2319
2320 ###########################################################################
2321 # SECTION 9: Other testcases
2322 #
2323 # This section consists of miscellaneous testcases I thought of during
2324 # the implementation which round out the testing.
2325 ###########################################################################
2326
2327 # Testcase 9a, Inner renamed directory within outer renamed directory
2328 #   (Related to testcase 1f)
2329 #   Commit O: z/{b,c,d/{e,f,g}}
2330 #   Commit A: y/{b,c}, x/w/{e,f,g}
2331 #   Commit B: z/{b,c,d/{e,f,g,h},i}
2332 #   Expected: y/{b,c,i}, x/w/{e,f,g,h}
2333 #   NOTE: The only reason this one is interesting is because when a directory
2334 #         is split into multiple other directories, we determine by the weight
2335 #         of which one had the most paths going to it.  A naive implementation
2336 #         of that could take the new file in commit B at z/i to x/w/i or x/i.
2337
2338 test_expect_success '9a-setup: Inner renamed directory within outer renamed directory' '
2339         test_create_repo 9a &&
2340         (
2341                 cd 9a &&
2342
2343                 mkdir -p z/d &&
2344                 echo b >z/b &&
2345                 echo c >z/c &&
2346                 echo e >z/d/e &&
2347                 echo f >z/d/f &&
2348                 echo g >z/d/g &&
2349                 git add z &&
2350                 test_tick &&
2351                 git commit -m "O" &&
2352
2353                 git branch O &&
2354                 git branch A &&
2355                 git branch B &&
2356
2357                 git checkout A &&
2358                 mkdir x &&
2359                 git mv z/d x/w &&
2360                 git mv z y &&
2361                 test_tick &&
2362                 git commit -m "A" &&
2363
2364                 git checkout B &&
2365                 echo h >z/d/h &&
2366                 echo i >z/i &&
2367                 git add z &&
2368                 test_tick &&
2369                 git commit -m "B"
2370         )
2371 '
2372
2373 test_expect_failure '9a-check: Inner renamed directory within outer renamed directory' '
2374         (
2375                 cd 9a &&
2376
2377                 git checkout A^0 &&
2378
2379                 git merge -s recursive B^0 &&
2380
2381                 git ls-files -s >out &&
2382                 test_line_count = 7 out &&
2383                 git ls-files -u >out &&
2384                 test_line_count = 0 out &&
2385                 git ls-files -o >out &&
2386                 test_line_count = 1 out &&
2387
2388                 git rev-parse >actual \
2389                         HEAD:y/b HEAD:y/c HEAD:y/i &&
2390                 git rev-parse >expect \
2391                         O:z/b    O:z/c    B:z/i &&
2392                 test_cmp expect actual &&
2393
2394                 git rev-parse >actual \
2395                         HEAD:x/w/e HEAD:x/w/f HEAD:x/w/g HEAD:x/w/h &&
2396                 git rev-parse >expect \
2397                         O:z/d/e    O:z/d/f    O:z/d/g    B:z/d/h &&
2398                 test_cmp expect actual
2399         )
2400 '
2401
2402 # Testcase 9b, Transitive rename with content merge
2403 #   (Related to testcase 1c)
2404 #   Commit O: z/{b,c},   x/d_1
2405 #   Commit A: y/{b,c},   x/d_2
2406 #   Commit B: z/{b,c,d_3}
2407 #   Expected: y/{b,c,d_merged}
2408
2409 test_expect_success '9b-setup: Transitive rename with content merge' '
2410         test_create_repo 9b &&
2411         (
2412                 cd 9b &&
2413
2414                 mkdir z &&
2415                 echo b >z/b &&
2416                 echo c >z/c &&
2417                 mkdir x &&
2418                 test_seq 1 10 >x/d &&
2419                 git add z x &&
2420                 test_tick &&
2421                 git commit -m "O" &&
2422
2423                 git branch O &&
2424                 git branch A &&
2425                 git branch B &&
2426
2427                 git checkout A &&
2428                 git mv z y &&
2429                 test_seq 1 11 >x/d &&
2430                 git add x/d &&
2431                 test_tick &&
2432                 git commit -m "A" &&
2433
2434                 git checkout B &&
2435                 test_seq 0 10 >x/d &&
2436                 git mv x/d z/d &&
2437                 git add z/d &&
2438                 test_tick &&
2439                 git commit -m "B"
2440         )
2441 '
2442
2443 test_expect_failure '9b-check: Transitive rename with content merge' '
2444         (
2445                 cd 9b &&
2446
2447                 git checkout A^0 &&
2448
2449                 git merge -s recursive B^0 &&
2450
2451                 git ls-files -s >out &&
2452                 test_line_count = 3 out &&
2453
2454                 test_seq 0 11 >expected &&
2455                 test_cmp expected y/d &&
2456                 git add expected &&
2457                 git rev-parse >actual \
2458                         HEAD:y/b HEAD:y/c HEAD:y/d &&
2459                 git rev-parse >expect \
2460                         O:z/b    O:z/c    :0:expected &&
2461                 test_cmp expect actual &&
2462                 test_must_fail git rev-parse HEAD:x/d &&
2463                 test_must_fail git rev-parse HEAD:z/d &&
2464                 test_path_is_missing z/d &&
2465
2466                 test $(git rev-parse HEAD:y/d) != $(git rev-parse O:x/d) &&
2467                 test $(git rev-parse HEAD:y/d) != $(git rev-parse A:x/d) &&
2468                 test $(git rev-parse HEAD:y/d) != $(git rev-parse B:z/d)
2469         )
2470 '
2471
2472 # Testcase 9c, Doubly transitive rename?
2473 #   (Related to testcase 1c, 7e, and 9d)
2474 #   Commit O: z/{b,c},     x/{d,e},    w/f
2475 #   Commit A: y/{b,c},     x/{d,e,f,g}
2476 #   Commit B: z/{b,c,d,e},             w/f
2477 #   Expected: y/{b,c,d,e}, x/{f,g}
2478 #
2479 #   NOTE: x/f and x/g may be slightly confusing here.  The rename from w/f to
2480 #         x/f is clear.  Let's look beyond that.  Here's the logic:
2481 #            Commit B renamed x/ -> z/
2482 #            Commit A renamed z/ -> y/
2483 #         So, we could possibly further rename x/f to z/f to y/f, a doubly
2484 #         transient rename.  However, where does it end?  We can chain these
2485 #         indefinitely (see testcase 9d).  What if there is a D/F conflict
2486 #         at z/f/ or y/f/?  Or just another file conflict at one of those
2487 #         paths?  In the case of an N-long chain of transient renamings,
2488 #         where do we "abort" the rename at?  Can the user make sense of
2489 #         the resulting conflict and resolve it?
2490 #
2491 #         To avoid this confusion I use the simple rule that if the other side
2492 #         of history did a directory rename to a path that your side renamed
2493 #         away, then ignore that particular rename from the other side of
2494 #         history for any implicit directory renames.
2495
2496 test_expect_success '9c-setup: Doubly transitive rename?' '
2497         test_create_repo 9c &&
2498         (
2499                 cd 9c &&
2500
2501                 mkdir z &&
2502                 echo b >z/b &&
2503                 echo c >z/c &&
2504                 mkdir x &&
2505                 echo d >x/d &&
2506                 echo e >x/e &&
2507                 mkdir w &&
2508                 echo f >w/f &&
2509                 git add z x w &&
2510                 test_tick &&
2511                 git commit -m "O" &&
2512
2513                 git branch O &&
2514                 git branch A &&
2515                 git branch B &&
2516
2517                 git checkout A &&
2518                 git mv z y &&
2519                 git mv w/f x/ &&
2520                 echo g >x/g &&
2521                 git add x/g &&
2522                 test_tick &&
2523                 git commit -m "A" &&
2524
2525                 git checkout B &&
2526                 git mv x/d z/d &&
2527                 git mv x/e z/e &&
2528                 test_tick &&
2529                 git commit -m "B"
2530         )
2531 '
2532
2533 test_expect_failure '9c-check: Doubly transitive rename?' '
2534         (
2535                 cd 9c &&
2536
2537                 git checkout A^0 &&
2538
2539                 git merge -s recursive B^0 >out &&
2540                 test_i18ngrep "WARNING: Avoiding applying x -> z rename to x/f" out &&
2541
2542                 git ls-files -s >out &&
2543                 test_line_count = 6 out &&
2544                 git ls-files -o >out &&
2545                 test_line_count = 1 out &&
2546
2547                 git rev-parse >actual \
2548                         HEAD:y/b HEAD:y/c HEAD:y/d HEAD:y/e HEAD:x/f HEAD:x/g &&
2549                 git rev-parse >expect \
2550                         O:z/b    O:z/c    O:x/d    O:x/e    O:w/f    A:x/g &&
2551                 test_cmp expect actual
2552         )
2553 '
2554
2555 # Testcase 9d, N-fold transitive rename?
2556 #   (Related to testcase 9c...and 1c and 7e)
2557 #   Commit O: z/a, y/b, x/c, w/d, v/e, u/f
2558 #   Commit A:  y/{a,b},  w/{c,d},  u/{e,f}
2559 #   Commit B: z/{a,t}, x/{b,c}, v/{d,e}, u/f
2560 #   Expected: <see NOTE first>
2561 #
2562 #   NOTE: z/ -> y/ (in commit A)
2563 #         y/ -> x/ (in commit B)
2564 #         x/ -> w/ (in commit A)
2565 #         w/ -> v/ (in commit B)
2566 #         v/ -> u/ (in commit A)
2567 #         So, if we add a file to z, say z/t, where should it end up?  In u?
2568 #         What if there's another file or directory named 't' in one of the
2569 #         intervening directories and/or in u itself?  Also, shouldn't the
2570 #         same logic that places 't' in u/ also move ALL other files to u/?
2571 #         What if there are file or directory conflicts in any of them?  If
2572 #         we attempted to do N-way (N-fold? N-ary? N-uple?) transitive renames
2573 #         like this, would the user have any hope of understanding any
2574 #         conflicts or how their working tree ended up?  I think not, so I'm
2575 #         ruling out N-ary transitive renames for N>1.
2576 #
2577 #   Therefore our expected result is:
2578 #     z/t, y/a, x/b, w/c, u/d, u/e, u/f
2579 #   The reason that v/d DOES get transitively renamed to u/d is that u/ isn't
2580 #   renamed somewhere.  A slightly sub-optimal result, but it uses fairly
2581 #   simple rules that are consistent with what we need for all the other
2582 #   testcases and simplifies things for the user.
2583
2584 test_expect_success '9d-setup: N-way transitive rename?' '
2585         test_create_repo 9d &&
2586         (
2587                 cd 9d &&
2588
2589                 mkdir z y x w v u &&
2590                 echo a >z/a &&
2591                 echo b >y/b &&
2592                 echo c >x/c &&
2593                 echo d >w/d &&
2594                 echo e >v/e &&
2595                 echo f >u/f &&
2596                 git add z y x w v u &&
2597                 test_tick &&
2598                 git commit -m "O" &&
2599
2600                 git branch O &&
2601                 git branch A &&
2602                 git branch B &&
2603
2604                 git checkout A &&
2605                 git mv z/a y/ &&
2606                 git mv x/c w/ &&
2607                 git mv v/e u/ &&
2608                 test_tick &&
2609                 git commit -m "A" &&
2610
2611                 git checkout B &&
2612                 echo t >z/t &&
2613                 git mv y/b x/ &&
2614                 git mv w/d v/ &&
2615                 git add z/t &&
2616                 test_tick &&
2617                 git commit -m "B"
2618         )
2619 '
2620
2621 test_expect_failure '9d-check: N-way transitive rename?' '
2622         (
2623                 cd 9d &&
2624
2625                 git checkout A^0 &&
2626
2627                 git merge -s recursive B^0 >out &&
2628                 test_i18ngrep "WARNING: Avoiding applying z -> y rename to z/t" out &&
2629                 test_i18ngrep "WARNING: Avoiding applying y -> x rename to y/a" out &&
2630                 test_i18ngrep "WARNING: Avoiding applying x -> w rename to x/b" out &&
2631                 test_i18ngrep "WARNING: Avoiding applying w -> v rename to w/c" out &&
2632
2633                 git ls-files -s >out &&
2634                 test_line_count = 7 out &&
2635                 git ls-files -o >out &&
2636                 test_line_count = 1 out &&
2637
2638                 git rev-parse >actual \
2639                         HEAD:z/t \
2640                         HEAD:y/a HEAD:x/b HEAD:w/c \
2641                         HEAD:u/d HEAD:u/e HEAD:u/f &&
2642                 git rev-parse >expect \
2643                         B:z/t    \
2644                         O:z/a    O:y/b    O:x/c    \
2645                         O:w/d    O:v/e    A:u/f &&
2646                 test_cmp expect actual
2647         )
2648 '
2649
2650 # Testcase 9e, N-to-1 whammo
2651 #   (Related to testcase 9c...and 1c and 7e)
2652 #   Commit O: dir1/{a,b}, dir2/{d,e}, dir3/{g,h}, dirN/{j,k}
2653 #   Commit A: dir1/{a,b,c,yo}, dir2/{d,e,f,yo}, dir3/{g,h,i,yo}, dirN/{j,k,l,yo}
2654 #   Commit B: combined/{a,b,d,e,g,h,j,k}
2655 #   Expected: combined/{a,b,c,d,e,f,g,h,i,j,k,l}, CONFLICT(Nto1) warnings,
2656 #             dir1/yo, dir2/yo, dir3/yo, dirN/yo
2657
2658 test_expect_success '9e-setup: N-to-1 whammo' '
2659         test_create_repo 9e &&
2660         (
2661                 cd 9e &&
2662
2663                 mkdir dir1 dir2 dir3 dirN &&
2664                 echo a >dir1/a &&
2665                 echo b >dir1/b &&
2666                 echo d >dir2/d &&
2667                 echo e >dir2/e &&
2668                 echo g >dir3/g &&
2669                 echo h >dir3/h &&
2670                 echo j >dirN/j &&
2671                 echo k >dirN/k &&
2672                 git add dir* &&
2673                 test_tick &&
2674                 git commit -m "O" &&
2675
2676                 git branch O &&
2677                 git branch A &&
2678                 git branch B &&
2679
2680                 git checkout A &&
2681                 echo c  >dir1/c &&
2682                 echo yo >dir1/yo &&
2683                 echo f  >dir2/f &&
2684                 echo yo >dir2/yo &&
2685                 echo i  >dir3/i &&
2686                 echo yo >dir3/yo &&
2687                 echo l  >dirN/l &&
2688                 echo yo >dirN/yo &&
2689                 git add dir* &&
2690                 test_tick &&
2691                 git commit -m "A" &&
2692
2693                 git checkout B &&
2694                 git mv dir1 combined &&
2695                 git mv dir2/* combined/ &&
2696                 git mv dir3/* combined/ &&
2697                 git mv dirN/* combined/ &&
2698                 test_tick &&
2699                 git commit -m "B"
2700         )
2701 '
2702
2703 test_expect_failure C_LOCALE_OUTPUT '9e-check: N-to-1 whammo' '
2704         (
2705                 cd 9e &&
2706
2707                 git checkout A^0 &&
2708
2709                 test_must_fail git merge -s recursive B^0 >out &&
2710                 grep "CONFLICT (implicit dir rename): Cannot map more than one path to combined/yo" out >error_line &&
2711                 grep -q dir1/yo error_line &&
2712                 grep -q dir2/yo error_line &&
2713                 grep -q dir3/yo error_line &&
2714                 grep -q dirN/yo error_line &&
2715
2716                 git ls-files -s >out &&
2717                 test_line_count = 16 out &&
2718                 git ls-files -u >out &&
2719                 test_line_count = 0 out &&
2720                 git ls-files -o >out &&
2721                 test_line_count = 2 out &&
2722
2723                 git rev-parse >actual \
2724                         :0:combined/a :0:combined/b :0:combined/c \
2725                         :0:combined/d :0:combined/e :0:combined/f \
2726                         :0:combined/g :0:combined/h :0:combined/i \
2727                         :0:combined/j :0:combined/k :0:combined/l &&
2728                 git rev-parse >expect \
2729                          O:dir1/a      O:dir1/b      A:dir1/c \
2730                          O:dir2/d      O:dir2/e      A:dir2/f \
2731                          O:dir3/g      O:dir3/h      A:dir3/i \
2732                          O:dirN/j      O:dirN/k      A:dirN/l &&
2733                 test_cmp expect actual &&
2734
2735                 git rev-parse >actual \
2736                         :0:dir1/yo :0:dir2/yo :0:dir3/yo :0:dirN/yo &&
2737                 git rev-parse >expect \
2738                          A:dir1/yo  A:dir2/yo  A:dir3/yo  A:dirN/yo &&
2739                 test_cmp expect actual
2740         )
2741 '
2742
2743 # Testcase 9f, Renamed directory that only contained immediate subdirs
2744 #   (Related to testcases 1e & 9g)
2745 #   Commit O: goal/{a,b}/$more_files
2746 #   Commit A: priority/{a,b}/$more_files
2747 #   Commit B: goal/{a,b}/$more_files, goal/c
2748 #   Expected: priority/{a,b}/$more_files, priority/c
2749
2750 test_expect_success '9f-setup: Renamed directory that only contained immediate subdirs' '
2751         test_create_repo 9f &&
2752         (
2753                 cd 9f &&
2754
2755                 mkdir -p goal/a &&
2756                 mkdir -p goal/b &&
2757                 echo foo >goal/a/foo &&
2758                 echo bar >goal/b/bar &&
2759                 echo baz >goal/b/baz &&
2760                 git add goal &&
2761                 test_tick &&
2762                 git commit -m "O" &&
2763
2764                 git branch O &&
2765                 git branch A &&
2766                 git branch B &&
2767
2768                 git checkout A &&
2769                 git mv goal/ priority &&
2770                 test_tick &&
2771                 git commit -m "A" &&
2772
2773                 git checkout B &&
2774                 echo c >goal/c &&
2775                 git add goal/c &&
2776                 test_tick &&
2777                 git commit -m "B"
2778         )
2779 '
2780
2781 test_expect_failure '9f-check: Renamed directory that only contained immediate subdirs' '
2782         (
2783                 cd 9f &&
2784
2785                 git checkout A^0 &&
2786
2787                 git merge -s recursive B^0 &&
2788
2789                 git ls-files -s >out &&
2790                 test_line_count = 4 out &&
2791
2792                 git rev-parse >actual \
2793                         HEAD:priority/a/foo \
2794                         HEAD:priority/b/bar \
2795                         HEAD:priority/b/baz \
2796                         HEAD:priority/c &&
2797                 git rev-parse >expect \
2798                         O:goal/a/foo \
2799                         O:goal/b/bar \
2800                         O:goal/b/baz \
2801                         B:goal/c &&
2802                 test_cmp expect actual &&
2803                 test_must_fail git rev-parse HEAD:goal/c
2804         )
2805 '
2806
2807 # Testcase 9g, Renamed directory that only contained immediate subdirs, immediate subdirs renamed
2808 #   (Related to testcases 1e & 9f)
2809 #   Commit O: goal/{a,b}/$more_files
2810 #   Commit A: priority/{alpha,bravo}/$more_files
2811 #   Commit B: goal/{a,b}/$more_files, goal/c
2812 #   Expected: priority/{alpha,bravo}/$more_files, priority/c
2813
2814 test_expect_success '9g-setup: Renamed directory that only contained immediate subdirs, immediate subdirs renamed' '
2815         test_create_repo 9g &&
2816         (
2817                 cd 9g &&
2818
2819                 mkdir -p goal/a &&
2820                 mkdir -p goal/b &&
2821                 echo foo >goal/a/foo &&
2822                 echo bar >goal/b/bar &&
2823                 echo baz >goal/b/baz &&
2824                 git add goal &&
2825                 test_tick &&
2826                 git commit -m "O" &&
2827
2828                 git branch O &&
2829                 git branch A &&
2830                 git branch B &&
2831
2832                 git checkout A &&
2833                 mkdir priority &&
2834                 git mv goal/a/ priority/alpha &&
2835                 git mv goal/b/ priority/beta &&
2836                 rmdir goal/ &&
2837                 test_tick &&
2838                 git commit -m "A" &&
2839
2840                 git checkout B &&
2841                 echo c >goal/c &&
2842                 git add goal/c &&
2843                 test_tick &&
2844                 git commit -m "B"
2845         )
2846 '
2847
2848 test_expect_failure '9g-check: Renamed directory that only contained immediate subdirs, immediate subdirs renamed' '
2849         (
2850                 cd 9g &&
2851
2852                 git checkout A^0 &&
2853
2854                 git merge -s recursive B^0 &&
2855
2856                 git ls-files -s >out &&
2857                 test_line_count = 4 out &&
2858
2859                 git rev-parse >actual \
2860                         HEAD:priority/alpha/foo \
2861                         HEAD:priority/beta/bar  \
2862                         HEAD:priority/beta/baz  \
2863                         HEAD:priority/c &&
2864                 git rev-parse >expect \
2865                         O:goal/a/foo \
2866                         O:goal/b/bar \
2867                         O:goal/b/baz \
2868                         B:goal/c &&
2869                 test_cmp expect actual &&
2870                 test_must_fail git rev-parse HEAD:goal/c
2871         )
2872 '
2873
2874 ###########################################################################
2875 # Rules suggested by section 9:
2876 #
2877 #   If the other side of history did a directory rename to a path that your
2878 #   side renamed away, then ignore that particular rename from the other
2879 #   side of history for any implicit directory renames.
2880 ###########################################################################
2881
2882 test_done