| 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 | # SECTION 1: Basic cases we should be able to handle |
| 32 | ########################################################################### |
| 33 | |
| 34 | # Testcase 1a, Basic directory rename. |
| 35 | # Commit O: z/{b,c} |
| 36 | # Commit A: y/{b,c} |
| 37 | # Commit B: z/{b,c,d,e/f} |
| 38 | # Expected: y/{b,c,d,e/f} |
| 39 | |
| 40 | test_setup_1a () { |
| 41 | git init 1a && |
| 42 | ( |
| 43 | cd 1a && |
| 44 | |
| 45 | mkdir z && |
| 46 | echo b >z/b && |
| 47 | echo c >z/c && |
| 48 | git add z && |
| 49 | test_tick && |
| 50 | git commit -m "O" && |
| 51 | |
| 52 | git branch O && |
| 53 | git branch A && |
| 54 | git branch B && |
| 55 | |
| 56 | git checkout A && |
| 57 | git mv z y && |
| 58 | test_tick && |
| 59 | git commit -m "A" && |
| 60 | |
| 61 | git checkout B && |
| 62 | echo d >z/d && |
| 63 | mkdir z/e && |
| 64 | echo f >z/e/f && |
| 65 | git add z/d z/e/f && |
| 66 | test_tick && |
| 67 | git commit -m "B" |
| 68 | ) |
| 69 | } |
| 70 | |
| 71 | test_expect_success '1a: Simple directory rename detection' ' |
| 72 | test_setup_1a && |
| 73 | ( |
| 74 | cd 1a && |
| 75 | |
| 76 | git checkout A^0 && |
| 77 | |
| 78 | git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 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_setup_1b () { |
| 107 | git init 1b && |
| 108 | ( |
| 109 | cd 1b && |
| 110 | |
| 111 | mkdir z && |
| 112 | echo b >z/b && |
| 113 | echo c >z/c && |
| 114 | mkdir y && |
| 115 | echo d >y/d && |
| 116 | git add z y && |
| 117 | test_tick && |
| 118 | git commit -m "O" && |
| 119 | |
| 120 | git branch O && |
| 121 | git branch A && |
| 122 | git branch B && |
| 123 | |
| 124 | git checkout A && |
| 125 | echo e >z/e && |
| 126 | git add z/e && |
| 127 | test_tick && |
| 128 | git commit -m "A" && |
| 129 | |
| 130 | git checkout B && |
| 131 | git mv z/b y && |
| 132 | git mv z/c y && |
| 133 | rmdir z && |
| 134 | test_tick && |
| 135 | git commit -m "B" |
| 136 | ) |
| 137 | } |
| 138 | |
| 139 | test_expect_success '1b: Merge a directory with another' ' |
| 140 | test_setup_1b && |
| 141 | ( |
| 142 | cd 1b && |
| 143 | |
| 144 | git checkout A^0 && |
| 145 | |
| 146 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 147 | |
| 148 | git ls-files -s >out && |
| 149 | test_line_count = 4 out && |
| 150 | |
| 151 | git rev-parse >actual \ |
| 152 | HEAD:y/b HEAD:y/c HEAD:y/d HEAD:y/e && |
| 153 | git rev-parse >expect \ |
| 154 | O:z/b O:z/c O:y/d A:z/e && |
| 155 | test_cmp expect actual && |
| 156 | test_must_fail git rev-parse HEAD:z/e |
| 157 | ) |
| 158 | ' |
| 159 | |
| 160 | # Testcase 1c, Transitive renaming |
| 161 | # (Related to testcases 3a and 6d -- when should a transitive rename apply?) |
| 162 | # (Related to testcases 9c and 9d -- can transitivity repeat?) |
| 163 | # (Related to testcase 12b -- joint-transitivity?) |
| 164 | # Commit O: z/{b,c}, x/d |
| 165 | # Commit A: y/{b,c}, x/d |
| 166 | # Commit B: z/{b,c,d} |
| 167 | # Expected: y/{b,c,d} (because x/d -> z/d -> y/d) |
| 168 | |
| 169 | test_setup_1c () { |
| 170 | git init 1c && |
| 171 | ( |
| 172 | cd 1c && |
| 173 | |
| 174 | mkdir z && |
| 175 | echo b >z/b && |
| 176 | echo c >z/c && |
| 177 | mkdir x && |
| 178 | echo d >x/d && |
| 179 | git add z x && |
| 180 | test_tick && |
| 181 | git commit -m "O" && |
| 182 | |
| 183 | git branch O && |
| 184 | git branch A && |
| 185 | git branch B && |
| 186 | |
| 187 | git checkout A && |
| 188 | git mv z y && |
| 189 | test_tick && |
| 190 | git commit -m "A" && |
| 191 | |
| 192 | git checkout B && |
| 193 | git mv x/d z/d && |
| 194 | test_tick && |
| 195 | git commit -m "B" |
| 196 | ) |
| 197 | } |
| 198 | |
| 199 | test_expect_success '1c: Transitive renaming' ' |
| 200 | test_setup_1c && |
| 201 | ( |
| 202 | cd 1c && |
| 203 | |
| 204 | git checkout A^0 && |
| 205 | |
| 206 | git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 207 | |
| 208 | git ls-files -s >out && |
| 209 | test_line_count = 3 out && |
| 210 | |
| 211 | git rev-parse >actual \ |
| 212 | HEAD:y/b HEAD:y/c HEAD:y/d && |
| 213 | git rev-parse >expect \ |
| 214 | O:z/b O:z/c O:x/d && |
| 215 | test_cmp expect actual && |
| 216 | test_must_fail git rev-parse HEAD:x/d && |
| 217 | test_must_fail git rev-parse HEAD:z/d && |
| 218 | test_path_is_missing z/d |
| 219 | ) |
| 220 | ' |
| 221 | |
| 222 | # Testcase 1d, Directory renames (merging two directories into one new one) |
| 223 | # cause a rename/rename(2to1) conflict |
| 224 | # (Related to testcases 1c and 7b) |
| 225 | # Commit O. z/{b,c}, y/{d,e} |
| 226 | # Commit A. x/{b,c}, y/{d,e,m,wham_1} |
| 227 | # Commit B. z/{b,c,n,wham_2}, x/{d,e} |
| 228 | # Expected: x/{b,c,d,e,m,n}, CONFLICT:(y/wham_1 & z/wham_2 -> x/wham) |
| 229 | # Note: y/m & z/n should definitely move into x. By the same token, both |
| 230 | # y/wham_1 & z/wham_2 should too...giving us a conflict. |
| 231 | |
| 232 | test_setup_1d () { |
| 233 | git init 1d && |
| 234 | ( |
| 235 | cd 1d && |
| 236 | |
| 237 | mkdir z && |
| 238 | echo b >z/b && |
| 239 | echo c >z/c && |
| 240 | mkdir y && |
| 241 | echo d >y/d && |
| 242 | echo e >y/e && |
| 243 | git add z y && |
| 244 | test_tick && |
| 245 | git commit -m "O" && |
| 246 | |
| 247 | git branch O && |
| 248 | git branch A && |
| 249 | git branch B && |
| 250 | |
| 251 | git checkout A && |
| 252 | git mv z x && |
| 253 | echo m >y/m && |
| 254 | echo wham1 >y/wham && |
| 255 | git add y && |
| 256 | test_tick && |
| 257 | git commit -m "A" && |
| 258 | |
| 259 | git checkout B && |
| 260 | git mv y x && |
| 261 | echo n >z/n && |
| 262 | echo wham2 >z/wham && |
| 263 | git add z && |
| 264 | test_tick && |
| 265 | git commit -m "B" |
| 266 | ) |
| 267 | } |
| 268 | |
| 269 | test_expect_success '1d: Directory renames cause a rename/rename(2to1) conflict' ' |
| 270 | test_setup_1d && |
| 271 | ( |
| 272 | cd 1d && |
| 273 | |
| 274 | git checkout A^0 && |
| 275 | |
| 276 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 277 | test_grep "CONFLICT (\(.*\)/\1)" out && |
| 278 | |
| 279 | git ls-files -s >out && |
| 280 | test_line_count = 8 out && |
| 281 | git ls-files -u >out && |
| 282 | test_line_count = 2 out && |
| 283 | git ls-files -o >out && |
| 284 | test_line_count = 1 out && |
| 285 | |
| 286 | git rev-parse >actual \ |
| 287 | :0:x/b :0:x/c :0:x/d :0:x/e :0:x/m :0:x/n && |
| 288 | git rev-parse >expect \ |
| 289 | O:z/b O:z/c O:y/d O:y/e A:y/m B:z/n && |
| 290 | test_cmp expect actual && |
| 291 | |
| 292 | test_must_fail git rev-parse :0:x/wham && |
| 293 | git rev-parse >actual \ |
| 294 | :2:x/wham :3:x/wham && |
| 295 | git rev-parse >expect \ |
| 296 | A:y/wham B:z/wham && |
| 297 | test_cmp expect actual && |
| 298 | |
| 299 | # Test that the two-way merge in x/wham is as expected |
| 300 | git cat-file -p :2:x/wham >expect && |
| 301 | git cat-file -p :3:x/wham >other && |
| 302 | >empty && |
| 303 | test_must_fail git merge-file \ |
| 304 | -L "HEAD:y/wham" \ |
| 305 | -L "" \ |
| 306 | -L "B^0:z/wham" \ |
| 307 | expect empty other && |
| 308 | test_cmp expect x/wham |
| 309 | ) |
| 310 | ' |
| 311 | |
| 312 | # Testcase 1e, Renamed directory, with all filenames being renamed too |
| 313 | # (Related to testcases 9f & 9g) |
| 314 | # Commit O: z/{oldb,oldc} |
| 315 | # Commit A: y/{newb,newc} |
| 316 | # Commit B: z/{oldb,oldc,d} |
| 317 | # Expected: y/{newb,newc,d} |
| 318 | |
| 319 | test_setup_1e () { |
| 320 | git init 1e && |
| 321 | ( |
| 322 | cd 1e && |
| 323 | |
| 324 | mkdir z && |
| 325 | echo b >z/oldb && |
| 326 | echo c >z/oldc && |
| 327 | git add z && |
| 328 | test_tick && |
| 329 | git commit -m "O" && |
| 330 | |
| 331 | git branch O && |
| 332 | git branch A && |
| 333 | git branch B && |
| 334 | |
| 335 | git checkout A && |
| 336 | mkdir y && |
| 337 | git mv z/oldb y/newb && |
| 338 | git mv z/oldc y/newc && |
| 339 | test_tick && |
| 340 | git commit -m "A" && |
| 341 | |
| 342 | git checkout B && |
| 343 | echo d >z/d && |
| 344 | git add z/d && |
| 345 | test_tick && |
| 346 | git commit -m "B" |
| 347 | ) |
| 348 | } |
| 349 | |
| 350 | test_expect_success '1e: Renamed directory, with all files being renamed too' ' |
| 351 | test_setup_1e && |
| 352 | ( |
| 353 | cd 1e && |
| 354 | |
| 355 | git checkout A^0 && |
| 356 | |
| 357 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 358 | |
| 359 | git ls-files -s >out && |
| 360 | test_line_count = 3 out && |
| 361 | |
| 362 | git rev-parse >actual \ |
| 363 | HEAD:y/newb HEAD:y/newc HEAD:y/d && |
| 364 | git rev-parse >expect \ |
| 365 | O:z/oldb O:z/oldc B:z/d && |
| 366 | test_cmp expect actual && |
| 367 | test_must_fail git rev-parse HEAD:z/d |
| 368 | ) |
| 369 | ' |
| 370 | |
| 371 | # Testcase 1f, Split a directory into two other directories |
| 372 | # (Related to testcases 3a, all of section 2, and all of section 4) |
| 373 | # Commit O: z/{b,c,d,e,f} |
| 374 | # Commit A: z/{b,c,d,e,f,g} |
| 375 | # Commit B: y/{b,c}, x/{d,e,f} |
| 376 | # Expected: y/{b,c}, x/{d,e,f,g} |
| 377 | |
| 378 | test_setup_1f () { |
| 379 | git init 1f && |
| 380 | ( |
| 381 | cd 1f && |
| 382 | |
| 383 | mkdir z && |
| 384 | echo b >z/b && |
| 385 | echo c >z/c && |
| 386 | echo d >z/d && |
| 387 | echo e >z/e && |
| 388 | echo f >z/f && |
| 389 | git add z && |
| 390 | test_tick && |
| 391 | git commit -m "O" && |
| 392 | |
| 393 | git branch O && |
| 394 | git branch A && |
| 395 | git branch B && |
| 396 | |
| 397 | git checkout A && |
| 398 | echo g >z/g && |
| 399 | git add z/g && |
| 400 | test_tick && |
| 401 | git commit -m "A" && |
| 402 | |
| 403 | git checkout B && |
| 404 | mkdir y && |
| 405 | mkdir x && |
| 406 | git mv z/b y/ && |
| 407 | git mv z/c y/ && |
| 408 | git mv z/d x/ && |
| 409 | git mv z/e x/ && |
| 410 | git mv z/f x/ && |
| 411 | rmdir z && |
| 412 | test_tick && |
| 413 | git commit -m "B" |
| 414 | ) |
| 415 | } |
| 416 | |
| 417 | test_expect_success '1f: Split a directory into two other directories' ' |
| 418 | test_setup_1f && |
| 419 | ( |
| 420 | cd 1f && |
| 421 | |
| 422 | git checkout A^0 && |
| 423 | |
| 424 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 425 | |
| 426 | git ls-files -s >out && |
| 427 | test_line_count = 6 out && |
| 428 | |
| 429 | git rev-parse >actual \ |
| 430 | HEAD:y/b HEAD:y/c HEAD:x/d HEAD:x/e HEAD:x/f HEAD:x/g && |
| 431 | git rev-parse >expect \ |
| 432 | O:z/b O:z/c O:z/d O:z/e O:z/f A:z/g && |
| 433 | test_cmp expect actual && |
| 434 | test_path_is_missing z/g && |
| 435 | test_must_fail git rev-parse HEAD:z/g |
| 436 | ) |
| 437 | ' |
| 438 | |
| 439 | ########################################################################### |
| 440 | # Rules suggested by testcases in section 1: |
| 441 | # |
| 442 | # We should still detect the directory rename even if it wasn't just |
| 443 | # the directory renamed, but the files within it. (see 1b) |
| 444 | # |
| 445 | # If renames split a directory into two or more others, the directory |
| 446 | # with the most renames, "wins" (see 1f). However, see the testcases |
| 447 | # in section 2, plus testcases 3a and 4a. |
| 448 | ########################################################################### |
| 449 | |
| 450 | |
| 451 | ########################################################################### |
| 452 | # SECTION 2: Split into multiple directories, with equal number of paths |
| 453 | # |
| 454 | # Explore the splitting-a-directory rules a bit; what happens in the |
| 455 | # edge cases? |
| 456 | # |
| 457 | # Note that there is a closely related case of a directory not being |
| 458 | # split on either side of history, but being renamed differently on |
| 459 | # each side. See testcase 8e for that. |
| 460 | ########################################################################### |
| 461 | |
| 462 | # Testcase 2a, Directory split into two on one side, with equal numbers of paths |
| 463 | # Commit O: z/{b,c} |
| 464 | # Commit A: y/b, w/c |
| 465 | # Commit B: z/{b,c,d} |
| 466 | # Expected: y/b, w/c, z/d, with warning about z/ -> (y/ vs. w/) conflict |
| 467 | test_setup_2a () { |
| 468 | git init 2a && |
| 469 | ( |
| 470 | cd 2a && |
| 471 | |
| 472 | mkdir z && |
| 473 | echo b >z/b && |
| 474 | echo c >z/c && |
| 475 | git add z && |
| 476 | test_tick && |
| 477 | git commit -m "O" && |
| 478 | |
| 479 | git branch O && |
| 480 | git branch A && |
| 481 | git branch B && |
| 482 | |
| 483 | git checkout A && |
| 484 | mkdir y && |
| 485 | mkdir w && |
| 486 | git mv z/b y/ && |
| 487 | git mv z/c w/ && |
| 488 | test_tick && |
| 489 | git commit -m "A" && |
| 490 | |
| 491 | git checkout B && |
| 492 | echo d >z/d && |
| 493 | git add z/d && |
| 494 | test_tick && |
| 495 | git commit -m "B" |
| 496 | ) |
| 497 | } |
| 498 | |
| 499 | test_expect_success '2a: Directory split into two on one side, with equal numbers of paths' ' |
| 500 | test_setup_2a && |
| 501 | ( |
| 502 | cd 2a && |
| 503 | |
| 504 | git checkout A^0 && |
| 505 | |
| 506 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 507 | test_grep "CONFLICT.*directory rename split" out && |
| 508 | |
| 509 | git ls-files -s >out && |
| 510 | test_line_count = 3 out && |
| 511 | git ls-files -u >out && |
| 512 | test_line_count = 0 out && |
| 513 | git ls-files -o >out && |
| 514 | test_line_count = 1 out && |
| 515 | |
| 516 | git rev-parse >actual \ |
| 517 | :0:y/b :0:w/c :0:z/d && |
| 518 | git rev-parse >expect \ |
| 519 | O:z/b O:z/c B:z/d && |
| 520 | test_cmp expect actual |
| 521 | ) |
| 522 | ' |
| 523 | |
| 524 | # Testcase 2b, Directory split into two on one side, with equal numbers of paths |
| 525 | # Commit O: z/{b,c} |
| 526 | # Commit A: y/b, w/c |
| 527 | # Commit B: z/{b,c}, x/d |
| 528 | # Expected: y/b, w/c, x/d; No warning about z/ -> (y/ vs. w/) conflict |
| 529 | test_setup_2b () { |
| 530 | git init 2b && |
| 531 | ( |
| 532 | cd 2b && |
| 533 | |
| 534 | mkdir z && |
| 535 | echo b >z/b && |
| 536 | echo c >z/c && |
| 537 | git add z && |
| 538 | test_tick && |
| 539 | git commit -m "O" && |
| 540 | |
| 541 | git branch O && |
| 542 | git branch A && |
| 543 | git branch B && |
| 544 | |
| 545 | git checkout A && |
| 546 | mkdir y && |
| 547 | mkdir w && |
| 548 | git mv z/b y/ && |
| 549 | git mv z/c w/ && |
| 550 | test_tick && |
| 551 | git commit -m "A" && |
| 552 | |
| 553 | git checkout B && |
| 554 | mkdir x && |
| 555 | echo d >x/d && |
| 556 | git add x/d && |
| 557 | test_tick && |
| 558 | git commit -m "B" |
| 559 | ) |
| 560 | } |
| 561 | |
| 562 | test_expect_success '2b: Directory split into two on one side, with equal numbers of paths' ' |
| 563 | test_setup_2b && |
| 564 | ( |
| 565 | cd 2b && |
| 566 | |
| 567 | git checkout A^0 && |
| 568 | |
| 569 | git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 570 | |
| 571 | git ls-files -s >out && |
| 572 | test_line_count = 3 out && |
| 573 | git ls-files -u >out && |
| 574 | test_line_count = 0 out && |
| 575 | git ls-files -o >out && |
| 576 | test_line_count = 1 out && |
| 577 | |
| 578 | git rev-parse >actual \ |
| 579 | :0:y/b :0:w/c :0:x/d && |
| 580 | git rev-parse >expect \ |
| 581 | O:z/b O:z/c B:x/d && |
| 582 | test_cmp expect actual && |
| 583 | test_grep ! "CONFLICT.*directory rename split" out |
| 584 | ) |
| 585 | ' |
| 586 | |
| 587 | ########################################################################### |
| 588 | # Rules suggested by section 2: |
| 589 | # |
| 590 | # None; the rule was already covered in section 1. These testcases are |
| 591 | # here just to make sure the conflict resolution and necessary warning |
| 592 | # messages are handled correctly. |
| 593 | ########################################################################### |
| 594 | |
| 595 | |
| 596 | ########################################################################### |
| 597 | # SECTION 3: Path in question is the source path for some rename already |
| 598 | # |
| 599 | # Combining cases from Section 1 and trying to handle them could lead to |
| 600 | # directory renaming detection being over-applied. So, this section |
| 601 | # provides some good testcases to check that the implementation doesn't go |
| 602 | # too far. |
| 603 | ########################################################################### |
| 604 | |
| 605 | # Testcase 3a, Avoid implicit rename if involved as source on other side |
| 606 | # (Related to testcases 1c, 1f, and 9h) |
| 607 | # Commit O: z/{b,c,d} |
| 608 | # Commit A: z/{b,c,d} (no change) |
| 609 | # Commit B: y/{b,c}, x/d |
| 610 | # Expected: y/{b,c}, x/d |
| 611 | test_setup_3a () { |
| 612 | git init 3a && |
| 613 | ( |
| 614 | cd 3a && |
| 615 | |
| 616 | mkdir z && |
| 617 | echo b >z/b && |
| 618 | echo c >z/c && |
| 619 | echo d >z/d && |
| 620 | git add z && |
| 621 | test_tick && |
| 622 | git commit -m "O" && |
| 623 | |
| 624 | git branch O && |
| 625 | git branch A && |
| 626 | git branch B && |
| 627 | |
| 628 | git checkout A && |
| 629 | test_tick && |
| 630 | git commit --allow-empty -m "A" && |
| 631 | |
| 632 | git checkout B && |
| 633 | mkdir y && |
| 634 | mkdir x && |
| 635 | git mv z/b y/ && |
| 636 | git mv z/c y/ && |
| 637 | git mv z/d x/ && |
| 638 | rmdir z && |
| 639 | test_tick && |
| 640 | git commit -m "B" |
| 641 | ) |
| 642 | } |
| 643 | |
| 644 | test_expect_success '3a: Avoid implicit rename if involved as source on other side' ' |
| 645 | test_setup_3a && |
| 646 | ( |
| 647 | cd 3a && |
| 648 | |
| 649 | git checkout A^0 && |
| 650 | |
| 651 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 652 | |
| 653 | git ls-files -s >out && |
| 654 | test_line_count = 3 out && |
| 655 | |
| 656 | git rev-parse >actual \ |
| 657 | HEAD:y/b HEAD:y/c HEAD:x/d && |
| 658 | git rev-parse >expect \ |
| 659 | O:z/b O:z/c O:z/d && |
| 660 | test_cmp expect actual |
| 661 | ) |
| 662 | ' |
| 663 | |
| 664 | # Testcase 3b, Avoid implicit rename if involved as source on other side |
| 665 | # (Related to testcases 5c and 7c, also kind of 1e and 1f) |
| 666 | # Commit O: z/{b,c,d} |
| 667 | # Commit A: y/{b,c}, x/d |
| 668 | # Commit B: z/{b,c}, w/d |
| 669 | # Expected: y/{b,c}, CONFLICT:(z/d -> x/d vs. w/d) |
| 670 | # NOTE: We're particularly checking that since z/d is already involved as |
| 671 | # a source in a file rename on the same side of history, that we don't |
| 672 | # get it involved in directory rename detection. If it were, we might |
| 673 | # end up with CONFLICT:(z/d -> y/d vs. x/d vs. w/d), i.e. a |
| 674 | # rename/rename/rename(1to3) conflict, which is just weird. |
| 675 | test_setup_3b () { |
| 676 | git init 3b && |
| 677 | ( |
| 678 | cd 3b && |
| 679 | |
| 680 | mkdir z && |
| 681 | echo b >z/b && |
| 682 | echo c >z/c && |
| 683 | echo d >z/d && |
| 684 | git add z && |
| 685 | test_tick && |
| 686 | git commit -m "O" && |
| 687 | |
| 688 | git branch O && |
| 689 | git branch A && |
| 690 | git branch B && |
| 691 | |
| 692 | git checkout A && |
| 693 | mkdir y && |
| 694 | mkdir x && |
| 695 | git mv z/b y/ && |
| 696 | git mv z/c y/ && |
| 697 | git mv z/d x/ && |
| 698 | rmdir z && |
| 699 | test_tick && |
| 700 | git commit -m "A" && |
| 701 | |
| 702 | git checkout B && |
| 703 | mkdir w && |
| 704 | git mv z/d w/ && |
| 705 | test_tick && |
| 706 | git commit -m "B" |
| 707 | ) |
| 708 | } |
| 709 | |
| 710 | test_expect_success '3b: Avoid implicit rename if involved as source on current side' ' |
| 711 | test_setup_3b && |
| 712 | ( |
| 713 | cd 3b && |
| 714 | |
| 715 | git checkout A^0 && |
| 716 | |
| 717 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 718 | test_grep CONFLICT.*rename/rename.*z/d.*x/d.*w/d out && |
| 719 | test_grep ! CONFLICT.*rename/rename.*y/d out && |
| 720 | |
| 721 | git ls-files -s >out && |
| 722 | test_line_count = 5 out && |
| 723 | git ls-files -u >out && |
| 724 | test_line_count = 3 out && |
| 725 | git ls-files -o >out && |
| 726 | test_line_count = 1 out && |
| 727 | |
| 728 | git rev-parse >actual \ |
| 729 | :0:y/b :0:y/c :1:z/d :2:x/d :3:w/d && |
| 730 | git rev-parse >expect \ |
| 731 | O:z/b O:z/c O:z/d O:z/d O:z/d && |
| 732 | test_cmp expect actual && |
| 733 | |
| 734 | test_path_is_missing z/d && |
| 735 | git hash-object >actual \ |
| 736 | x/d w/d && |
| 737 | git rev-parse >expect \ |
| 738 | O:z/d O:z/d && |
| 739 | test_cmp expect actual |
| 740 | ) |
| 741 | ' |
| 742 | |
| 743 | ########################################################################### |
| 744 | # Rules suggested by section 3: |
| 745 | # |
| 746 | # Avoid directory-rename-detection for a path, if that path is the source |
| 747 | # of a rename on either side of a merge. |
| 748 | ########################################################################### |
| 749 | |
| 750 | |
| 751 | ########################################################################### |
| 752 | # SECTION 4: Partially renamed directory; still exists on both sides of merge |
| 753 | # |
| 754 | # What if we were to attempt to do directory rename detection when someone |
| 755 | # "mostly" moved a directory but still left some files around, or, |
| 756 | # equivalently, fully renamed a directory in one commit and then recreated |
| 757 | # that directory in a later commit adding some new files and then tried to |
| 758 | # merge? |
| 759 | # |
| 760 | # It's hard to divine user intent in these cases, because you can make an |
| 761 | # argument that, depending on the intermediate history of the side being |
| 762 | # merged, that some users will want files in that directory to |
| 763 | # automatically be detected and renamed, while users with a different |
| 764 | # intermediate history wouldn't want that rename to happen. |
| 765 | # |
| 766 | # I think that it is best to simply not have directory rename detection |
| 767 | # apply to such cases. My reasoning for this is four-fold: (1) it's |
| 768 | # easiest for users in general to figure out what happened if we don't |
| 769 | # apply directory rename detection in any such case, (2) it's an easy rule |
| 770 | # to explain ["We don't do directory rename detection if the directory |
| 771 | # still exists on both sides of the merge"], (3) we can get some hairy |
| 772 | # edge/corner cases that would be really confusing and possibly not even |
| 773 | # representable in the index if we were to even try, and [related to 3] (4) |
| 774 | # attempting to resolve this issue of divining user intent by examining |
| 775 | # intermediate history goes against the spirit of three-way merges and is a |
| 776 | # path towards crazy corner cases that are far more complex than what we're |
| 777 | # already dealing with. |
| 778 | # |
| 779 | # Note that the wording of the rule ("We don't do directory rename |
| 780 | # detection if the directory still exists on both sides of the merge.") |
| 781 | # also excludes "renaming" of a directory into a subdirectory of itself |
| 782 | # (e.g. /some/dir/* -> /some/dir/subdir/*). It may be possible to carve |
| 783 | # out an exception for "renaming"-beneath-itself cases without opening |
| 784 | # weird edge/corner cases for other partial directory renames, but for now |
| 785 | # we are keeping the rule simple. |
| 786 | # |
| 787 | # This section contains a test for a partially-renamed-directory case. |
| 788 | ########################################################################### |
| 789 | |
| 790 | # Testcase 4a, Directory split, with original directory still present |
| 791 | # (Related to testcase 1f) |
| 792 | # Commit O: z/{b,c,d,e} |
| 793 | # Commit A: y/{b,c,d}, z/e |
| 794 | # Commit B: z/{b,c,d,e,f} |
| 795 | # Expected: y/{b,c,d}, z/{e,f} |
| 796 | # NOTE: Even though most files from z moved to y, we don't want f to follow. |
| 797 | |
| 798 | test_setup_4a () { |
| 799 | git init 4a && |
| 800 | ( |
| 801 | cd 4a && |
| 802 | |
| 803 | mkdir z && |
| 804 | echo b >z/b && |
| 805 | echo c >z/c && |
| 806 | echo d >z/d && |
| 807 | echo e >z/e && |
| 808 | git add z && |
| 809 | test_tick && |
| 810 | git commit -m "O" && |
| 811 | |
| 812 | git branch O && |
| 813 | git branch A && |
| 814 | git branch B && |
| 815 | |
| 816 | git checkout A && |
| 817 | mkdir y && |
| 818 | git mv z/b y/ && |
| 819 | git mv z/c y/ && |
| 820 | git mv z/d y/ && |
| 821 | test_tick && |
| 822 | git commit -m "A" && |
| 823 | |
| 824 | git checkout B && |
| 825 | echo f >z/f && |
| 826 | git add z/f && |
| 827 | test_tick && |
| 828 | git commit -m "B" |
| 829 | ) |
| 830 | } |
| 831 | |
| 832 | test_expect_success '4a: Directory split, with original directory still present' ' |
| 833 | test_setup_4a && |
| 834 | ( |
| 835 | cd 4a && |
| 836 | |
| 837 | git checkout A^0 && |
| 838 | |
| 839 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 840 | |
| 841 | git ls-files -s >out && |
| 842 | test_line_count = 5 out && |
| 843 | git ls-files -u >out && |
| 844 | test_line_count = 0 out && |
| 845 | git ls-files -o >out && |
| 846 | test_line_count = 1 out && |
| 847 | |
| 848 | git rev-parse >actual \ |
| 849 | HEAD:y/b HEAD:y/c HEAD:y/d HEAD:z/e HEAD:z/f && |
| 850 | git rev-parse >expect \ |
| 851 | O:z/b O:z/c O:z/d O:z/e B:z/f && |
| 852 | test_cmp expect actual |
| 853 | ) |
| 854 | ' |
| 855 | |
| 856 | ########################################################################### |
| 857 | # Rules suggested by section 4: |
| 858 | # |
| 859 | # Directory-rename-detection should be turned off for any directories (as |
| 860 | # a source for renames) that exist on both sides of the merge. (The "as |
| 861 | # a source for renames" clarification is due to cases like 1c where |
| 862 | # the target directory exists on both sides and we do want the rename |
| 863 | # detection.) But, sadly, see testcase 8b. |
| 864 | ########################################################################### |
| 865 | |
| 866 | |
| 867 | ########################################################################### |
| 868 | # SECTION 5: Files/directories in the way of subset of to-be-renamed paths |
| 869 | # |
| 870 | # Implicitly renaming files due to a detected directory rename could run |
| 871 | # into problems if there are files or directories in the way of the paths |
| 872 | # we want to rename. Explore such cases in this section. |
| 873 | ########################################################################### |
| 874 | |
| 875 | # Testcase 5a, Merge directories, other side adds files to original and target |
| 876 | # Commit O: z/{b,c}, y/d |
| 877 | # Commit A: z/{b,c,e_1,f}, y/{d,e_2} |
| 878 | # Commit B: y/{b,c,d} |
| 879 | # Expected: z/e_1, y/{b,c,d,e_2,f} + CONFLICT warning |
| 880 | # NOTE: While directory rename detection is active here causing z/f to |
| 881 | # become y/f, we did not apply this for z/e_1 because that would |
| 882 | # give us an add/add conflict for y/e_1 vs y/e_2. This problem with |
| 883 | # this add/add, is that both versions of y/e are from the same side |
| 884 | # of history, giving us no way to represent this conflict in the |
| 885 | # index. |
| 886 | |
| 887 | test_setup_5a () { |
| 888 | git init 5a && |
| 889 | ( |
| 890 | cd 5a && |
| 891 | |
| 892 | mkdir z && |
| 893 | echo b >z/b && |
| 894 | echo c >z/c && |
| 895 | mkdir y && |
| 896 | echo d >y/d && |
| 897 | git add z y && |
| 898 | test_tick && |
| 899 | git commit -m "O" && |
| 900 | |
| 901 | git branch O && |
| 902 | git branch A && |
| 903 | git branch B && |
| 904 | |
| 905 | git checkout A && |
| 906 | echo e1 >z/e && |
| 907 | echo f >z/f && |
| 908 | echo e2 >y/e && |
| 909 | git add z/e z/f y/e && |
| 910 | test_tick && |
| 911 | git commit -m "A" && |
| 912 | |
| 913 | git checkout B && |
| 914 | git mv z/b y/ && |
| 915 | git mv z/c y/ && |
| 916 | rmdir z && |
| 917 | test_tick && |
| 918 | git commit -m "B" |
| 919 | ) |
| 920 | } |
| 921 | |
| 922 | test_expect_success '5a: Merge directories, other side adds files to original and target' ' |
| 923 | test_setup_5a && |
| 924 | ( |
| 925 | cd 5a && |
| 926 | |
| 927 | git checkout A^0 && |
| 928 | |
| 929 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 930 | test_grep "CONFLICT.*implicit dir rename" out && |
| 931 | |
| 932 | git ls-files -s >out && |
| 933 | test_line_count = 6 out && |
| 934 | git ls-files -u >out && |
| 935 | test_line_count = 0 out && |
| 936 | git ls-files -o >out && |
| 937 | test_line_count = 1 out && |
| 938 | |
| 939 | git rev-parse >actual \ |
| 940 | :0:y/b :0:y/c :0:y/d :0:y/e :0:z/e :0:y/f && |
| 941 | git rev-parse >expect \ |
| 942 | O:z/b O:z/c O:y/d A:y/e A:z/e A:z/f && |
| 943 | test_cmp expect actual |
| 944 | ) |
| 945 | ' |
| 946 | |
| 947 | # Testcase 5b, Rename/delete in order to get add/add/add conflict |
| 948 | # (Related to testcase 8d; these may appear slightly inconsistent to users; |
| 949 | # Also related to testcases 7d and 7e) |
| 950 | # Commit O: z/{b,c,d_1} |
| 951 | # Commit A: y/{b,c,d_2} |
| 952 | # Commit B: z/{b,c,d_1,e}, y/d_3 |
| 953 | # Expected: y/{b,c,e}, CONFLICT(add/add: y/d_2 vs. y/d_3) |
| 954 | # NOTE: If z/d_1 in commit B were to be involved in dir rename detection, as |
| 955 | # we normally would since z/ is being renamed to y/, then this would be |
| 956 | # a rename/delete (z/d_1 -> y/d_1 vs. deleted) AND an add/add/add |
| 957 | # conflict of y/d_1 vs. y/d_2 vs. y/d_3. Add/add/add is not |
| 958 | # representable in the index, so the existence of y/d_3 needs to |
| 959 | # cause us to bail on directory rename detection for that path, falling |
| 960 | # back to git behavior without the directory rename detection. |
| 961 | |
| 962 | test_setup_5b () { |
| 963 | git init 5b && |
| 964 | ( |
| 965 | cd 5b && |
| 966 | |
| 967 | mkdir z && |
| 968 | echo b >z/b && |
| 969 | echo c >z/c && |
| 970 | echo d1 >z/d && |
| 971 | git add z && |
| 972 | test_tick && |
| 973 | git commit -m "O" && |
| 974 | |
| 975 | git branch O && |
| 976 | git branch A && |
| 977 | git branch B && |
| 978 | |
| 979 | git checkout A && |
| 980 | git rm z/d && |
| 981 | git mv z y && |
| 982 | echo d2 >y/d && |
| 983 | git add y/d && |
| 984 | test_tick && |
| 985 | git commit -m "A" && |
| 986 | |
| 987 | git checkout B && |
| 988 | mkdir y && |
| 989 | echo d3 >y/d && |
| 990 | echo e >z/e && |
| 991 | git add y/d z/e && |
| 992 | test_tick && |
| 993 | git commit -m "B" |
| 994 | ) |
| 995 | } |
| 996 | |
| 997 | test_expect_success '5b: Rename/delete in order to get add/add/add conflict' ' |
| 998 | test_setup_5b && |
| 999 | ( |
| 1000 | cd 5b && |
| 1001 | |
| 1002 | git checkout A^0 && |
| 1003 | |
| 1004 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1005 | test_grep "CONFLICT (add/add).* y/d" out && |
| 1006 | |
| 1007 | git ls-files -s >out && |
| 1008 | test_line_count = 5 out && |
| 1009 | git ls-files -u >out && |
| 1010 | test_line_count = 2 out && |
| 1011 | git ls-files -o >out && |
| 1012 | test_line_count = 1 out && |
| 1013 | |
| 1014 | git rev-parse >actual \ |
| 1015 | :0:y/b :0:y/c :0:y/e :2:y/d :3:y/d && |
| 1016 | git rev-parse >expect \ |
| 1017 | O:z/b O:z/c B:z/e A:y/d B:y/d && |
| 1018 | test_cmp expect actual && |
| 1019 | |
| 1020 | test_must_fail git rev-parse :1:y/d && |
| 1021 | test_path_is_file y/d |
| 1022 | ) |
| 1023 | ' |
| 1024 | |
| 1025 | # Testcase 5c, Transitive rename would cause rename/rename/rename/add/add/add |
| 1026 | # (Directory rename detection would result in transitive rename vs. |
| 1027 | # rename/rename(1to2) and turn it into a rename/rename(1to3). Further, |
| 1028 | # rename paths conflict with separate adds on the other side) |
| 1029 | # (Related to testcases 3b and 7c) |
| 1030 | # Commit O: z/{b,c}, x/d_1 |
| 1031 | # Commit A: y/{b,c,d_2}, w/d_1 |
| 1032 | # Commit B: z/{b,c,d_1,e}, w/d_3, y/d_4 |
| 1033 | # Expected: A mess, but only a rename/rename(1to2)/add/add mess. Use the |
| 1034 | # presence of y/d_4 in B to avoid doing transitive rename of |
| 1035 | # x/d_1 -> z/d_1 -> y/d_1, so that the only paths we have at |
| 1036 | # y/d are y/d_2 and y/d_4. We still do the move from z/e to y/e, |
| 1037 | # though, because it doesn't have anything in the way. |
| 1038 | |
| 1039 | test_setup_5c () { |
| 1040 | git init 5c && |
| 1041 | ( |
| 1042 | cd 5c && |
| 1043 | |
| 1044 | mkdir z && |
| 1045 | echo b >z/b && |
| 1046 | echo c >z/c && |
| 1047 | mkdir x && |
| 1048 | echo d1 >x/d && |
| 1049 | git add z x && |
| 1050 | test_tick && |
| 1051 | git commit -m "O" && |
| 1052 | |
| 1053 | git branch O && |
| 1054 | git branch A && |
| 1055 | git branch B && |
| 1056 | |
| 1057 | git checkout A && |
| 1058 | git mv z y && |
| 1059 | echo d2 >y/d && |
| 1060 | git add y/d && |
| 1061 | git mv x w && |
| 1062 | test_tick && |
| 1063 | git commit -m "A" && |
| 1064 | |
| 1065 | git checkout B && |
| 1066 | git mv x/d z/ && |
| 1067 | mkdir w && |
| 1068 | mkdir y && |
| 1069 | echo d3 >w/d && |
| 1070 | echo d4 >y/d && |
| 1071 | echo e >z/e && |
| 1072 | git add w/ y/ z/e && |
| 1073 | test_tick && |
| 1074 | git commit -m "B" |
| 1075 | ) |
| 1076 | } |
| 1077 | |
| 1078 | test_expect_success '5c: Transitive rename would cause rename/rename/rename/add/add/add' ' |
| 1079 | test_setup_5c && |
| 1080 | ( |
| 1081 | cd 5c && |
| 1082 | |
| 1083 | git checkout A^0 && |
| 1084 | |
| 1085 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1086 | test_grep "CONFLICT (rename/rename).*x/d.*w/d.*z/d" out && |
| 1087 | test_grep "CONFLICT (add/add).* y/d" out && |
| 1088 | |
| 1089 | git ls-files -s >out && |
| 1090 | test_line_count = 9 out && |
| 1091 | git ls-files -u >out && |
| 1092 | test_line_count = 6 out && |
| 1093 | git ls-files -o >out && |
| 1094 | test_line_count = 1 out && |
| 1095 | |
| 1096 | git rev-parse >actual \ |
| 1097 | :0:y/b :0:y/c :0:y/e && |
| 1098 | git rev-parse >expect \ |
| 1099 | O:z/b O:z/c B:z/e && |
| 1100 | test_cmp expect actual && |
| 1101 | |
| 1102 | test_must_fail git rev-parse :1:y/d && |
| 1103 | git rev-parse >actual \ |
| 1104 | :2:w/d :3:w/d :1:x/d :2:y/d :3:y/d :3:z/d && |
| 1105 | git rev-parse >expect \ |
| 1106 | O:x/d B:w/d O:x/d A:y/d B:y/d O:x/d && |
| 1107 | test_cmp expect actual && |
| 1108 | |
| 1109 | git hash-object >actual \ |
| 1110 | z/d && |
| 1111 | git rev-parse >expect \ |
| 1112 | O:x/d && |
| 1113 | test_cmp expect actual && |
| 1114 | test_path_is_missing x/d && |
| 1115 | test_path_is_file y/d && |
| 1116 | test_grep -q "<<<<" y/d # conflict markers should be present |
| 1117 | ) |
| 1118 | ' |
| 1119 | |
| 1120 | # Testcase 5d, Directory/file/file conflict due to directory rename |
| 1121 | # Commit O: z/{b,c} |
| 1122 | # Commit A: y/{b,c,d_1} |
| 1123 | # Commit B: z/{b,c,d_2,f}, y/d/e |
| 1124 | # Expected: y/{b,c,d/e,f}, z/d_2, CONFLICT(file/directory), y/d_1~HEAD |
| 1125 | # Note: The fact that y/d/ exists in B makes us bail on directory rename |
| 1126 | # detection for z/d_2, but that doesn't prevent us from applying the |
| 1127 | # directory rename detection for z/f -> y/f. |
| 1128 | |
| 1129 | test_setup_5d () { |
| 1130 | git init 5d && |
| 1131 | ( |
| 1132 | cd 5d && |
| 1133 | |
| 1134 | mkdir z && |
| 1135 | echo b >z/b && |
| 1136 | echo c >z/c && |
| 1137 | git add z && |
| 1138 | test_tick && |
| 1139 | git commit -m "O" && |
| 1140 | |
| 1141 | git branch O && |
| 1142 | git branch A && |
| 1143 | git branch B && |
| 1144 | |
| 1145 | git checkout A && |
| 1146 | git mv z y && |
| 1147 | echo d1 >y/d && |
| 1148 | git add y/d && |
| 1149 | test_tick && |
| 1150 | git commit -m "A" && |
| 1151 | |
| 1152 | git checkout B && |
| 1153 | mkdir -p y/d && |
| 1154 | echo e >y/d/e && |
| 1155 | echo d2 >z/d && |
| 1156 | echo f >z/f && |
| 1157 | git add y/d/e z/d z/f && |
| 1158 | test_tick && |
| 1159 | git commit -m "B" |
| 1160 | ) |
| 1161 | } |
| 1162 | |
| 1163 | test_expect_success '5d: Directory/file/file conflict due to directory rename' ' |
| 1164 | test_setup_5d && |
| 1165 | ( |
| 1166 | cd 5d && |
| 1167 | |
| 1168 | git checkout A^0 && |
| 1169 | |
| 1170 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1171 | test_grep "CONFLICT (file/directory).*y/d" out && |
| 1172 | |
| 1173 | git ls-files -s >out && |
| 1174 | test_line_count = 6 out && |
| 1175 | git ls-files -u >out && |
| 1176 | test_line_count = 1 out && |
| 1177 | git ls-files -o >out && |
| 1178 | test_line_count = 1 out && |
| 1179 | |
| 1180 | git rev-parse >actual \ |
| 1181 | :0:y/b :0:y/c :0:z/d :0:y/f :2:y/d~HEAD :0:y/d/e && |
| 1182 | git rev-parse >expect \ |
| 1183 | O:z/b O:z/c B:z/d B:z/f A:y/d B:y/d/e && |
| 1184 | test_cmp expect actual && |
| 1185 | |
| 1186 | git hash-object y/d~HEAD >actual && |
| 1187 | git rev-parse A:y/d >expect && |
| 1188 | test_cmp expect actual |
| 1189 | ) |
| 1190 | ' |
| 1191 | |
| 1192 | ########################################################################### |
| 1193 | # Rules suggested by section 5: |
| 1194 | # |
| 1195 | # If a subset of to-be-renamed files have a file or directory in the way, |
| 1196 | # "turn off" the directory rename for those specific sub-paths, falling |
| 1197 | # back to old handling. But, sadly, see testcases 8a and 8b. |
| 1198 | ########################################################################### |
| 1199 | |
| 1200 | |
| 1201 | ########################################################################### |
| 1202 | # SECTION 6: Same side of the merge was the one that did the rename |
| 1203 | # |
| 1204 | # It may sound obvious that you only want to apply implicit directory |
| 1205 | # renames to directories if the _other_ side of history did the renaming. |
| 1206 | # If you did make an implementation that didn't explicitly enforce this |
| 1207 | # rule, the majority of cases that would fall under this section would |
| 1208 | # also be solved by following the rules from the above sections. But |
| 1209 | # there are still a few that stick out, so this section covers them just |
| 1210 | # to make sure we also get them right. |
| 1211 | ########################################################################### |
| 1212 | |
| 1213 | # Testcase 6a, Tricky rename/delete |
| 1214 | # Commit O: z/{b,c,d} |
| 1215 | # Commit A: z/b |
| 1216 | # Commit B: y/{b,c}, z/d |
| 1217 | # Expected: y/b, CONFLICT(rename/delete, z/c -> y/c vs. NULL) |
| 1218 | # Note: We're just checking here that the rename of z/b and z/c to put |
| 1219 | # them under y/ doesn't accidentally catch z/d and make it look like |
| 1220 | # it is also involved in a rename/delete conflict. |
| 1221 | |
| 1222 | test_setup_6a () { |
| 1223 | git init 6a && |
| 1224 | ( |
| 1225 | cd 6a && |
| 1226 | |
| 1227 | mkdir z && |
| 1228 | echo b >z/b && |
| 1229 | echo c >z/c && |
| 1230 | echo d >z/d && |
| 1231 | git add z && |
| 1232 | test_tick && |
| 1233 | git commit -m "O" && |
| 1234 | |
| 1235 | git branch O && |
| 1236 | git branch A && |
| 1237 | git branch B && |
| 1238 | |
| 1239 | git checkout A && |
| 1240 | git rm z/c && |
| 1241 | git rm z/d && |
| 1242 | test_tick && |
| 1243 | git commit -m "A" && |
| 1244 | |
| 1245 | git checkout B && |
| 1246 | mkdir y && |
| 1247 | git mv z/b y/ && |
| 1248 | git mv z/c y/ && |
| 1249 | test_tick && |
| 1250 | git commit -m "B" |
| 1251 | ) |
| 1252 | } |
| 1253 | |
| 1254 | test_expect_success '6a: Tricky rename/delete' ' |
| 1255 | test_setup_6a && |
| 1256 | ( |
| 1257 | cd 6a && |
| 1258 | |
| 1259 | git checkout A^0 && |
| 1260 | |
| 1261 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1262 | test_grep "CONFLICT (rename/delete).*z/c.*y/c" out && |
| 1263 | |
| 1264 | git ls-files -s >out && |
| 1265 | test_line_count = 3 out && |
| 1266 | git ls-files -u >out && |
| 1267 | test_line_count = 2 out && |
| 1268 | git ls-files -o >out && |
| 1269 | test_line_count = 1 out && |
| 1270 | |
| 1271 | git rev-parse >actual \ |
| 1272 | :0:y/b :1:y/c :3:y/c && |
| 1273 | git rev-parse >expect \ |
| 1274 | O:z/b O:z/c O:z/c && |
| 1275 | test_cmp expect actual |
| 1276 | ) |
| 1277 | ' |
| 1278 | |
| 1279 | # Testcase 6b1, Same rename done on both sides |
| 1280 | # (Related to testcase 6b2 and 8e) |
| 1281 | # Commit O: z/{b,c,d,e} |
| 1282 | # Commit A: y/{b,c,d}, x/e |
| 1283 | # Commit B: y/{b,c,d}, z/{e,f} |
| 1284 | # Expected: y/{b,c,d,f}, x/e |
| 1285 | # Note: Directory rename detection says A renamed z/ -> y/ (3 paths renamed |
| 1286 | # to y/ and only 1 renamed to x/), therefore the new file 'z/f' in B |
| 1287 | # should be moved to 'y/f'. |
| 1288 | # |
| 1289 | # This is a bit of an edge case where any behavior might surprise users, |
| 1290 | # whether that is treating A as renaming z/ -> y/, treating A as renaming |
| 1291 | # z/ -> x/, or treating A as not doing any directory rename. However, I |
| 1292 | # think this answer is the least confusing and most consistent with the |
| 1293 | # rules elsewhere. |
| 1294 | # |
| 1295 | # A note about z/ -> x/, since it may not be clear how that could come |
| 1296 | # about: If we were to ignore files renamed by both sides |
| 1297 | # (i.e. z/{b,c,d}), as directory rename detection did in git-2.18 thru |
| 1298 | # at least git-2.28, then we would note there are no renames from z/ to |
| 1299 | # y/ and one rename from z/ to x/ and thus come to the conclusion that |
| 1300 | # A renamed z/ -> x/. This seems more confusing for end users than a |
| 1301 | # rename of z/ to y/, it makes directory rename detection behavior |
| 1302 | # harder for them to predict. As such, we modified the rule, changed |
| 1303 | # the behavior on testcases 6b2 and 8e, and introduced this 6b1 testcase. |
| 1304 | |
| 1305 | test_setup_6b1 () { |
| 1306 | git init 6b1 && |
| 1307 | ( |
| 1308 | cd 6b1 && |
| 1309 | |
| 1310 | mkdir z && |
| 1311 | echo b >z/b && |
| 1312 | echo c >z/c && |
| 1313 | echo d >z/d && |
| 1314 | echo e >z/e && |
| 1315 | git add z && |
| 1316 | test_tick && |
| 1317 | git commit -m "O" && |
| 1318 | |
| 1319 | git branch O && |
| 1320 | git branch A && |
| 1321 | git branch B && |
| 1322 | |
| 1323 | git checkout A && |
| 1324 | git mv z y && |
| 1325 | mkdir x && |
| 1326 | git mv y/e x/e && |
| 1327 | test_tick && |
| 1328 | git commit -m "A" && |
| 1329 | |
| 1330 | git checkout B && |
| 1331 | git mv z y && |
| 1332 | mkdir z && |
| 1333 | git mv y/e z/e && |
| 1334 | echo f >z/f && |
| 1335 | git add z/f && |
| 1336 | test_tick && |
| 1337 | git commit -m "B" |
| 1338 | ) |
| 1339 | } |
| 1340 | |
| 1341 | test_expect_success '6b1: Same renames done on both sides, plus another rename' ' |
| 1342 | test_setup_6b1 && |
| 1343 | ( |
| 1344 | cd 6b1 && |
| 1345 | |
| 1346 | git checkout A^0 && |
| 1347 | |
| 1348 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 1349 | |
| 1350 | git ls-files -s >out && |
| 1351 | test_line_count = 5 out && |
| 1352 | git ls-files -u >out && |
| 1353 | test_line_count = 0 out && |
| 1354 | git ls-files -o >out && |
| 1355 | test_line_count = 1 out && |
| 1356 | |
| 1357 | git rev-parse >actual \ |
| 1358 | HEAD:y/b HEAD:y/c HEAD:y/d HEAD:x/e HEAD:y/f && |
| 1359 | git rev-parse >expect \ |
| 1360 | O:z/b O:z/c O:z/d O:z/e B:z/f && |
| 1361 | test_cmp expect actual |
| 1362 | ) |
| 1363 | ' |
| 1364 | |
| 1365 | # Testcase 6b2, Same rename done on both sides |
| 1366 | # (Related to testcases 6c and 8e) |
| 1367 | # Commit O: z/{b,c} |
| 1368 | # Commit A: y/{b,c} |
| 1369 | # Commit B: y/{b,c}, z/d |
| 1370 | # Expected: y/{b,c,d} |
| 1371 | # Alternate: y/{b,c}, z/d |
| 1372 | # Note: Directory rename detection says A renamed z/ -> y/, therefore the new |
| 1373 | # file 'z/d' in B should be moved to 'y/d'. |
| 1374 | # |
| 1375 | # We could potentially ignore the renames of z/{b,c} on side A since |
| 1376 | # those were renamed on both sides. However, it's a bit of a corner |
| 1377 | # case because what if there was also a z/e that side A moved to x/e |
| 1378 | # and side B left alone? If we used the "ignore renames done on both |
| 1379 | # sides" logic, then we'd compute that A renamed z/ -> x/, and move |
| 1380 | # z/d to x/d. That seems more surprising and uglier than allowing |
| 1381 | # the z/ -> y/ rename. |
| 1382 | |
| 1383 | test_setup_6b2 () { |
| 1384 | git init 6b2 && |
| 1385 | ( |
| 1386 | cd 6b2 && |
| 1387 | |
| 1388 | mkdir z && |
| 1389 | echo b >z/b && |
| 1390 | echo c >z/c && |
| 1391 | git add z && |
| 1392 | test_tick && |
| 1393 | git commit -m "O" && |
| 1394 | |
| 1395 | git branch O && |
| 1396 | git branch A && |
| 1397 | git branch B && |
| 1398 | |
| 1399 | git checkout A && |
| 1400 | git mv z y && |
| 1401 | test_tick && |
| 1402 | git commit -m "A" && |
| 1403 | |
| 1404 | git checkout B && |
| 1405 | git mv z y && |
| 1406 | mkdir z && |
| 1407 | echo d >z/d && |
| 1408 | git add z/d && |
| 1409 | test_tick && |
| 1410 | git commit -m "B" |
| 1411 | ) |
| 1412 | } |
| 1413 | |
| 1414 | test_expect_success '6b2: Same rename done on both sides' ' |
| 1415 | test_setup_6b2 && |
| 1416 | ( |
| 1417 | cd 6b2 && |
| 1418 | |
| 1419 | git checkout A^0 && |
| 1420 | |
| 1421 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 1422 | |
| 1423 | git ls-files -s >out && |
| 1424 | test_line_count = 3 out && |
| 1425 | git ls-files -u >out && |
| 1426 | test_line_count = 0 out && |
| 1427 | git ls-files -o >out && |
| 1428 | test_line_count = 1 out && |
| 1429 | |
| 1430 | git rev-parse >actual \ |
| 1431 | HEAD:y/b HEAD:y/c HEAD:y/d && |
| 1432 | git rev-parse >expect \ |
| 1433 | O:z/b O:z/c B:z/d && |
| 1434 | test_cmp expect actual |
| 1435 | ) |
| 1436 | ' |
| 1437 | |
| 1438 | # Testcase 6c, Rename only done on same side |
| 1439 | # (Related to testcases 6b1, 6b2, and 8e) |
| 1440 | # Commit O: z/{b,c} |
| 1441 | # Commit A: z/{b,c} (no change) |
| 1442 | # Commit B: y/{b,c}, z/d |
| 1443 | # Expected: y/{b,c}, z/d |
| 1444 | # NOTE: Seems obvious, but just checking that the implementation doesn't |
| 1445 | # "accidentally detect a rename" and give us y/{b,c,d}. |
| 1446 | |
| 1447 | test_setup_6c () { |
| 1448 | git init 6c && |
| 1449 | ( |
| 1450 | cd 6c && |
| 1451 | |
| 1452 | mkdir z && |
| 1453 | echo b >z/b && |
| 1454 | echo c >z/c && |
| 1455 | git add z && |
| 1456 | test_tick && |
| 1457 | git commit -m "O" && |
| 1458 | |
| 1459 | git branch O && |
| 1460 | git branch A && |
| 1461 | git branch B && |
| 1462 | |
| 1463 | git checkout A && |
| 1464 | test_tick && |
| 1465 | git commit --allow-empty -m "A" && |
| 1466 | |
| 1467 | git checkout B && |
| 1468 | git mv z y && |
| 1469 | mkdir z && |
| 1470 | echo d >z/d && |
| 1471 | git add z/d && |
| 1472 | test_tick && |
| 1473 | git commit -m "B" |
| 1474 | ) |
| 1475 | } |
| 1476 | |
| 1477 | test_expect_success '6c: Rename only done on same side' ' |
| 1478 | test_setup_6c && |
| 1479 | ( |
| 1480 | cd 6c && |
| 1481 | |
| 1482 | git checkout A^0 && |
| 1483 | |
| 1484 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 1485 | |
| 1486 | git ls-files -s >out && |
| 1487 | test_line_count = 3 out && |
| 1488 | git ls-files -u >out && |
| 1489 | test_line_count = 0 out && |
| 1490 | git ls-files -o >out && |
| 1491 | test_line_count = 1 out && |
| 1492 | |
| 1493 | git rev-parse >actual \ |
| 1494 | HEAD:y/b HEAD:y/c HEAD:z/d && |
| 1495 | git rev-parse >expect \ |
| 1496 | O:z/b O:z/c B:z/d && |
| 1497 | test_cmp expect actual |
| 1498 | ) |
| 1499 | ' |
| 1500 | |
| 1501 | # Testcase 6d, We don't always want transitive renaming |
| 1502 | # (Related to testcase 1c) |
| 1503 | # Commit O: z/{b,c}, x/d |
| 1504 | # Commit A: z/{b,c}, x/d (no change) |
| 1505 | # Commit B: y/{b,c}, z/d |
| 1506 | # Expected: y/{b,c}, z/d |
| 1507 | # NOTE: Again, this seems obvious but just checking that the implementation |
| 1508 | # doesn't "accidentally detect a rename" and give us y/{b,c,d}. |
| 1509 | |
| 1510 | test_setup_6d () { |
| 1511 | git init 6d && |
| 1512 | ( |
| 1513 | cd 6d && |
| 1514 | |
| 1515 | mkdir z && |
| 1516 | echo b >z/b && |
| 1517 | echo c >z/c && |
| 1518 | mkdir x && |
| 1519 | echo d >x/d && |
| 1520 | git add z x && |
| 1521 | test_tick && |
| 1522 | git commit -m "O" && |
| 1523 | |
| 1524 | git branch O && |
| 1525 | git branch A && |
| 1526 | git branch B && |
| 1527 | |
| 1528 | git checkout A && |
| 1529 | test_tick && |
| 1530 | git commit --allow-empty -m "A" && |
| 1531 | |
| 1532 | git checkout B && |
| 1533 | git mv z y && |
| 1534 | git mv x z && |
| 1535 | test_tick && |
| 1536 | git commit -m "B" |
| 1537 | ) |
| 1538 | } |
| 1539 | |
| 1540 | test_expect_success '6d: We do not always want transitive renaming' ' |
| 1541 | test_setup_6d && |
| 1542 | ( |
| 1543 | cd 6d && |
| 1544 | |
| 1545 | git checkout A^0 && |
| 1546 | |
| 1547 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 1548 | |
| 1549 | git ls-files -s >out && |
| 1550 | test_line_count = 3 out && |
| 1551 | git ls-files -u >out && |
| 1552 | test_line_count = 0 out && |
| 1553 | git ls-files -o >out && |
| 1554 | test_line_count = 1 out && |
| 1555 | |
| 1556 | git rev-parse >actual \ |
| 1557 | HEAD:y/b HEAD:y/c HEAD:z/d && |
| 1558 | git rev-parse >expect \ |
| 1559 | O:z/b O:z/c O:x/d && |
| 1560 | test_cmp expect actual |
| 1561 | ) |
| 1562 | ' |
| 1563 | |
| 1564 | # Testcase 6e, Add/add from one-side |
| 1565 | # Commit O: z/{b,c} |
| 1566 | # Commit A: z/{b,c} (no change) |
| 1567 | # Commit B: y/{b,c,d_1}, z/d_2 |
| 1568 | # Expected: y/{b,c,d_1}, z/d_2 |
| 1569 | # NOTE: Again, this seems obvious but just checking that the implementation |
| 1570 | # doesn't "accidentally detect a rename" and give us y/{b,c} + |
| 1571 | # add/add conflict on y/d_1 vs y/d_2. |
| 1572 | |
| 1573 | test_setup_6e () { |
| 1574 | git init 6e && |
| 1575 | ( |
| 1576 | cd 6e && |
| 1577 | |
| 1578 | mkdir z && |
| 1579 | echo b >z/b && |
| 1580 | echo c >z/c && |
| 1581 | git add z && |
| 1582 | test_tick && |
| 1583 | git commit -m "O" && |
| 1584 | |
| 1585 | git branch O && |
| 1586 | git branch A && |
| 1587 | git branch B && |
| 1588 | |
| 1589 | git checkout A && |
| 1590 | test_tick && |
| 1591 | git commit --allow-empty -m "A" && |
| 1592 | |
| 1593 | git checkout B && |
| 1594 | git mv z y && |
| 1595 | echo d1 > y/d && |
| 1596 | mkdir z && |
| 1597 | echo d2 > z/d && |
| 1598 | git add y/d z/d && |
| 1599 | test_tick && |
| 1600 | git commit -m "B" |
| 1601 | ) |
| 1602 | } |
| 1603 | |
| 1604 | test_expect_success '6e: Add/add from one side' ' |
| 1605 | test_setup_6e && |
| 1606 | ( |
| 1607 | cd 6e && |
| 1608 | |
| 1609 | git checkout A^0 && |
| 1610 | |
| 1611 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 1612 | |
| 1613 | git ls-files -s >out && |
| 1614 | test_line_count = 4 out && |
| 1615 | git ls-files -u >out && |
| 1616 | test_line_count = 0 out && |
| 1617 | git ls-files -o >out && |
| 1618 | test_line_count = 1 out && |
| 1619 | |
| 1620 | git rev-parse >actual \ |
| 1621 | HEAD:y/b HEAD:y/c HEAD:y/d HEAD:z/d && |
| 1622 | git rev-parse >expect \ |
| 1623 | O:z/b O:z/c B:y/d B:z/d && |
| 1624 | test_cmp expect actual |
| 1625 | ) |
| 1626 | ' |
| 1627 | |
| 1628 | ########################################################################### |
| 1629 | # Rules suggested by section 6: |
| 1630 | # |
| 1631 | # Only apply implicit directory renames to directories if the other |
| 1632 | # side of history is the one doing the renaming. |
| 1633 | ########################################################################### |
| 1634 | |
| 1635 | |
| 1636 | ########################################################################### |
| 1637 | # SECTION 7: More involved Edge/Corner cases |
| 1638 | # |
| 1639 | # The ruleset we have generated in the above sections seems to provide |
| 1640 | # well-defined merges. But can we find edge/corner cases that either (a) |
| 1641 | # are harder for users to understand, or (b) have a resolution that is |
| 1642 | # non-intuitive or suboptimal? |
| 1643 | # |
| 1644 | # The testcases in this section dive into cases that I've tried to craft in |
| 1645 | # a way to find some that might be surprising to users or difficult for |
| 1646 | # them to understand (the next section will look at non-intuitive or |
| 1647 | # suboptimal merge results). Some of the testcases are similar to ones |
| 1648 | # from past sections, but have been simplified to try to highlight error |
| 1649 | # messages using a "modified" path (due to the directory rename). Are |
| 1650 | # users okay with these? |
| 1651 | # |
| 1652 | # In my opinion, testcases that are difficult to understand from this |
| 1653 | # section is due to difficulty in the testcase rather than the directory |
| 1654 | # renaming (similar to how t6042 and t6036 have difficult resolutions due |
| 1655 | # to the problem setup itself being complex). And I don't think the |
| 1656 | # error messages are a problem. |
| 1657 | # |
| 1658 | # On the other hand, the testcases in section 8 worry me slightly more... |
| 1659 | ########################################################################### |
| 1660 | |
| 1661 | # Testcase 7a, rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file |
| 1662 | # Commit O: z/{b,c} |
| 1663 | # Commit A: y/{b,c} |
| 1664 | # Commit B: w/b, x/c, z/d |
| 1665 | # Expected: y/d, CONFLICT(rename/rename for both z/b and z/c) |
| 1666 | # NOTE: There's a rename of z/ here, y/ has more renames, so z/d -> y/d. |
| 1667 | |
| 1668 | test_setup_7a () { |
| 1669 | git init 7a && |
| 1670 | ( |
| 1671 | cd 7a && |
| 1672 | |
| 1673 | mkdir z && |
| 1674 | echo b >z/b && |
| 1675 | echo c >z/c && |
| 1676 | git add z && |
| 1677 | test_tick && |
| 1678 | git commit -m "O" && |
| 1679 | |
| 1680 | git branch O && |
| 1681 | git branch A && |
| 1682 | git branch B && |
| 1683 | |
| 1684 | git checkout A && |
| 1685 | git mv z y && |
| 1686 | test_tick && |
| 1687 | git commit -m "A" && |
| 1688 | |
| 1689 | git checkout B && |
| 1690 | mkdir w && |
| 1691 | mkdir x && |
| 1692 | git mv z/b w/ && |
| 1693 | git mv z/c x/ && |
| 1694 | echo d > z/d && |
| 1695 | git add z/d && |
| 1696 | test_tick && |
| 1697 | git commit -m "B" |
| 1698 | ) |
| 1699 | } |
| 1700 | |
| 1701 | test_expect_success '7a: rename-dir vs. rename-dir (NOT split evenly) PLUS add-other-file' ' |
| 1702 | test_setup_7a && |
| 1703 | ( |
| 1704 | cd 7a && |
| 1705 | |
| 1706 | git checkout A^0 && |
| 1707 | |
| 1708 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1709 | test_grep "CONFLICT (rename/rename).*z/b.*y/b.*w/b" out && |
| 1710 | test_grep "CONFLICT (rename/rename).*z/c.*y/c.*x/c" out && |
| 1711 | |
| 1712 | git ls-files -s >out && |
| 1713 | test_line_count = 7 out && |
| 1714 | git ls-files -u >out && |
| 1715 | test_line_count = 6 out && |
| 1716 | git ls-files -o >out && |
| 1717 | test_line_count = 1 out && |
| 1718 | |
| 1719 | git rev-parse >actual \ |
| 1720 | :1:z/b :2:y/b :3:w/b :1:z/c :2:y/c :3:x/c :0:y/d && |
| 1721 | git rev-parse >expect \ |
| 1722 | O:z/b O:z/b O:z/b O:z/c O:z/c O:z/c B:z/d && |
| 1723 | test_cmp expect actual && |
| 1724 | |
| 1725 | git hash-object >actual \ |
| 1726 | y/b w/b y/c x/c && |
| 1727 | git rev-parse >expect \ |
| 1728 | O:z/b O:z/b O:z/c O:z/c && |
| 1729 | test_cmp expect actual |
| 1730 | ) |
| 1731 | ' |
| 1732 | |
| 1733 | # Testcase 7b, rename/rename(2to1), but only due to transitive rename |
| 1734 | # (Related to testcase 1d) |
| 1735 | # Commit O: z/{b,c}, x/d_1, w/d_2 |
| 1736 | # Commit A: y/{b,c,d_2}, x/d_1 |
| 1737 | # Commit B: z/{b,c,d_1}, w/d_2 |
| 1738 | # Expected: y/{b,c}, CONFLICT(rename/rename(2to1): x/d_1, w/d_2 -> y_d) |
| 1739 | |
| 1740 | test_setup_7b () { |
| 1741 | git init 7b && |
| 1742 | ( |
| 1743 | cd 7b && |
| 1744 | |
| 1745 | mkdir z && |
| 1746 | mkdir x && |
| 1747 | mkdir w && |
| 1748 | echo b >z/b && |
| 1749 | echo c >z/c && |
| 1750 | echo d1 > x/d && |
| 1751 | echo d2 > w/d && |
| 1752 | git add z x w && |
| 1753 | test_tick && |
| 1754 | git commit -m "O" && |
| 1755 | |
| 1756 | git branch O && |
| 1757 | git branch A && |
| 1758 | git branch B && |
| 1759 | |
| 1760 | git checkout A && |
| 1761 | git mv z y && |
| 1762 | git mv w/d y/ && |
| 1763 | test_tick && |
| 1764 | git commit -m "A" && |
| 1765 | |
| 1766 | git checkout B && |
| 1767 | git mv x/d z/ && |
| 1768 | rmdir x && |
| 1769 | test_tick && |
| 1770 | git commit -m "B" |
| 1771 | ) |
| 1772 | } |
| 1773 | |
| 1774 | test_expect_success '7b: rename/rename(2to1), but only due to transitive rename' ' |
| 1775 | test_setup_7b && |
| 1776 | ( |
| 1777 | cd 7b && |
| 1778 | |
| 1779 | git checkout A^0 && |
| 1780 | |
| 1781 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1782 | test_grep "CONFLICT (\(.*\)/\1)" out && |
| 1783 | |
| 1784 | git ls-files -s >out && |
| 1785 | test_line_count = 4 out && |
| 1786 | git ls-files -u >out && |
| 1787 | test_line_count = 2 out && |
| 1788 | git ls-files -o >out && |
| 1789 | test_line_count = 1 out && |
| 1790 | |
| 1791 | git rev-parse >actual \ |
| 1792 | :0:y/b :0:y/c :2:y/d :3:y/d && |
| 1793 | git rev-parse >expect \ |
| 1794 | O:z/b O:z/c O:w/d O:x/d && |
| 1795 | test_cmp expect actual && |
| 1796 | |
| 1797 | # Test that the two-way merge in y/d is as expected |
| 1798 | git cat-file -p :2:y/d >expect && |
| 1799 | git cat-file -p :3:y/d >other && |
| 1800 | >empty && |
| 1801 | test_must_fail git merge-file \ |
| 1802 | -L "HEAD:y/d" \ |
| 1803 | -L "" \ |
| 1804 | -L "B^0:z/d" \ |
| 1805 | expect empty other && |
| 1806 | test_cmp expect y/d |
| 1807 | ) |
| 1808 | ' |
| 1809 | |
| 1810 | # Testcase 7c, rename/rename(1to...2or3); transitive rename may add complexity |
| 1811 | # (Related to testcases 3b and 5c) |
| 1812 | # Commit O: z/{b,c}, x/d |
| 1813 | # Commit A: y/{b,c}, w/d |
| 1814 | # Commit B: z/{b,c,d} |
| 1815 | # Expected: y/{b,c}, CONFLICT(x/d -> w/d vs. y/d) |
| 1816 | # NOTE: z/ was renamed to y/ so we do want to report |
| 1817 | # neither CONFLICT(x/d -> w/d vs. z/d) |
| 1818 | # nor CONFLiCT x/d -> w/d vs. y/d vs. z/d) |
| 1819 | |
| 1820 | test_setup_7c () { |
| 1821 | git init 7c && |
| 1822 | ( |
| 1823 | cd 7c && |
| 1824 | |
| 1825 | mkdir z && |
| 1826 | echo b >z/b && |
| 1827 | echo c >z/c && |
| 1828 | mkdir x && |
| 1829 | echo d >x/d && |
| 1830 | git add z x && |
| 1831 | test_tick && |
| 1832 | git commit -m "O" && |
| 1833 | |
| 1834 | git branch O && |
| 1835 | git branch A && |
| 1836 | git branch B && |
| 1837 | |
| 1838 | git checkout A && |
| 1839 | git mv z y && |
| 1840 | git mv x w && |
| 1841 | test_tick && |
| 1842 | git commit -m "A" && |
| 1843 | |
| 1844 | git checkout B && |
| 1845 | git mv x/d z/ && |
| 1846 | rmdir x && |
| 1847 | test_tick && |
| 1848 | git commit -m "B" |
| 1849 | ) |
| 1850 | } |
| 1851 | |
| 1852 | test_expect_success '7c: rename/rename(1to...2or3); transitive rename may add complexity' ' |
| 1853 | test_setup_7c && |
| 1854 | ( |
| 1855 | cd 7c && |
| 1856 | |
| 1857 | git checkout A^0 && |
| 1858 | |
| 1859 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1860 | test_grep "CONFLICT (rename/rename).*x/d.*w/d.*y/d" out && |
| 1861 | |
| 1862 | git ls-files -s >out && |
| 1863 | test_line_count = 5 out && |
| 1864 | git ls-files -u >out && |
| 1865 | test_line_count = 3 out && |
| 1866 | git ls-files -o >out && |
| 1867 | test_line_count = 1 out && |
| 1868 | |
| 1869 | git rev-parse >actual \ |
| 1870 | :0:y/b :0:y/c :1:x/d :2:w/d :3:y/d && |
| 1871 | git rev-parse >expect \ |
| 1872 | O:z/b O:z/c O:x/d O:x/d O:x/d && |
| 1873 | test_cmp expect actual |
| 1874 | ) |
| 1875 | ' |
| 1876 | |
| 1877 | # Testcase 7d, transitive rename involved in rename/delete; how is it reported? |
| 1878 | # (Related somewhat to testcases 5b and 8d) |
| 1879 | # Commit O: z/{b,c}, x/d |
| 1880 | # Commit A: y/{b,c} |
| 1881 | # Commit B: z/{b,c,d} |
| 1882 | # Expected: y/{b,c}, CONFLICT(delete x/d vs rename to y/d) |
| 1883 | # NOTE: z->y so NOT CONFLICT(delete x/d vs rename to z/d) |
| 1884 | |
| 1885 | test_setup_7d () { |
| 1886 | git init 7d && |
| 1887 | ( |
| 1888 | cd 7d && |
| 1889 | |
| 1890 | mkdir z && |
| 1891 | echo b >z/b && |
| 1892 | echo c >z/c && |
| 1893 | mkdir x && |
| 1894 | echo d >x/d && |
| 1895 | git add z x && |
| 1896 | test_tick && |
| 1897 | git commit -m "O" && |
| 1898 | |
| 1899 | git branch O && |
| 1900 | git branch A && |
| 1901 | git branch B && |
| 1902 | |
| 1903 | git checkout A && |
| 1904 | git mv z y && |
| 1905 | git rm -rf x && |
| 1906 | test_tick && |
| 1907 | git commit -m "A" && |
| 1908 | |
| 1909 | git checkout B && |
| 1910 | git mv x/d z/ && |
| 1911 | rmdir x && |
| 1912 | test_tick && |
| 1913 | git commit -m "B" |
| 1914 | ) |
| 1915 | } |
| 1916 | |
| 1917 | test_expect_success '7d: transitive rename involved in rename/delete; how is it reported?' ' |
| 1918 | test_setup_7d && |
| 1919 | ( |
| 1920 | cd 7d && |
| 1921 | |
| 1922 | git checkout A^0 && |
| 1923 | |
| 1924 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 1925 | test_grep "CONFLICT (rename/delete).*x/d.*y/d" out && |
| 1926 | |
| 1927 | git ls-files -s >out && |
| 1928 | test_line_count = 4 out && |
| 1929 | git ls-files -u >out && |
| 1930 | test_line_count = 2 out && |
| 1931 | git ls-files -o >out && |
| 1932 | test_line_count = 1 out && |
| 1933 | |
| 1934 | git rev-parse >actual \ |
| 1935 | :0:y/b :0:y/c :1:y/d :3:y/d && |
| 1936 | git rev-parse >expect \ |
| 1937 | O:z/b O:z/c O:x/d O:x/d && |
| 1938 | test_cmp expect actual |
| 1939 | ) |
| 1940 | ' |
| 1941 | |
| 1942 | # Testcase 7e, transitive rename in rename/delete AND dirs in the way |
| 1943 | # (Very similar to 'both rename source and destination involved in D/F conflict' from t6022-merge-rename.sh) |
| 1944 | # (Also related to testcases 9c and 9d) |
| 1945 | # Commit O: z/{b,c}, x/d_1 |
| 1946 | # Commit A: y/{b,c,d/g}, x/d/f |
| 1947 | # Commit B: z/{b,c,d_1} |
| 1948 | # Expected: rename/delete(x/d_1->y/d_1 vs. None) + D/F conflict on y/d |
| 1949 | # y/{b,c,d/g}, y/d_1~B^0, x/d/f |
| 1950 | |
| 1951 | # NOTE: The main path of interest here is d_1 and where it ends up, but |
| 1952 | # this is actually a case that has two potential directory renames |
| 1953 | # involved and D/F conflict(s), so it makes sense to walk through |
| 1954 | # each step. |
| 1955 | # |
| 1956 | # Commit A renames z/ -> y/. Thus everything that B adds to z/ |
| 1957 | # should be instead moved to y/. This gives us the D/F conflict on |
| 1958 | # y/d because x/d_1 -> z/d_1 -> y/d_1 conflicts with y/d/g. |
| 1959 | # |
| 1960 | # Further, commit B renames x/ -> z/, thus everything A adds to x/ |
| 1961 | # should instead be moved to z/...BUT we removed z/ and renamed it |
| 1962 | # to y/, so maybe everything should move not from x/ to z/, but |
| 1963 | # from x/ to z/ to y/. Doing so might make sense from the logic so |
| 1964 | # far, but note that commit A had both an x/ and a y/; it did the |
| 1965 | # renaming of z/ to y/ and created x/d/f and it clearly made these |
| 1966 | # things separate, so it doesn't make much sense to push these |
| 1967 | # together. Doing so is what I'd call a doubly transitive rename; |
| 1968 | # see testcases 9c and 9d for further discussion of this issue and |
| 1969 | # how it's resolved. |
| 1970 | |
| 1971 | test_setup_7e () { |
| 1972 | git init 7e && |
| 1973 | ( |
| 1974 | cd 7e && |
| 1975 | |
| 1976 | mkdir z && |
| 1977 | echo b >z/b && |
| 1978 | echo c >z/c && |
| 1979 | mkdir x && |
| 1980 | echo d1 >x/d && |
| 1981 | git add z x && |
| 1982 | test_tick && |
| 1983 | git commit -m "O" && |
| 1984 | |
| 1985 | git branch O && |
| 1986 | git branch A && |
| 1987 | git branch B && |
| 1988 | |
| 1989 | git checkout A && |
| 1990 | git mv z y && |
| 1991 | git rm x/d && |
| 1992 | mkdir -p x/d && |
| 1993 | mkdir -p y/d && |
| 1994 | echo f >x/d/f && |
| 1995 | echo g >y/d/g && |
| 1996 | git add x/d/f y/d/g && |
| 1997 | test_tick && |
| 1998 | git commit -m "A" && |
| 1999 | |
| 2000 | git checkout B && |
| 2001 | git mv x/d z/ && |
| 2002 | rmdir x && |
| 2003 | test_tick && |
| 2004 | git commit -m "B" |
| 2005 | ) |
| 2006 | } |
| 2007 | |
| 2008 | test_expect_success '7e: transitive rename in rename/delete AND dirs in the way' ' |
| 2009 | test_setup_7e && |
| 2010 | ( |
| 2011 | cd 7e && |
| 2012 | |
| 2013 | git checkout A^0 && |
| 2014 | |
| 2015 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 2016 | test_grep "CONFLICT (rename/delete).*x/d.*y/d" out && |
| 2017 | |
| 2018 | git ls-files -s >out && |
| 2019 | test_line_count = 6 out && |
| 2020 | git ls-files -u >out && |
| 2021 | test_line_count = 2 out && |
| 2022 | git ls-files -o >out && |
| 2023 | test_line_count = 1 out && |
| 2024 | |
| 2025 | git rev-parse >actual \ |
| 2026 | :0:x/d/f :0:y/d/g :0:y/b :0:y/c :1:y/d~B^0 :3:y/d~B^0 && |
| 2027 | git rev-parse >expect \ |
| 2028 | A:x/d/f A:y/d/g O:z/b O:z/c O:x/d O:x/d && |
| 2029 | test_cmp expect actual && |
| 2030 | |
| 2031 | git hash-object y/d~B^0 >actual && |
| 2032 | git rev-parse O:x/d >expect && |
| 2033 | test_cmp expect actual |
| 2034 | ) |
| 2035 | ' |
| 2036 | |
| 2037 | ########################################################################### |
| 2038 | # SECTION 8: Suboptimal merges |
| 2039 | # |
| 2040 | # As alluded to in the last section, the ruleset we have built up for |
| 2041 | # detecting directory renames unfortunately has some special cases where it |
| 2042 | # results in slightly suboptimal or non-intuitive behavior. This section |
| 2043 | # explores these cases. |
| 2044 | # |
| 2045 | # To be fair, we already had non-intuitive or suboptimal behavior for most |
| 2046 | # of these cases in git before introducing implicit directory rename |
| 2047 | # detection, but it'd be nice if there was a modified ruleset out there |
| 2048 | # that handled these cases a bit better. |
| 2049 | ########################################################################### |
| 2050 | |
| 2051 | # Testcase 8a, Dual-directory rename, one into the others' way |
| 2052 | # Commit O. x/{a,b}, y/{c,d} |
| 2053 | # Commit A. x/{a,b,e}, y/{c,d,f} |
| 2054 | # Commit B. y/{a,b}, z/{c,d} |
| 2055 | # |
| 2056 | # Possible Resolutions: |
| 2057 | # w/o dir-rename detection: y/{a,b,f}, z/{c,d}, x/e |
| 2058 | # Currently expected: y/{a,b,e,f}, z/{c,d} |
| 2059 | # Optimal: y/{a,b,e}, z/{c,d,f} |
| 2060 | # |
| 2061 | # Note: Both x and y got renamed and it'd be nice to detect both, and we do |
| 2062 | # better with directory rename detection than git did without, but the |
| 2063 | # simple rule from section 5 prevents me from handling this as optimally as |
| 2064 | # we potentially could. |
| 2065 | |
| 2066 | test_setup_8a () { |
| 2067 | git init 8a && |
| 2068 | ( |
| 2069 | cd 8a && |
| 2070 | |
| 2071 | mkdir x && |
| 2072 | mkdir y && |
| 2073 | echo a >x/a && |
| 2074 | echo b >x/b && |
| 2075 | echo c >y/c && |
| 2076 | echo d >y/d && |
| 2077 | git add x y && |
| 2078 | test_tick && |
| 2079 | git commit -m "O" && |
| 2080 | |
| 2081 | git branch O && |
| 2082 | git branch A && |
| 2083 | git branch B && |
| 2084 | |
| 2085 | git checkout A && |
| 2086 | echo e >x/e && |
| 2087 | echo f >y/f && |
| 2088 | git add x/e y/f && |
| 2089 | test_tick && |
| 2090 | git commit -m "A" && |
| 2091 | |
| 2092 | git checkout B && |
| 2093 | git mv y z && |
| 2094 | git mv x y && |
| 2095 | test_tick && |
| 2096 | git commit -m "B" |
| 2097 | ) |
| 2098 | } |
| 2099 | |
| 2100 | test_expect_success '8a: Dual-directory rename, one into the others way' ' |
| 2101 | test_setup_8a && |
| 2102 | ( |
| 2103 | cd 8a && |
| 2104 | |
| 2105 | git checkout A^0 && |
| 2106 | |
| 2107 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 2108 | |
| 2109 | git ls-files -s >out && |
| 2110 | test_line_count = 6 out && |
| 2111 | git ls-files -u >out && |
| 2112 | test_line_count = 0 out && |
| 2113 | git ls-files -o >out && |
| 2114 | test_line_count = 1 out && |
| 2115 | |
| 2116 | git rev-parse >actual \ |
| 2117 | HEAD:y/a HEAD:y/b HEAD:y/e HEAD:y/f HEAD:z/c HEAD:z/d && |
| 2118 | git rev-parse >expect \ |
| 2119 | O:x/a O:x/b A:x/e A:y/f O:y/c O:y/d && |
| 2120 | test_cmp expect actual |
| 2121 | ) |
| 2122 | ' |
| 2123 | |
| 2124 | # Testcase 8b, Dual-directory rename, one into the others' way, with conflicting filenames |
| 2125 | # Commit O. x/{a_1,b_1}, y/{a_2,b_2} |
| 2126 | # Commit A. x/{a_1,b_1,e_1}, y/{a_2,b_2,e_2} |
| 2127 | # Commit B. y/{a_1,b_1}, z/{a_2,b_2} |
| 2128 | # |
| 2129 | # w/o dir-rename detection: y/{a_1,b_1,e_2}, z/{a_2,b_2}, x/e_1 |
| 2130 | # Currently expected: <same> |
| 2131 | # Scary: y/{a_1,b_1}, z/{a_2,b_2}, CONFLICT(add/add, e_1 vs. e_2) |
| 2132 | # Optimal: y/{a_1,b_1,e_1}, z/{a_2,b_2,e_2} |
| 2133 | # |
| 2134 | # Note: Very similar to 8a, except instead of 'e' and 'f' in directories x and |
| 2135 | # y, both are named 'e'. Without directory rename detection, neither file |
| 2136 | # moves directories. Implement directory rename detection suboptimally, and |
| 2137 | # you get an add/add conflict, but both files were added in commit A, so this |
| 2138 | # is an add/add conflict where one side of history added both files -- |
| 2139 | # something we can't represent in the index. Obviously, we'd prefer the last |
| 2140 | # resolution, but our previous rules are too coarse to allow it. Using both |
| 2141 | # the rules from section 4 and section 5 save us from the Scary resolution, |
| 2142 | # making us fall back to pre-directory-rename-detection behavior for both |
| 2143 | # e_1 and e_2. |
| 2144 | |
| 2145 | test_setup_8b () { |
| 2146 | git init 8b && |
| 2147 | ( |
| 2148 | cd 8b && |
| 2149 | |
| 2150 | mkdir x && |
| 2151 | mkdir y && |
| 2152 | echo a1 >x/a && |
| 2153 | echo b1 >x/b && |
| 2154 | echo a2 >y/a && |
| 2155 | echo b2 >y/b && |
| 2156 | git add x y && |
| 2157 | test_tick && |
| 2158 | git commit -m "O" && |
| 2159 | |
| 2160 | git branch O && |
| 2161 | git branch A && |
| 2162 | git branch B && |
| 2163 | |
| 2164 | git checkout A && |
| 2165 | echo e1 >x/e && |
| 2166 | echo e2 >y/e && |
| 2167 | git add x/e y/e && |
| 2168 | test_tick && |
| 2169 | git commit -m "A" && |
| 2170 | |
| 2171 | git checkout B && |
| 2172 | git mv y z && |
| 2173 | git mv x y && |
| 2174 | test_tick && |
| 2175 | git commit -m "B" |
| 2176 | ) |
| 2177 | } |
| 2178 | |
| 2179 | test_expect_success '8b: Dual-directory rename, one into the others way, with conflicting filenames' ' |
| 2180 | test_setup_8b && |
| 2181 | ( |
| 2182 | cd 8b && |
| 2183 | |
| 2184 | git checkout A^0 && |
| 2185 | |
| 2186 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 2187 | |
| 2188 | git ls-files -s >out && |
| 2189 | test_line_count = 6 out && |
| 2190 | git ls-files -u >out && |
| 2191 | test_line_count = 0 out && |
| 2192 | git ls-files -o >out && |
| 2193 | test_line_count = 1 out && |
| 2194 | |
| 2195 | git rev-parse >actual \ |
| 2196 | HEAD:y/a HEAD:y/b HEAD:z/a HEAD:z/b HEAD:x/e HEAD:y/e && |
| 2197 | git rev-parse >expect \ |
| 2198 | O:x/a O:x/b O:y/a O:y/b A:x/e A:y/e && |
| 2199 | test_cmp expect actual |
| 2200 | ) |
| 2201 | ' |
| 2202 | |
| 2203 | # Testcase 8c, modify/delete or rename+modify/delete? |
| 2204 | # (Related to testcases 5b, 8d, and 9h) |
| 2205 | # Commit O: z/{b,c,d} |
| 2206 | # Commit A: y/{b,c} |
| 2207 | # Commit B: z/{b,c,d_modified,e} |
| 2208 | # Expected: y/{b,c,e}, CONFLICT(modify/delete: on z/d) |
| 2209 | # |
| 2210 | # Note: It could easily be argued that the correct resolution here is |
| 2211 | # y/{b,c,e}, CONFLICT(rename/delete: z/d -> y/d vs deleted) |
| 2212 | # and that the modified version of d should be present in y/ after |
| 2213 | # the merge, just marked as conflicted. Indeed, I previously did |
| 2214 | # argue that. But applying directory renames to the side of |
| 2215 | # history where a file is merely modified results in spurious |
| 2216 | # rename/rename(1to2) conflicts -- see testcase 9h. See also |
| 2217 | # notes in 8d. |
| 2218 | |
| 2219 | test_setup_8c () { |
| 2220 | git init 8c && |
| 2221 | ( |
| 2222 | cd 8c && |
| 2223 | |
| 2224 | mkdir z && |
| 2225 | echo b >z/b && |
| 2226 | echo c >z/c && |
| 2227 | test_seq 1 10 >z/d && |
| 2228 | git add z && |
| 2229 | test_tick && |
| 2230 | git commit -m "O" && |
| 2231 | |
| 2232 | git branch O && |
| 2233 | git branch A && |
| 2234 | git branch B && |
| 2235 | |
| 2236 | git checkout A && |
| 2237 | git rm z/d && |
| 2238 | git mv z y && |
| 2239 | test_tick && |
| 2240 | git commit -m "A" && |
| 2241 | |
| 2242 | git checkout B && |
| 2243 | echo 11 >z/d && |
| 2244 | test_chmod +x z/d && |
| 2245 | echo e >z/e && |
| 2246 | git add z/d z/e && |
| 2247 | test_tick && |
| 2248 | git commit -m "B" |
| 2249 | ) |
| 2250 | } |
| 2251 | |
| 2252 | test_expect_success '8c: modify/delete or rename+modify/delete' ' |
| 2253 | test_setup_8c && |
| 2254 | ( |
| 2255 | cd 8c && |
| 2256 | |
| 2257 | git checkout A^0 && |
| 2258 | |
| 2259 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 2260 | test_grep "CONFLICT (modify/delete).* z/d" out && |
| 2261 | |
| 2262 | git ls-files -s >out && |
| 2263 | test_line_count = 5 out && |
| 2264 | git ls-files -u >out && |
| 2265 | test_line_count = 2 out && |
| 2266 | git ls-files -o >out && |
| 2267 | test_line_count = 1 out && |
| 2268 | |
| 2269 | git rev-parse >actual \ |
| 2270 | :0:y/b :0:y/c :0:y/e :1:z/d :3:z/d && |
| 2271 | git rev-parse >expect \ |
| 2272 | O:z/b O:z/c B:z/e O:z/d B:z/d && |
| 2273 | test_cmp expect actual && |
| 2274 | |
| 2275 | test_must_fail git rev-parse :2:z/d && |
| 2276 | git ls-files -s z/d | grep ^100755 && |
| 2277 | test_path_is_file z/d && |
| 2278 | test_path_is_missing y/d |
| 2279 | ) |
| 2280 | ' |
| 2281 | |
| 2282 | # Testcase 8d, rename/delete...or not? |
| 2283 | # (Related to testcase 5b; these may appear slightly inconsistent to users; |
| 2284 | # Also related to testcases 7d and 7e) |
| 2285 | # Commit O: z/{b,c,d} |
| 2286 | # Commit A: y/{b,c} |
| 2287 | # Commit B: z/{b,c,d,e} |
| 2288 | # Expected: y/{b,c,e} |
| 2289 | # |
| 2290 | # Note: It would also be somewhat reasonable to resolve this as |
| 2291 | # y/{b,c,e}, CONFLICT(rename/delete: x/d -> y/d or deleted) |
| 2292 | # |
| 2293 | # In this case, I'm leaning towards: commit A was the one that deleted z/d |
| 2294 | # and it did the rename of z to y, so the two "conflicts" (rename vs. |
| 2295 | # delete) are both coming from commit A, which is illogical. Conflicts |
| 2296 | # during merging are supposed to be about opposite sides doing things |
| 2297 | # differently. |
| 2298 | |
| 2299 | test_setup_8d () { |
| 2300 | git init 8d && |
| 2301 | ( |
| 2302 | cd 8d && |
| 2303 | |
| 2304 | mkdir z && |
| 2305 | echo b >z/b && |
| 2306 | echo c >z/c && |
| 2307 | test_seq 1 10 >z/d && |
| 2308 | git add z && |
| 2309 | test_tick && |
| 2310 | git commit -m "O" && |
| 2311 | |
| 2312 | git branch O && |
| 2313 | git branch A && |
| 2314 | git branch B && |
| 2315 | |
| 2316 | git checkout A && |
| 2317 | git rm z/d && |
| 2318 | git mv z y && |
| 2319 | test_tick && |
| 2320 | git commit -m "A" && |
| 2321 | |
| 2322 | git checkout B && |
| 2323 | echo e >z/e && |
| 2324 | git add z/e && |
| 2325 | test_tick && |
| 2326 | git commit -m "B" |
| 2327 | ) |
| 2328 | } |
| 2329 | |
| 2330 | test_expect_success '8d: rename/delete...or not?' ' |
| 2331 | test_setup_8d && |
| 2332 | ( |
| 2333 | cd 8d && |
| 2334 | |
| 2335 | git checkout A^0 && |
| 2336 | |
| 2337 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 2338 | |
| 2339 | git ls-files -s >out && |
| 2340 | test_line_count = 3 out && |
| 2341 | |
| 2342 | git rev-parse >actual \ |
| 2343 | HEAD:y/b HEAD:y/c HEAD:y/e && |
| 2344 | git rev-parse >expect \ |
| 2345 | O:z/b O:z/c B:z/e && |
| 2346 | test_cmp expect actual |
| 2347 | ) |
| 2348 | ' |
| 2349 | |
| 2350 | # Testcase 8e, Both sides rename, one side adds to original directory |
| 2351 | # Commit O: z/{b,c} |
| 2352 | # Commit A: y/{b,c} |
| 2353 | # Commit B: w/{b,c}, z/d |
| 2354 | # |
| 2355 | # Possible Resolutions: |
| 2356 | # if z not considered renamed: z/d, CONFLICT(z/b -> y/b vs. w/b), |
| 2357 | # CONFLICT(z/c -> y/c vs. w/c) |
| 2358 | # if z->y rename considered: y/d, CONFLICT(z/b -> y/b vs. w/b), |
| 2359 | # CONFLICT(z/c -> y/c vs. w/c) |
| 2360 | # Optimal: ?? |
| 2361 | # |
| 2362 | # Notes: In commit A, directory z got renamed to y. In commit B, directory z |
| 2363 | # did NOT get renamed; the directory is still present; instead it is |
| 2364 | # considered to have just renamed a subset of paths in directory z |
| 2365 | # elsewhere. This is much like testcase 6b2 (where commit B moves all |
| 2366 | # the original paths out of z/ but opted to keep d within z/). |
| 2367 | # |
| 2368 | # It was not clear in the past what should be done with this testcase; |
| 2369 | # in fact, I noted that I "just picked one" previously. However, |
| 2370 | # following the new logic for testcase 6b2, we should take the rename |
| 2371 | # and move z/d to y/d. |
| 2372 | # |
| 2373 | # 6b1, 6b2, and this case are definitely somewhat fuzzy in terms of |
| 2374 | # whether they are optimal for end users, but (a) the default for |
| 2375 | # directory rename detection is to mark these all as conflicts |
| 2376 | # anyway, (b) it feels like this is less prone to higher order corner |
| 2377 | # case confusion, and (c) the current algorithm requires less global |
| 2378 | # knowledge (i.e. less coupling in the algorithm between renames done |
| 2379 | # on both sides) which thus means users are better able to predict |
| 2380 | # the behavior, and predict it without computing as many details. |
| 2381 | |
| 2382 | test_setup_8e () { |
| 2383 | git init 8e && |
| 2384 | ( |
| 2385 | cd 8e && |
| 2386 | |
| 2387 | mkdir z && |
| 2388 | echo b >z/b && |
| 2389 | echo c >z/c && |
| 2390 | git add z && |
| 2391 | test_tick && |
| 2392 | git commit -m "O" && |
| 2393 | |
| 2394 | git branch O && |
| 2395 | git branch A && |
| 2396 | git branch B && |
| 2397 | |
| 2398 | git checkout A && |
| 2399 | git mv z y && |
| 2400 | test_tick && |
| 2401 | git commit -m "A" && |
| 2402 | |
| 2403 | git checkout B && |
| 2404 | git mv z w && |
| 2405 | mkdir z && |
| 2406 | echo d >z/d && |
| 2407 | git add z/d && |
| 2408 | test_tick && |
| 2409 | git commit -m "B" |
| 2410 | ) |
| 2411 | } |
| 2412 | |
| 2413 | test_expect_success '8e: Both sides rename, one side adds to original directory' ' |
| 2414 | test_setup_8e && |
| 2415 | ( |
| 2416 | cd 8e && |
| 2417 | |
| 2418 | git checkout A^0 && |
| 2419 | |
| 2420 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 2421 | test_grep CONFLICT.*rename/rename.*z/c.*y/c.*w/c out && |
| 2422 | test_grep CONFLICT.*rename/rename.*z/b.*y/b.*w/b out && |
| 2423 | |
| 2424 | git ls-files -s >out && |
| 2425 | test_line_count = 7 out && |
| 2426 | git ls-files -u >out && |
| 2427 | test_line_count = 6 out && |
| 2428 | git ls-files -o >out && |
| 2429 | test_line_count = 2 out && |
| 2430 | |
| 2431 | git rev-parse >actual \ |
| 2432 | :1:z/b :2:y/b :3:w/b :1:z/c :2:y/c :3:w/c :0:y/d && |
| 2433 | git rev-parse >expect \ |
| 2434 | O:z/b O:z/b O:z/b O:z/c O:z/c O:z/c B:z/d && |
| 2435 | test_cmp expect actual && |
| 2436 | |
| 2437 | git hash-object >actual \ |
| 2438 | y/b w/b y/c w/c && |
| 2439 | git rev-parse >expect \ |
| 2440 | O:z/b O:z/b O:z/c O:z/c && |
| 2441 | test_cmp expect actual && |
| 2442 | |
| 2443 | test_path_is_missing z/b && |
| 2444 | test_path_is_missing z/c |
| 2445 | ) |
| 2446 | ' |
| 2447 | |
| 2448 | ########################################################################### |
| 2449 | # SECTION 9: Other testcases |
| 2450 | # |
| 2451 | # This section consists of miscellaneous testcases I thought of during |
| 2452 | # the implementation which round out the testing. |
| 2453 | ########################################################################### |
| 2454 | |
| 2455 | # Testcase 9a, Inner renamed directory within outer renamed directory |
| 2456 | # (Related to testcase 1f) |
| 2457 | # Commit O: z/{b,c,d/{e,f,g}} |
| 2458 | # Commit A: y/{b,c}, x/w/{e,f,g} |
| 2459 | # Commit B: z/{b,c,d/{e,f,g,h},i} |
| 2460 | # Expected: y/{b,c,i}, x/w/{e,f,g,h} |
| 2461 | # NOTE: The only reason this one is interesting is because when a directory |
| 2462 | # is split into multiple other directories, we determine by the weight |
| 2463 | # of which one had the most paths going to it. A naive implementation |
| 2464 | # of that could take the new file in commit B at z/i to x/w/i or x/i. |
| 2465 | |
| 2466 | test_setup_9a () { |
| 2467 | git init 9a && |
| 2468 | ( |
| 2469 | cd 9a && |
| 2470 | |
| 2471 | mkdir -p z/d && |
| 2472 | echo b >z/b && |
| 2473 | echo c >z/c && |
| 2474 | echo e >z/d/e && |
| 2475 | echo f >z/d/f && |
| 2476 | echo g >z/d/g && |
| 2477 | git add z && |
| 2478 | test_tick && |
| 2479 | git commit -m "O" && |
| 2480 | |
| 2481 | git branch O && |
| 2482 | git branch A && |
| 2483 | git branch B && |
| 2484 | |
| 2485 | git checkout A && |
| 2486 | mkdir x && |
| 2487 | git mv z/d x/w && |
| 2488 | git mv z y && |
| 2489 | test_tick && |
| 2490 | git commit -m "A" && |
| 2491 | |
| 2492 | git checkout B && |
| 2493 | echo h >z/d/h && |
| 2494 | echo i >z/i && |
| 2495 | git add z && |
| 2496 | test_tick && |
| 2497 | git commit -m "B" |
| 2498 | ) |
| 2499 | } |
| 2500 | |
| 2501 | test_expect_success '9a: Inner renamed directory within outer renamed directory' ' |
| 2502 | test_setup_9a && |
| 2503 | ( |
| 2504 | cd 9a && |
| 2505 | |
| 2506 | git checkout A^0 && |
| 2507 | |
| 2508 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 2509 | |
| 2510 | git ls-files -s >out && |
| 2511 | test_line_count = 7 out && |
| 2512 | git ls-files -u >out && |
| 2513 | test_line_count = 0 out && |
| 2514 | git ls-files -o >out && |
| 2515 | test_line_count = 1 out && |
| 2516 | |
| 2517 | git rev-parse >actual \ |
| 2518 | HEAD:y/b HEAD:y/c HEAD:y/i && |
| 2519 | git rev-parse >expect \ |
| 2520 | O:z/b O:z/c B:z/i && |
| 2521 | test_cmp expect actual && |
| 2522 | |
| 2523 | git rev-parse >actual \ |
| 2524 | HEAD:x/w/e HEAD:x/w/f HEAD:x/w/g HEAD:x/w/h && |
| 2525 | git rev-parse >expect \ |
| 2526 | O:z/d/e O:z/d/f O:z/d/g B:z/d/h && |
| 2527 | test_cmp expect actual |
| 2528 | ) |
| 2529 | ' |
| 2530 | |
| 2531 | # Testcase 9b, Transitive rename with content merge |
| 2532 | # (Related to testcase 1c) |
| 2533 | # Commit O: z/{b,c}, x/d_1 |
| 2534 | # Commit A: y/{b,c}, x/d_2 |
| 2535 | # Commit B: z/{b,c,d_3} |
| 2536 | # Expected: y/{b,c,d_merged} |
| 2537 | |
| 2538 | test_setup_9b () { |
| 2539 | git init 9b && |
| 2540 | ( |
| 2541 | cd 9b && |
| 2542 | |
| 2543 | mkdir z && |
| 2544 | echo b >z/b && |
| 2545 | echo c >z/c && |
| 2546 | mkdir x && |
| 2547 | test_seq 1 10 >x/d && |
| 2548 | git add z x && |
| 2549 | test_tick && |
| 2550 | git commit -m "O" && |
| 2551 | |
| 2552 | git branch O && |
| 2553 | git branch A && |
| 2554 | git branch B && |
| 2555 | |
| 2556 | git checkout A && |
| 2557 | git mv z y && |
| 2558 | test_seq 1 11 >x/d && |
| 2559 | git add x/d && |
| 2560 | test_tick && |
| 2561 | git commit -m "A" && |
| 2562 | |
| 2563 | git checkout B && |
| 2564 | test_seq 0 10 >x/d && |
| 2565 | git mv x/d z/d && |
| 2566 | git add z/d && |
| 2567 | test_tick && |
| 2568 | git commit -m "B" |
| 2569 | ) |
| 2570 | } |
| 2571 | |
| 2572 | test_expect_success '9b: Transitive rename with content merge' ' |
| 2573 | test_setup_9b && |
| 2574 | ( |
| 2575 | cd 9b && |
| 2576 | |
| 2577 | git checkout A^0 && |
| 2578 | |
| 2579 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 2580 | |
| 2581 | git ls-files -s >out && |
| 2582 | test_line_count = 3 out && |
| 2583 | |
| 2584 | test_seq 0 11 >expected && |
| 2585 | test_cmp expected y/d && |
| 2586 | git add expected && |
| 2587 | git rev-parse >actual \ |
| 2588 | HEAD:y/b HEAD:y/c HEAD:y/d && |
| 2589 | git rev-parse >expect \ |
| 2590 | O:z/b O:z/c :0:expected && |
| 2591 | test_cmp expect actual && |
| 2592 | test_must_fail git rev-parse HEAD:x/d && |
| 2593 | test_must_fail git rev-parse HEAD:z/d && |
| 2594 | test_path_is_missing z/d && |
| 2595 | |
| 2596 | test $(git rev-parse HEAD:y/d) != $(git rev-parse O:x/d) && |
| 2597 | test $(git rev-parse HEAD:y/d) != $(git rev-parse A:x/d) && |
| 2598 | test $(git rev-parse HEAD:y/d) != $(git rev-parse B:z/d) |
| 2599 | ) |
| 2600 | ' |
| 2601 | |
| 2602 | # Testcase 9c, Doubly transitive rename? |
| 2603 | # (Related to testcase 1c, 7e, and 9d) |
| 2604 | # Commit O: z/{b,c}, x/{d,e}, w/f |
| 2605 | # Commit A: y/{b,c}, x/{d,e,f,g} |
| 2606 | # Commit B: z/{b,c,d,e}, w/f |
| 2607 | # Expected: y/{b,c,d,e}, x/{f,g} |
| 2608 | # |
| 2609 | # NOTE: x/f and x/g may be slightly confusing here. The rename from w/f to |
| 2610 | # x/f is clear. Let's look beyond that. Here's the logic: |
| 2611 | # Commit B renamed x/ -> z/ |
| 2612 | # Commit A renamed z/ -> y/ |
| 2613 | # So, we could possibly further rename x/f to z/f to y/f, a doubly |
| 2614 | # transient rename. However, where does it end? We can chain these |
| 2615 | # indefinitely (see testcase 9d). What if there is a D/F conflict |
| 2616 | # at z/f/ or y/f/? Or just another file conflict at one of those |
| 2617 | # paths? In the case of an N-long chain of transient renamings, |
| 2618 | # where do we "abort" the rename at? Can the user make sense of |
| 2619 | # the resulting conflict and resolve it? |
| 2620 | # |
| 2621 | # To avoid this confusion I use the simple rule that if the other side |
| 2622 | # of history did a directory rename to a path that your side renamed |
| 2623 | # away, then ignore that particular rename from the other side of |
| 2624 | # history for any implicit directory renames. |
| 2625 | |
| 2626 | test_setup_9c () { |
| 2627 | git init 9c && |
| 2628 | ( |
| 2629 | cd 9c && |
| 2630 | |
| 2631 | mkdir z && |
| 2632 | echo b >z/b && |
| 2633 | echo c >z/c && |
| 2634 | mkdir x && |
| 2635 | echo d >x/d && |
| 2636 | echo e >x/e && |
| 2637 | mkdir w && |
| 2638 | echo f >w/f && |
| 2639 | git add z x w && |
| 2640 | test_tick && |
| 2641 | git commit -m "O" && |
| 2642 | |
| 2643 | git branch O && |
| 2644 | git branch A && |
| 2645 | git branch B && |
| 2646 | |
| 2647 | git checkout A && |
| 2648 | git mv z y && |
| 2649 | git mv w/f x/ && |
| 2650 | echo g >x/g && |
| 2651 | git add x/g && |
| 2652 | test_tick && |
| 2653 | git commit -m "A" && |
| 2654 | |
| 2655 | git checkout B && |
| 2656 | git mv x/d z/d && |
| 2657 | git mv x/e z/e && |
| 2658 | test_tick && |
| 2659 | git commit -m "B" |
| 2660 | ) |
| 2661 | } |
| 2662 | |
| 2663 | test_expect_success '9c: Doubly transitive rename?' ' |
| 2664 | test_setup_9c && |
| 2665 | ( |
| 2666 | cd 9c && |
| 2667 | |
| 2668 | git checkout A^0 && |
| 2669 | |
| 2670 | git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 2671 | test_grep "WARNING: Avoiding applying x -> z rename to x/f" out && |
| 2672 | |
| 2673 | git ls-files -s >out && |
| 2674 | test_line_count = 6 out && |
| 2675 | git ls-files -o >out && |
| 2676 | test_line_count = 1 out && |
| 2677 | |
| 2678 | git rev-parse >actual \ |
| 2679 | HEAD:y/b HEAD:y/c HEAD:y/d HEAD:y/e HEAD:x/f HEAD:x/g && |
| 2680 | git rev-parse >expect \ |
| 2681 | O:z/b O:z/c O:x/d O:x/e O:w/f A:x/g && |
| 2682 | test_cmp expect actual |
| 2683 | ) |
| 2684 | ' |
| 2685 | |
| 2686 | # Testcase 9d, N-fold transitive rename? |
| 2687 | # (Related to testcase 9c...and 1c and 7e) |
| 2688 | # Commit O: z/a, y/b, x/c, w/d, v/e, u/f |
| 2689 | # Commit A: y/{a,b}, w/{c,d}, u/{e,f} |
| 2690 | # Commit B: z/{a,t}, x/{b,c}, v/{d,e}, u/f |
| 2691 | # Expected: <see NOTE first> |
| 2692 | # |
| 2693 | # NOTE: z/ -> y/ (in commit A) |
| 2694 | # y/ -> x/ (in commit B) |
| 2695 | # x/ -> w/ (in commit A) |
| 2696 | # w/ -> v/ (in commit B) |
| 2697 | # v/ -> u/ (in commit A) |
| 2698 | # So, if we add a file to z, say z/t, where should it end up? In u? |
| 2699 | # What if there's another file or directory named 't' in one of the |
| 2700 | # intervening directories and/or in u itself? Also, shouldn't the |
| 2701 | # same logic that places 't' in u/ also move ALL other files to u/? |
| 2702 | # What if there are file or directory conflicts in any of them? If |
| 2703 | # we attempted to do N-way (N-fold? N-ary? N-uple?) transitive renames |
| 2704 | # like this, would the user have any hope of understanding any |
| 2705 | # conflicts or how their working tree ended up? I think not, so I'm |
| 2706 | # ruling out N-ary transitive renames for N>1. |
| 2707 | # |
| 2708 | # Therefore our expected result is: |
| 2709 | # z/t, y/a, x/b, w/c, u/d, u/e, u/f |
| 2710 | # The reason that v/d DOES get transitively renamed to u/d is that u/ isn't |
| 2711 | # renamed somewhere. A slightly sub-optimal result, but it uses fairly |
| 2712 | # simple rules that are consistent with what we need for all the other |
| 2713 | # testcases and simplifies things for the user. |
| 2714 | |
| 2715 | test_setup_9d () { |
| 2716 | git init 9d && |
| 2717 | ( |
| 2718 | cd 9d && |
| 2719 | |
| 2720 | mkdir z y x w v u && |
| 2721 | echo a >z/a && |
| 2722 | echo b >y/b && |
| 2723 | echo c >x/c && |
| 2724 | echo d >w/d && |
| 2725 | echo e >v/e && |
| 2726 | echo f >u/f && |
| 2727 | git add z y x w v u && |
| 2728 | test_tick && |
| 2729 | git commit -m "O" && |
| 2730 | |
| 2731 | git branch O && |
| 2732 | git branch A && |
| 2733 | git branch B && |
| 2734 | |
| 2735 | git checkout A && |
| 2736 | git mv z/a y/ && |
| 2737 | git mv x/c w/ && |
| 2738 | git mv v/e u/ && |
| 2739 | test_tick && |
| 2740 | git commit -m "A" && |
| 2741 | |
| 2742 | git checkout B && |
| 2743 | echo t >z/t && |
| 2744 | git mv y/b x/ && |
| 2745 | git mv w/d v/ && |
| 2746 | git add z/t && |
| 2747 | test_tick && |
| 2748 | git commit -m "B" |
| 2749 | ) |
| 2750 | } |
| 2751 | |
| 2752 | test_expect_success '9d: N-way transitive rename?' ' |
| 2753 | test_setup_9d && |
| 2754 | ( |
| 2755 | cd 9d && |
| 2756 | |
| 2757 | git checkout A^0 && |
| 2758 | |
| 2759 | git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 2760 | test_grep "WARNING: Avoiding applying z -> y rename to z/t" out && |
| 2761 | test_grep "WARNING: Avoiding applying y -> x rename to y/a" out && |
| 2762 | test_grep "WARNING: Avoiding applying x -> w rename to x/b" out && |
| 2763 | test_grep "WARNING: Avoiding applying w -> v rename to w/c" out && |
| 2764 | |
| 2765 | git ls-files -s >out && |
| 2766 | test_line_count = 7 out && |
| 2767 | git ls-files -o >out && |
| 2768 | test_line_count = 1 out && |
| 2769 | |
| 2770 | git rev-parse >actual \ |
| 2771 | HEAD:z/t \ |
| 2772 | HEAD:y/a HEAD:x/b HEAD:w/c \ |
| 2773 | HEAD:u/d HEAD:u/e HEAD:u/f && |
| 2774 | git rev-parse >expect \ |
| 2775 | B:z/t \ |
| 2776 | O:z/a O:y/b O:x/c \ |
| 2777 | O:w/d O:v/e A:u/f && |
| 2778 | test_cmp expect actual |
| 2779 | ) |
| 2780 | ' |
| 2781 | |
| 2782 | # Testcase 9e, N-to-1 whammo |
| 2783 | # (Related to testcase 9c...and 1c and 7e) |
| 2784 | # Commit O: dir1/{a,b}, dir2/{d,e}, dir3/{g,h}, dirN/{j,k} |
| 2785 | # Commit A: dir1/{a,b,c,yo}, dir2/{d,e,f,yo}, dir3/{g,h,i,yo}, dirN/{j,k,l,yo} |
| 2786 | # Commit B: combined/{a,b,d,e,g,h,j,k} |
| 2787 | # Expected: combined/{a,b,c,d,e,f,g,h,i,j,k,l}, CONFLICT(Nto1) warnings, |
| 2788 | # dir1/yo, dir2/yo, dir3/yo, dirN/yo |
| 2789 | |
| 2790 | test_setup_9e () { |
| 2791 | git init 9e && |
| 2792 | ( |
| 2793 | cd 9e && |
| 2794 | |
| 2795 | mkdir dir1 dir2 dir3 dirN && |
| 2796 | echo a >dir1/a && |
| 2797 | echo b >dir1/b && |
| 2798 | echo d >dir2/d && |
| 2799 | echo e >dir2/e && |
| 2800 | echo g >dir3/g && |
| 2801 | echo h >dir3/h && |
| 2802 | echo j >dirN/j && |
| 2803 | echo k >dirN/k && |
| 2804 | git add dir* && |
| 2805 | test_tick && |
| 2806 | git commit -m "O" && |
| 2807 | |
| 2808 | git branch O && |
| 2809 | git branch A && |
| 2810 | git branch B && |
| 2811 | |
| 2812 | git checkout A && |
| 2813 | echo c >dir1/c && |
| 2814 | echo yo >dir1/yo && |
| 2815 | echo f >dir2/f && |
| 2816 | echo yo >dir2/yo && |
| 2817 | echo i >dir3/i && |
| 2818 | echo yo >dir3/yo && |
| 2819 | echo l >dirN/l && |
| 2820 | echo yo >dirN/yo && |
| 2821 | git add dir* && |
| 2822 | test_tick && |
| 2823 | git commit -m "A" && |
| 2824 | |
| 2825 | git checkout B && |
| 2826 | git mv dir1 combined && |
| 2827 | git mv dir2/* combined/ && |
| 2828 | git mv dir3/* combined/ && |
| 2829 | git mv dirN/* combined/ && |
| 2830 | test_tick && |
| 2831 | git commit -m "B" |
| 2832 | ) |
| 2833 | } |
| 2834 | |
| 2835 | test_expect_success '9e: N-to-1 whammo' ' |
| 2836 | test_setup_9e && |
| 2837 | ( |
| 2838 | cd 9e && |
| 2839 | |
| 2840 | git checkout A^0 && |
| 2841 | |
| 2842 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out && |
| 2843 | grep "CONFLICT (implicit dir rename): Cannot map more than one path to combined/yo" out >error_line && |
| 2844 | test_grep -q dir1/yo error_line && |
| 2845 | test_grep -q dir2/yo error_line && |
| 2846 | test_grep -q dir3/yo error_line && |
| 2847 | test_grep -q dirN/yo error_line && |
| 2848 | |
| 2849 | git ls-files -s >out && |
| 2850 | test_line_count = 16 out && |
| 2851 | git ls-files -u >out && |
| 2852 | test_line_count = 0 out && |
| 2853 | git ls-files -o >out && |
| 2854 | test_line_count = 2 out && |
| 2855 | |
| 2856 | git rev-parse >actual \ |
| 2857 | :0:combined/a :0:combined/b :0:combined/c \ |
| 2858 | :0:combined/d :0:combined/e :0:combined/f \ |
| 2859 | :0:combined/g :0:combined/h :0:combined/i \ |
| 2860 | :0:combined/j :0:combined/k :0:combined/l && |
| 2861 | git rev-parse >expect \ |
| 2862 | O:dir1/a O:dir1/b A:dir1/c \ |
| 2863 | O:dir2/d O:dir2/e A:dir2/f \ |
| 2864 | O:dir3/g O:dir3/h A:dir3/i \ |
| 2865 | O:dirN/j O:dirN/k A:dirN/l && |
| 2866 | test_cmp expect actual && |
| 2867 | |
| 2868 | git rev-parse >actual \ |
| 2869 | :0:dir1/yo :0:dir2/yo :0:dir3/yo :0:dirN/yo && |
| 2870 | git rev-parse >expect \ |
| 2871 | A:dir1/yo A:dir2/yo A:dir3/yo A:dirN/yo && |
| 2872 | test_cmp expect actual |
| 2873 | ) |
| 2874 | ' |
| 2875 | |
| 2876 | # Testcase 9f, Renamed directory that only contained immediate subdirs |
| 2877 | # (Related to testcases 1e & 9g) |
| 2878 | # Commit O: goal/{a,b}/$more_files |
| 2879 | # Commit A: priority/{a,b}/$more_files |
| 2880 | # Commit B: goal/{a,b}/$more_files, goal/c |
| 2881 | # Expected: priority/{a,b}/$more_files, priority/c |
| 2882 | |
| 2883 | test_setup_9f () { |
| 2884 | git init 9f && |
| 2885 | ( |
| 2886 | cd 9f && |
| 2887 | |
| 2888 | mkdir -p goal/a && |
| 2889 | mkdir -p goal/b && |
| 2890 | echo foo >goal/a/foo && |
| 2891 | echo bar >goal/b/bar && |
| 2892 | echo baz >goal/b/baz && |
| 2893 | git add goal && |
| 2894 | test_tick && |
| 2895 | git commit -m "O" && |
| 2896 | |
| 2897 | git branch O && |
| 2898 | git branch A && |
| 2899 | git branch B && |
| 2900 | |
| 2901 | git checkout A && |
| 2902 | git mv goal/ priority && |
| 2903 | test_tick && |
| 2904 | git commit -m "A" && |
| 2905 | |
| 2906 | git checkout B && |
| 2907 | echo c >goal/c && |
| 2908 | git add goal/c && |
| 2909 | test_tick && |
| 2910 | git commit -m "B" |
| 2911 | ) |
| 2912 | } |
| 2913 | |
| 2914 | test_expect_success '9f: Renamed directory that only contained immediate subdirs' ' |
| 2915 | test_setup_9f && |
| 2916 | ( |
| 2917 | cd 9f && |
| 2918 | |
| 2919 | git checkout A^0 && |
| 2920 | |
| 2921 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 2922 | |
| 2923 | git ls-files -s >out && |
| 2924 | test_line_count = 4 out && |
| 2925 | |
| 2926 | git rev-parse >actual \ |
| 2927 | HEAD:priority/a/foo \ |
| 2928 | HEAD:priority/b/bar \ |
| 2929 | HEAD:priority/b/baz \ |
| 2930 | HEAD:priority/c && |
| 2931 | git rev-parse >expect \ |
| 2932 | O:goal/a/foo \ |
| 2933 | O:goal/b/bar \ |
| 2934 | O:goal/b/baz \ |
| 2935 | B:goal/c && |
| 2936 | test_cmp expect actual && |
| 2937 | test_must_fail git rev-parse HEAD:goal/c |
| 2938 | ) |
| 2939 | ' |
| 2940 | |
| 2941 | # Testcase 9g, Renamed directory that only contained immediate subdirs, immediate subdirs renamed |
| 2942 | # (Related to testcases 1e & 9f) |
| 2943 | # Commit O: goal/{a,b}/$more_files |
| 2944 | # Commit A: priority/{alpha,bravo}/$more_files |
| 2945 | # Commit B: goal/{a,b}/$more_files, goal/c |
| 2946 | # Expected: priority/{alpha,bravo}/$more_files, priority/c |
| 2947 | # We currently fail this test because the directory renames we detect are |
| 2948 | # goal/a/ -> priority/alpha/ |
| 2949 | # goal/b/ -> priority/bravo/ |
| 2950 | # We do not detect |
| 2951 | # goal/ -> priority/ |
| 2952 | # because of no files found within goal/, and the fact that "a" != "alpha" |
| 2953 | # and "b" != "bravo". But I'm not sure it's really a failure given that |
| 2954 | # viewpoint... |
| 2955 | |
| 2956 | test_setup_9g () { |
| 2957 | git init 9g && |
| 2958 | ( |
| 2959 | cd 9g && |
| 2960 | |
| 2961 | mkdir -p goal/a && |
| 2962 | mkdir -p goal/b && |
| 2963 | echo foo >goal/a/foo && |
| 2964 | echo bar >goal/b/bar && |
| 2965 | echo baz >goal/b/baz && |
| 2966 | git add goal && |
| 2967 | test_tick && |
| 2968 | git commit -m "O" && |
| 2969 | |
| 2970 | git branch O && |
| 2971 | git branch A && |
| 2972 | git branch B && |
| 2973 | |
| 2974 | git checkout A && |
| 2975 | mkdir priority && |
| 2976 | git mv goal/a/ priority/alpha && |
| 2977 | git mv goal/b/ priority/beta && |
| 2978 | rmdir goal/ && |
| 2979 | test_tick && |
| 2980 | git commit -m "A" && |
| 2981 | |
| 2982 | git checkout B && |
| 2983 | echo c >goal/c && |
| 2984 | git add goal/c && |
| 2985 | test_tick && |
| 2986 | git commit -m "B" |
| 2987 | ) |
| 2988 | } |
| 2989 | |
| 2990 | test_expect_failure '9g: Renamed directory that only contained immediate subdirs, immediate subdirs renamed' ' |
| 2991 | test_setup_9g && |
| 2992 | ( |
| 2993 | cd 9g && |
| 2994 | |
| 2995 | git checkout A^0 && |
| 2996 | |
| 2997 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 2998 | |
| 2999 | git ls-files -s >out && |
| 3000 | test_line_count = 4 out && |
| 3001 | |
| 3002 | git rev-parse >actual \ |
| 3003 | HEAD:priority/alpha/foo \ |
| 3004 | HEAD:priority/beta/bar \ |
| 3005 | HEAD:priority/beta/baz \ |
| 3006 | HEAD:priority/c && |
| 3007 | git rev-parse >expect \ |
| 3008 | O:goal/a/foo \ |
| 3009 | O:goal/b/bar \ |
| 3010 | O:goal/b/baz \ |
| 3011 | B:goal/c && |
| 3012 | test_cmp expect actual && |
| 3013 | test_must_fail git rev-parse HEAD:goal/c |
| 3014 | ) |
| 3015 | ' |
| 3016 | |
| 3017 | # Testcase 9h, Avoid implicit rename if involved as source on other side |
| 3018 | # (Extremely closely related to testcase 3a) |
| 3019 | # Commit O: z/{b,c,d_1} |
| 3020 | # Commit A: z/{b,c,d_2} |
| 3021 | # Commit B: y/{b,c}, x/d_1 |
| 3022 | # Expected: y/{b,c}, x/d_2 |
| 3023 | # NOTE: If we applied the z/ -> y/ rename to z/d, then we'd end up with |
| 3024 | # a rename/rename(1to2) conflict (z/d -> y/d vs. x/d) |
| 3025 | test_setup_9h () { |
| 3026 | git init 9h && |
| 3027 | ( |
| 3028 | cd 9h && |
| 3029 | |
| 3030 | mkdir z && |
| 3031 | echo b >z/b && |
| 3032 | echo c >z/c && |
| 3033 | printf "1\n2\n3\n4\n5\n6\n7\n8\nd\n" >z/d && |
| 3034 | git add z && |
| 3035 | test_tick && |
| 3036 | git commit -m "O" && |
| 3037 | |
| 3038 | git branch O && |
| 3039 | git branch A && |
| 3040 | git branch B && |
| 3041 | |
| 3042 | git checkout A && |
| 3043 | test_tick && |
| 3044 | echo more >>z/d && |
| 3045 | git add z/d && |
| 3046 | git commit -m "A" && |
| 3047 | |
| 3048 | git checkout B && |
| 3049 | mkdir y && |
| 3050 | mkdir x && |
| 3051 | git mv z/b y/ && |
| 3052 | git mv z/c y/ && |
| 3053 | git mv z/d x/ && |
| 3054 | rmdir z && |
| 3055 | test_tick && |
| 3056 | git commit -m "B" |
| 3057 | ) |
| 3058 | } |
| 3059 | |
| 3060 | test_expect_success '9h: Avoid dir rename on merely modified path' ' |
| 3061 | test_setup_9h && |
| 3062 | ( |
| 3063 | cd 9h && |
| 3064 | |
| 3065 | git checkout A^0 && |
| 3066 | |
| 3067 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 3068 | |
| 3069 | git ls-files -s >out && |
| 3070 | test_line_count = 3 out && |
| 3071 | |
| 3072 | git rev-parse >actual \ |
| 3073 | HEAD:y/b HEAD:y/c HEAD:x/d && |
| 3074 | git rev-parse >expect \ |
| 3075 | O:z/b O:z/c A:z/d && |
| 3076 | test_cmp expect actual |
| 3077 | ) |
| 3078 | ' |
| 3079 | |
| 3080 | ########################################################################### |
| 3081 | # Rules suggested by section 9: |
| 3082 | # |
| 3083 | # If the other side of history did a directory rename to a path that your |
| 3084 | # side renamed away, then ignore that particular rename from the other |
| 3085 | # side of history for any implicit directory renames. |
| 3086 | ########################################################################### |
| 3087 | |
| 3088 | ########################################################################### |
| 3089 | # SECTION 10: Handling untracked files |
| 3090 | # |
| 3091 | # unpack_trees(), upon which the recursive merge algorithm is based, aborts |
| 3092 | # the operation if untracked or dirty files would be deleted or overwritten |
| 3093 | # by the merge. Unfortunately, unpack_trees() does not understand renames, |
| 3094 | # and if it doesn't abort, then it muddies up the working directory before |
| 3095 | # we even get to the point of detecting renames, so we need some special |
| 3096 | # handling, at least in the case of directory renames. |
| 3097 | ########################################################################### |
| 3098 | |
| 3099 | # Testcase 10a, Overwrite untracked: normal rename/delete |
| 3100 | # Commit O: z/{b,c_1} |
| 3101 | # Commit A: z/b + untracked z/c + untracked z/d |
| 3102 | # Commit B: z/{b,d_1} |
| 3103 | # Expected: Aborted Merge + |
| 3104 | # ERROR_MSG(untracked working tree files would be overwritten by merge) |
| 3105 | |
| 3106 | test_setup_10a () { |
| 3107 | git init 10a && |
| 3108 | ( |
| 3109 | cd 10a && |
| 3110 | |
| 3111 | mkdir z && |
| 3112 | echo b >z/b && |
| 3113 | echo c >z/c && |
| 3114 | git add z && |
| 3115 | test_tick && |
| 3116 | git commit -m "O" && |
| 3117 | |
| 3118 | git branch O && |
| 3119 | git branch A && |
| 3120 | git branch B && |
| 3121 | |
| 3122 | git checkout A && |
| 3123 | git rm z/c && |
| 3124 | test_tick && |
| 3125 | git commit -m "A" && |
| 3126 | |
| 3127 | git checkout B && |
| 3128 | git mv z/c z/d && |
| 3129 | test_tick && |
| 3130 | git commit -m "B" |
| 3131 | ) |
| 3132 | } |
| 3133 | |
| 3134 | test_expect_success '10a: Overwrite untracked with normal rename/delete' ' |
| 3135 | test_setup_10a && |
| 3136 | ( |
| 3137 | cd 10a && |
| 3138 | |
| 3139 | git checkout A^0 && |
| 3140 | echo very >z/c && |
| 3141 | echo important >z/d && |
| 3142 | |
| 3143 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3144 | test_path_is_missing .git/MERGE_HEAD && |
| 3145 | test_grep "The following untracked working tree files would be overwritten by merge" err && |
| 3146 | |
| 3147 | git ls-files -s >out && |
| 3148 | test_line_count = 1 out && |
| 3149 | git ls-files -o >out && |
| 3150 | test_line_count = 4 out && |
| 3151 | |
| 3152 | echo very >expect && |
| 3153 | test_cmp expect z/c && |
| 3154 | |
| 3155 | echo important >expect && |
| 3156 | test_cmp expect z/d && |
| 3157 | |
| 3158 | git rev-parse HEAD:z/b >actual && |
| 3159 | git rev-parse O:z/b >expect && |
| 3160 | test_cmp expect actual |
| 3161 | ) |
| 3162 | ' |
| 3163 | |
| 3164 | # Testcase 10b, Overwrite untracked: dir rename + delete |
| 3165 | # Commit O: z/{b,c_1} |
| 3166 | # Commit A: y/b + untracked y/{c,d,e} |
| 3167 | # Commit B: z/{b,d_1,e} |
| 3168 | # Expected: Failed Merge; y/b + untracked y/c + untracked y/d on disk + |
| 3169 | # z/c_1 -> z/d_1 rename recorded at stage 3 for y/d + |
| 3170 | # ERROR_MSG(refusing to lose untracked file at 'y/d') |
| 3171 | |
| 3172 | test_setup_10b () { |
| 3173 | git init 10b && |
| 3174 | ( |
| 3175 | cd 10b && |
| 3176 | |
| 3177 | mkdir z && |
| 3178 | echo b >z/b && |
| 3179 | echo c >z/c && |
| 3180 | git add z && |
| 3181 | test_tick && |
| 3182 | git commit -m "O" && |
| 3183 | |
| 3184 | git branch O && |
| 3185 | git branch A && |
| 3186 | git branch B && |
| 3187 | |
| 3188 | git checkout A && |
| 3189 | git rm z/c && |
| 3190 | git mv z/ y/ && |
| 3191 | test_tick && |
| 3192 | git commit -m "A" && |
| 3193 | |
| 3194 | git checkout B && |
| 3195 | git mv z/c z/d && |
| 3196 | echo e >z/e && |
| 3197 | git add z/e && |
| 3198 | test_tick && |
| 3199 | git commit -m "B" |
| 3200 | ) |
| 3201 | } |
| 3202 | |
| 3203 | test_expect_success '10b: Overwrite untracked with dir rename + delete' ' |
| 3204 | test_setup_10b && |
| 3205 | ( |
| 3206 | cd 10b && |
| 3207 | |
| 3208 | git checkout A^0 && |
| 3209 | echo very >y/c && |
| 3210 | echo important >y/d && |
| 3211 | echo contents >y/e && |
| 3212 | |
| 3213 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3214 | test_path_is_missing .git/MERGE_HEAD && |
| 3215 | test_grep "error: The following untracked working tree files would be overwritten by merge" err && |
| 3216 | |
| 3217 | git ls-files -s >out && |
| 3218 | test_line_count = 1 out && |
| 3219 | git ls-files -u >out && |
| 3220 | test_line_count = 0 out && |
| 3221 | git ls-files -o >out && |
| 3222 | test_line_count = 5 out && |
| 3223 | |
| 3224 | echo very >expect && |
| 3225 | test_cmp expect y/c && |
| 3226 | |
| 3227 | echo important >expect && |
| 3228 | test_cmp expect y/d && |
| 3229 | |
| 3230 | echo contents >expect && |
| 3231 | test_cmp expect y/e |
| 3232 | ) |
| 3233 | ' |
| 3234 | |
| 3235 | # Testcase 10c, Overwrite untracked: dir rename/rename(1to2) |
| 3236 | # Commit O: z/{a,b}, x/{c,d} |
| 3237 | # Commit A: y/{a,b}, w/c, x/d + different untracked y/c |
| 3238 | # Commit B: z/{a,b,c}, x/d |
| 3239 | # Expected: Failed Merge; y/{a,b} + x/d + untracked y/c + |
| 3240 | # CONFLICT(rename/rename) x/c -> w/c vs y/c + |
| 3241 | # y/c~B^0 + |
| 3242 | # ERROR_MSG(Refusing to lose untracked file at y/c) |
| 3243 | |
| 3244 | test_setup_10c () { |
| 3245 | git init 10c_$1 && |
| 3246 | ( |
| 3247 | cd 10c_$1 && |
| 3248 | |
| 3249 | mkdir z x && |
| 3250 | echo a >z/a && |
| 3251 | echo b >z/b && |
| 3252 | echo c >x/c && |
| 3253 | echo d >x/d && |
| 3254 | git add z x && |
| 3255 | test_tick && |
| 3256 | git commit -m "O" && |
| 3257 | |
| 3258 | git branch O && |
| 3259 | git branch A && |
| 3260 | git branch B && |
| 3261 | |
| 3262 | git checkout A && |
| 3263 | mkdir w && |
| 3264 | git mv x/c w/c && |
| 3265 | git mv z/ y/ && |
| 3266 | test_tick && |
| 3267 | git commit -m "A" && |
| 3268 | |
| 3269 | git checkout B && |
| 3270 | git mv x/c z/ && |
| 3271 | test_tick && |
| 3272 | git commit -m "B" |
| 3273 | ) |
| 3274 | } |
| 3275 | |
| 3276 | test_expect_success '10c1: Overwrite untracked with dir rename/rename(1to2)' ' |
| 3277 | test_setup_10c 1 && |
| 3278 | ( |
| 3279 | cd 10c_1 && |
| 3280 | |
| 3281 | git checkout A^0 && |
| 3282 | echo important >y/c && |
| 3283 | |
| 3284 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3285 | test_path_is_missing .git/MERGE_HEAD && |
| 3286 | test_grep "error: The following untracked working tree files would be overwritten by merge" err && |
| 3287 | |
| 3288 | git ls-files -s >out && |
| 3289 | test_line_count = 4 out && |
| 3290 | git ls-files -u >out && |
| 3291 | test_line_count = 0 out && |
| 3292 | git ls-files -o >out && |
| 3293 | test_line_count = 3 out && |
| 3294 | |
| 3295 | echo important >expect && |
| 3296 | test_cmp expect y/c |
| 3297 | ) |
| 3298 | ' |
| 3299 | |
| 3300 | test_expect_success '10c2: Overwrite untracked with dir rename/rename(1to2), other direction' ' |
| 3301 | test_setup_10c 2 && |
| 3302 | ( |
| 3303 | cd 10c_2 && |
| 3304 | |
| 3305 | git reset --hard && |
| 3306 | git clean -fdqx && |
| 3307 | |
| 3308 | git checkout B^0 && |
| 3309 | mkdir y && |
| 3310 | echo important >y/c && |
| 3311 | |
| 3312 | test_must_fail git -c merge.directoryRenames=true merge -s recursive A^0 >out 2>err && |
| 3313 | test_path_is_missing .git/MERGE_HEAD && |
| 3314 | test_grep "error: The following untracked working tree files would be overwritten by merge" err && |
| 3315 | |
| 3316 | git ls-files -s >out && |
| 3317 | test_line_count = 4 out && |
| 3318 | git ls-files -u >out && |
| 3319 | test_line_count = 0 out && |
| 3320 | git ls-files -o >out && |
| 3321 | test_line_count = 3 out && |
| 3322 | |
| 3323 | echo important >expect && |
| 3324 | test_cmp expect y/c |
| 3325 | ) |
| 3326 | ' |
| 3327 | |
| 3328 | # Testcase 10d, Delete untracked w/ dir rename/rename(2to1) |
| 3329 | # Commit O: z/{a,b,c_1}, x/{d,e,f_2} |
| 3330 | # Commit A: y/{a,b}, x/{d,e,f_2,wham_1} + untracked y/wham |
| 3331 | # Commit B: z/{a,b,c_1,wham_2}, y/{d,e} |
| 3332 | # Expected: Failed Merge; y/{a,b,d,e} + untracked y/{wham,wham~merged}+ |
| 3333 | # CONFLICT(rename/rename) z/c_1 vs x/f_2 -> y/wham |
| 3334 | # ERROR_MSG(Refusing to lose untracked file at y/wham) |
| 3335 | |
| 3336 | test_setup_10d () { |
| 3337 | git init 10d && |
| 3338 | ( |
| 3339 | cd 10d && |
| 3340 | |
| 3341 | mkdir z x && |
| 3342 | echo a >z/a && |
| 3343 | echo b >z/b && |
| 3344 | echo c >z/c && |
| 3345 | echo d >x/d && |
| 3346 | echo e >x/e && |
| 3347 | echo f >x/f && |
| 3348 | git add z x && |
| 3349 | test_tick && |
| 3350 | git commit -m "O" && |
| 3351 | |
| 3352 | git branch O && |
| 3353 | git branch A && |
| 3354 | git branch B && |
| 3355 | |
| 3356 | git checkout A && |
| 3357 | git mv z/c x/wham && |
| 3358 | git mv z/ y/ && |
| 3359 | test_tick && |
| 3360 | git commit -m "A" && |
| 3361 | |
| 3362 | git checkout B && |
| 3363 | git mv x/f z/wham && |
| 3364 | git mv x/ y/ && |
| 3365 | test_tick && |
| 3366 | git commit -m "B" |
| 3367 | ) |
| 3368 | } |
| 3369 | |
| 3370 | test_expect_success '10d: Delete untracked with dir rename/rename(2to1)' ' |
| 3371 | test_setup_10d && |
| 3372 | ( |
| 3373 | cd 10d && |
| 3374 | |
| 3375 | git checkout A^0 && |
| 3376 | echo important >y/wham && |
| 3377 | |
| 3378 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3379 | test_path_is_missing .git/MERGE_HEAD && |
| 3380 | test_grep "error: The following untracked working tree files would be overwritten by merge" err && |
| 3381 | |
| 3382 | git ls-files -s >out && |
| 3383 | test_line_count = 6 out && |
| 3384 | git ls-files -u >out && |
| 3385 | test_line_count = 0 out && |
| 3386 | git ls-files -o >out && |
| 3387 | test_line_count = 3 out && |
| 3388 | |
| 3389 | echo important >expect && |
| 3390 | test_cmp expect y/wham |
| 3391 | ) |
| 3392 | ' |
| 3393 | |
| 3394 | # Testcase 10e, Does git complain about untracked file that's not in the way? |
| 3395 | # Commit O: z/{a,b} |
| 3396 | # Commit A: y/{a,b} + untracked z/c |
| 3397 | # Commit B: z/{a,b,c} |
| 3398 | # Expected: y/{a,b,c} + untracked z/c |
| 3399 | |
| 3400 | test_setup_10e () { |
| 3401 | git init 10e && |
| 3402 | ( |
| 3403 | cd 10e && |
| 3404 | |
| 3405 | mkdir z && |
| 3406 | echo a >z/a && |
| 3407 | echo b >z/b && |
| 3408 | git add z && |
| 3409 | test_tick && |
| 3410 | git commit -m "O" && |
| 3411 | |
| 3412 | git branch O && |
| 3413 | git branch A && |
| 3414 | git branch B && |
| 3415 | |
| 3416 | git checkout A && |
| 3417 | git mv z/ y/ && |
| 3418 | test_tick && |
| 3419 | git commit -m "A" && |
| 3420 | |
| 3421 | git checkout B && |
| 3422 | echo c >z/c && |
| 3423 | git add z/c && |
| 3424 | test_tick && |
| 3425 | git commit -m "B" |
| 3426 | ) |
| 3427 | } |
| 3428 | |
| 3429 | test_expect_success '10e: Does git complain about untracked file that is not really in the way?' ' |
| 3430 | test_setup_10e && |
| 3431 | ( |
| 3432 | cd 10e && |
| 3433 | |
| 3434 | git checkout A^0 && |
| 3435 | mkdir z && |
| 3436 | echo random >z/c && |
| 3437 | |
| 3438 | git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3439 | test_grep ! "following untracked working tree files would be overwritten by merge" err && |
| 3440 | |
| 3441 | git ls-files -s >out && |
| 3442 | test_line_count = 3 out && |
| 3443 | git ls-files -u >out && |
| 3444 | test_line_count = 0 out && |
| 3445 | git ls-files -o >out && |
| 3446 | test_line_count = 3 out && |
| 3447 | |
| 3448 | git rev-parse >actual \ |
| 3449 | :0:y/a :0:y/b :0:y/c && |
| 3450 | git rev-parse >expect \ |
| 3451 | O:z/a O:z/b B:z/c && |
| 3452 | test_cmp expect actual && |
| 3453 | |
| 3454 | echo random >expect && |
| 3455 | test_cmp expect z/c |
| 3456 | ) |
| 3457 | ' |
| 3458 | |
| 3459 | ########################################################################### |
| 3460 | # SECTION 11: Handling dirty (not up-to-date) files |
| 3461 | # |
| 3462 | # unpack_trees(), upon which the recursive merge algorithm is based, aborts |
| 3463 | # the operation if untracked or dirty files would be deleted or overwritten |
| 3464 | # by the merge. Unfortunately, unpack_trees() does not understand renames, |
| 3465 | # and if it doesn't abort, then it muddies up the working directory before |
| 3466 | # we even get to the point of detecting renames, so we need some special |
| 3467 | # handling. This was true even of normal renames, but there are additional |
| 3468 | # codepaths that need special handling with directory renames. Add |
| 3469 | # testcases for both renamed-by-directory-rename-detection and standard |
| 3470 | # rename cases. |
| 3471 | ########################################################################### |
| 3472 | |
| 3473 | # Testcase 11a, Avoid losing dirty contents with simple rename |
| 3474 | # Commit O: z/{a,b_v1}, |
| 3475 | # Commit A: z/{a,c_v1}, and z/c_v1 has uncommitted mods |
| 3476 | # Commit B: z/{a,b_v2} |
| 3477 | # Expected: ERROR_MSG(Refusing to lose dirty file at z/c) + |
| 3478 | # z/a, staged version of z/c has sha1sum matching B:z/b_v2, |
| 3479 | # z/c~HEAD with contents of B:z/b_v2, |
| 3480 | # z/c with uncommitted mods on top of A:z/c_v1 |
| 3481 | |
| 3482 | test_setup_11a () { |
| 3483 | git init 11a && |
| 3484 | ( |
| 3485 | cd 11a && |
| 3486 | |
| 3487 | mkdir z && |
| 3488 | echo a >z/a && |
| 3489 | test_seq 1 10 >z/b && |
| 3490 | git add z && |
| 3491 | test_tick && |
| 3492 | git commit -m "O" && |
| 3493 | |
| 3494 | git branch O && |
| 3495 | git branch A && |
| 3496 | git branch B && |
| 3497 | |
| 3498 | git checkout A && |
| 3499 | git mv z/b z/c && |
| 3500 | test_tick && |
| 3501 | git commit -m "A" && |
| 3502 | |
| 3503 | git checkout B && |
| 3504 | echo 11 >>z/b && |
| 3505 | git add z/b && |
| 3506 | test_tick && |
| 3507 | git commit -m "B" |
| 3508 | ) |
| 3509 | } |
| 3510 | |
| 3511 | test_expect_success '11a: Avoid losing dirty contents with simple rename' ' |
| 3512 | test_setup_11a && |
| 3513 | ( |
| 3514 | cd 11a && |
| 3515 | |
| 3516 | git checkout A^0 && |
| 3517 | echo stuff >>z/c && |
| 3518 | |
| 3519 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3520 | test_path_is_missing .git/MERGE_HEAD && |
| 3521 | test_grep "error: Your local changes to the following files would be overwritten by merge" err && |
| 3522 | |
| 3523 | test_seq 1 10 >expected && |
| 3524 | echo stuff >>expected && |
| 3525 | test_cmp expected z/c |
| 3526 | |
| 3527 | ) |
| 3528 | ' |
| 3529 | |
| 3530 | # Testcase 11b, Avoid losing dirty file involved in directory rename |
| 3531 | # Commit O: z/a, x/{b,c_v1} |
| 3532 | # Commit A: z/{a,c_v1}, x/b, and z/c_v1 has uncommitted mods |
| 3533 | # Commit B: y/a, x/{b,c_v2} |
| 3534 | # Expected: y/{a,c_v2}, x/b, z/c_v1 with uncommitted mods untracked, |
| 3535 | # ERROR_MSG(Refusing to lose dirty file at z/c) |
| 3536 | |
| 3537 | |
| 3538 | test_setup_11b () { |
| 3539 | git init 11b && |
| 3540 | ( |
| 3541 | cd 11b && |
| 3542 | |
| 3543 | mkdir z x && |
| 3544 | echo a >z/a && |
| 3545 | echo b >x/b && |
| 3546 | test_seq 1 10 >x/c && |
| 3547 | git add z x && |
| 3548 | test_tick && |
| 3549 | git commit -m "O" && |
| 3550 | |
| 3551 | git branch O && |
| 3552 | git branch A && |
| 3553 | git branch B && |
| 3554 | |
| 3555 | git checkout A && |
| 3556 | git mv x/c z/c && |
| 3557 | test_tick && |
| 3558 | git commit -m "A" && |
| 3559 | |
| 3560 | git checkout B && |
| 3561 | git mv z y && |
| 3562 | echo 11 >>x/c && |
| 3563 | git add x/c && |
| 3564 | test_tick && |
| 3565 | git commit -m "B" |
| 3566 | ) |
| 3567 | } |
| 3568 | |
| 3569 | test_expect_success '11b: Avoid losing dirty file involved in directory rename' ' |
| 3570 | test_setup_11b && |
| 3571 | ( |
| 3572 | cd 11b && |
| 3573 | |
| 3574 | git checkout A^0 && |
| 3575 | echo stuff >>z/c && |
| 3576 | |
| 3577 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3578 | test_path_is_missing .git/MERGE_HEAD && |
| 3579 | test_grep "error: Your local changes to the following files would be overwritten by merge" err && |
| 3580 | |
| 3581 | test_grep -q stuff z/c && |
| 3582 | test_seq 1 10 >expected && |
| 3583 | echo stuff >>expected && |
| 3584 | test_cmp expected z/c |
| 3585 | ) |
| 3586 | ' |
| 3587 | |
| 3588 | # Testcase 11c, Avoid losing not-up-to-date with rename + D/F conflict |
| 3589 | # Commit O: y/a, x/{b,c_v1} |
| 3590 | # Commit A: y/{a,c_v1}, x/b, and y/c_v1 has uncommitted mods |
| 3591 | # Commit B: y/{a,c/d}, x/{b,c_v2} |
| 3592 | # Expected: Abort_msg("following files would be overwritten by merge") + |
| 3593 | # y/c left untouched (still has uncommitted mods) |
| 3594 | |
| 3595 | test_setup_11c () { |
| 3596 | git init 11c && |
| 3597 | ( |
| 3598 | cd 11c && |
| 3599 | |
| 3600 | mkdir y x && |
| 3601 | echo a >y/a && |
| 3602 | echo b >x/b && |
| 3603 | test_seq 1 10 >x/c && |
| 3604 | git add y x && |
| 3605 | test_tick && |
| 3606 | git commit -m "O" && |
| 3607 | |
| 3608 | git branch O && |
| 3609 | git branch A && |
| 3610 | git branch B && |
| 3611 | |
| 3612 | git checkout A && |
| 3613 | git mv x/c y/c && |
| 3614 | test_tick && |
| 3615 | git commit -m "A" && |
| 3616 | |
| 3617 | git checkout B && |
| 3618 | mkdir y/c && |
| 3619 | echo d >y/c/d && |
| 3620 | echo 11 >>x/c && |
| 3621 | git add x/c y/c/d && |
| 3622 | test_tick && |
| 3623 | git commit -m "B" |
| 3624 | ) |
| 3625 | } |
| 3626 | |
| 3627 | test_expect_success '11c: Avoid losing not-uptodate with rename + D/F conflict' ' |
| 3628 | test_setup_11c && |
| 3629 | ( |
| 3630 | cd 11c && |
| 3631 | |
| 3632 | git checkout A^0 && |
| 3633 | echo stuff >>y/c && |
| 3634 | |
| 3635 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3636 | test_path_is_missing .git/MERGE_HEAD && |
| 3637 | test_grep "error: Your local changes to the following files would be overwritten by merge" err && |
| 3638 | |
| 3639 | test_grep -q stuff y/c && |
| 3640 | test_seq 1 10 >expected && |
| 3641 | echo stuff >>expected && |
| 3642 | test_cmp expected y/c && |
| 3643 | |
| 3644 | git ls-files -s >out && |
| 3645 | test_line_count = 3 out && |
| 3646 | git ls-files -u >out && |
| 3647 | test_line_count = 0 out && |
| 3648 | git ls-files -m >out && |
| 3649 | test_line_count = 1 out && |
| 3650 | git ls-files -o >out && |
| 3651 | test_line_count = 3 out |
| 3652 | ) |
| 3653 | ' |
| 3654 | |
| 3655 | # Testcase 11d, Avoid losing not-up-to-date with rename + D/F conflict |
| 3656 | # Commit O: z/a, x/{b,c_v1} |
| 3657 | # Commit A: z/{a,c_v1}, x/b, and z/c_v1 has uncommitted mods |
| 3658 | # Commit B: y/{a,c/d}, x/{b,c_v2} |
| 3659 | # Expected: D/F: y/c_v2 vs y/c/d) + |
| 3660 | # Warning_Msg("Refusing to lose dirty file at z/c) + |
| 3661 | # y/{a,c~HEAD,c/d}, x/b, now-untracked z/c_v1 with uncommitted mods |
| 3662 | |
| 3663 | test_setup_11d () { |
| 3664 | git init 11d && |
| 3665 | ( |
| 3666 | cd 11d && |
| 3667 | |
| 3668 | mkdir z x && |
| 3669 | echo a >z/a && |
| 3670 | echo b >x/b && |
| 3671 | test_seq 1 10 >x/c && |
| 3672 | git add z x && |
| 3673 | test_tick && |
| 3674 | git commit -m "O" && |
| 3675 | |
| 3676 | git branch O && |
| 3677 | git branch A && |
| 3678 | git branch B && |
| 3679 | |
| 3680 | git checkout A && |
| 3681 | git mv x/c z/c && |
| 3682 | test_tick && |
| 3683 | git commit -m "A" && |
| 3684 | |
| 3685 | git checkout B && |
| 3686 | git mv z y && |
| 3687 | mkdir y/c && |
| 3688 | echo d >y/c/d && |
| 3689 | echo 11 >>x/c && |
| 3690 | git add x/c y/c/d && |
| 3691 | test_tick && |
| 3692 | git commit -m "B" |
| 3693 | ) |
| 3694 | } |
| 3695 | |
| 3696 | test_expect_success '11d: Avoid losing not-uptodate with rename + D/F conflict' ' |
| 3697 | test_setup_11d && |
| 3698 | ( |
| 3699 | cd 11d && |
| 3700 | |
| 3701 | git checkout A^0 && |
| 3702 | echo stuff >>z/c && |
| 3703 | |
| 3704 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3705 | test_path_is_missing .git/MERGE_HEAD && |
| 3706 | test_grep "error: Your local changes to the following files would be overwritten by merge" err && |
| 3707 | |
| 3708 | test_grep -q stuff z/c && |
| 3709 | test_seq 1 10 >expected && |
| 3710 | echo stuff >>expected && |
| 3711 | test_cmp expected z/c |
| 3712 | ) |
| 3713 | ' |
| 3714 | |
| 3715 | # Testcase 11e, Avoid deleting not-up-to-date with dir rename/rename(1to2)/add |
| 3716 | # Commit O: z/{a,b}, x/{c_1,d} |
| 3717 | # Commit A: y/{a,b,c_2}, x/d, w/c_1, and y/c_2 has uncommitted mods |
| 3718 | # Commit B: z/{a,b,c_1}, x/d |
| 3719 | # Expected: Failed Merge; y/{a,b} + x/d + |
| 3720 | # CONFLICT(rename/rename) x/c_1 -> w/c_1 vs y/c_1 + |
| 3721 | # ERROR_MSG(Refusing to lose dirty file at y/c) |
| 3722 | # y/c~B^0 has O:x/c_1 contents |
| 3723 | # y/c~HEAD has A:y/c_2 contents |
| 3724 | # y/c has dirty file from before merge |
| 3725 | |
| 3726 | test_setup_11e () { |
| 3727 | git init 11e && |
| 3728 | ( |
| 3729 | cd 11e && |
| 3730 | |
| 3731 | mkdir z x && |
| 3732 | echo a >z/a && |
| 3733 | echo b >z/b && |
| 3734 | echo c >x/c && |
| 3735 | echo d >x/d && |
| 3736 | git add z x && |
| 3737 | test_tick && |
| 3738 | git commit -m "O" && |
| 3739 | |
| 3740 | git branch O && |
| 3741 | git branch A && |
| 3742 | git branch B && |
| 3743 | |
| 3744 | git checkout A && |
| 3745 | git mv z/ y/ && |
| 3746 | echo different >y/c && |
| 3747 | mkdir w && |
| 3748 | git mv x/c w/ && |
| 3749 | git add y/c && |
| 3750 | test_tick && |
| 3751 | git commit -m "A" && |
| 3752 | |
| 3753 | git checkout B && |
| 3754 | git mv x/c z/ && |
| 3755 | test_tick && |
| 3756 | git commit -m "B" |
| 3757 | ) |
| 3758 | } |
| 3759 | |
| 3760 | test_expect_success '11e: Avoid deleting not-uptodate with dir rename/rename(1to2)/add' ' |
| 3761 | test_setup_11e && |
| 3762 | ( |
| 3763 | cd 11e && |
| 3764 | |
| 3765 | git checkout A^0 && |
| 3766 | echo mods >>y/c && |
| 3767 | |
| 3768 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3769 | test_path_is_missing .git/MERGE_HEAD && |
| 3770 | test_grep "error: Your local changes to the following files would be overwritten by merge" err && |
| 3771 | |
| 3772 | echo different >expected && |
| 3773 | echo mods >>expected && |
| 3774 | test_cmp expected y/c |
| 3775 | ) |
| 3776 | ' |
| 3777 | |
| 3778 | # Testcase 11f, Avoid deleting not-up-to-date w/ dir rename/rename(2to1) |
| 3779 | # Commit O: z/{a,b}, x/{c_1,d_2} |
| 3780 | # Commit A: y/{a,b,wham_1}, x/d_2, except y/wham has uncommitted mods |
| 3781 | # Commit B: z/{a,b,wham_2}, x/c_1 |
| 3782 | # Expected: Failed Merge; y/{a,b} + untracked y/{wham~merged} + |
| 3783 | # y/wham with dirty changes from before merge + |
| 3784 | # CONFLICT(rename/rename) x/c vs x/d -> y/wham |
| 3785 | # ERROR_MSG(Refusing to lose dirty file at y/wham) |
| 3786 | |
| 3787 | test_setup_11f () { |
| 3788 | git init 11f && |
| 3789 | ( |
| 3790 | cd 11f && |
| 3791 | |
| 3792 | mkdir z x && |
| 3793 | echo a >z/a && |
| 3794 | echo b >z/b && |
| 3795 | test_seq 1 10 >x/c && |
| 3796 | echo d >x/d && |
| 3797 | git add z x && |
| 3798 | test_tick && |
| 3799 | git commit -m "O" && |
| 3800 | |
| 3801 | git branch O && |
| 3802 | git branch A && |
| 3803 | git branch B && |
| 3804 | |
| 3805 | git checkout A && |
| 3806 | git mv z/ y/ && |
| 3807 | git mv x/c y/wham && |
| 3808 | test_tick && |
| 3809 | git commit -m "A" && |
| 3810 | |
| 3811 | git checkout B && |
| 3812 | git mv x/d z/wham && |
| 3813 | test_tick && |
| 3814 | git commit -m "B" |
| 3815 | ) |
| 3816 | } |
| 3817 | |
| 3818 | test_expect_success '11f: Avoid deleting not-uptodate with dir rename/rename(2to1)' ' |
| 3819 | test_setup_11f && |
| 3820 | ( |
| 3821 | cd 11f && |
| 3822 | |
| 3823 | git checkout A^0 && |
| 3824 | echo important >>y/wham && |
| 3825 | |
| 3826 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err && |
| 3827 | test_path_is_missing .git/MERGE_HEAD && |
| 3828 | test_grep "error: Your local changes to the following files would be overwritten by merge" err && |
| 3829 | |
| 3830 | test_seq 1 10 >expected && |
| 3831 | echo important >>expected && |
| 3832 | test_cmp expected y/wham |
| 3833 | ) |
| 3834 | ' |
| 3835 | |
| 3836 | ########################################################################### |
| 3837 | # SECTION 12: Everything else |
| 3838 | # |
| 3839 | # Tests suggested by others. Tests added after implementation completed |
| 3840 | # and submitted. Grab bag. |
| 3841 | ########################################################################### |
| 3842 | |
| 3843 | # Testcase 12a, Moving one directory hierarchy into another |
| 3844 | # (Related to testcase 9a) |
| 3845 | # Commit O: node1/{leaf1,leaf2}, node2/{leaf3,leaf4} |
| 3846 | # Commit A: node1/{leaf1,leaf2,node2/{leaf3,leaf4}} |
| 3847 | # Commit B: node1/{leaf1,leaf2,leaf5}, node2/{leaf3,leaf4,leaf6} |
| 3848 | # Expected: node1/{leaf1,leaf2,leaf5,node2/{leaf3,leaf4,leaf6}} |
| 3849 | |
| 3850 | test_setup_12a () { |
| 3851 | git init 12a && |
| 3852 | ( |
| 3853 | cd 12a && |
| 3854 | |
| 3855 | mkdir -p node1 node2 && |
| 3856 | echo leaf1 >node1/leaf1 && |
| 3857 | echo leaf2 >node1/leaf2 && |
| 3858 | echo leaf3 >node2/leaf3 && |
| 3859 | echo leaf4 >node2/leaf4 && |
| 3860 | git add node1 node2 && |
| 3861 | test_tick && |
| 3862 | git commit -m "O" && |
| 3863 | |
| 3864 | git branch O && |
| 3865 | git branch A && |
| 3866 | git branch B && |
| 3867 | |
| 3868 | git checkout A && |
| 3869 | git mv node2/ node1/ && |
| 3870 | test_tick && |
| 3871 | git commit -m "A" && |
| 3872 | |
| 3873 | git checkout B && |
| 3874 | echo leaf5 >node1/leaf5 && |
| 3875 | echo leaf6 >node2/leaf6 && |
| 3876 | git add node1 node2 && |
| 3877 | test_tick && |
| 3878 | git commit -m "B" |
| 3879 | ) |
| 3880 | } |
| 3881 | |
| 3882 | test_expect_success '12a: Moving one directory hierarchy into another' ' |
| 3883 | test_setup_12a && |
| 3884 | ( |
| 3885 | cd 12a && |
| 3886 | |
| 3887 | git checkout A^0 && |
| 3888 | |
| 3889 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 3890 | |
| 3891 | git ls-files -s >out && |
| 3892 | test_line_count = 6 out && |
| 3893 | |
| 3894 | git rev-parse >actual \ |
| 3895 | HEAD:node1/leaf1 HEAD:node1/leaf2 HEAD:node1/leaf5 \ |
| 3896 | HEAD:node1/node2/leaf3 \ |
| 3897 | HEAD:node1/node2/leaf4 \ |
| 3898 | HEAD:node1/node2/leaf6 && |
| 3899 | git rev-parse >expect \ |
| 3900 | O:node1/leaf1 O:node1/leaf2 B:node1/leaf5 \ |
| 3901 | O:node2/leaf3 \ |
| 3902 | O:node2/leaf4 \ |
| 3903 | B:node2/leaf6 && |
| 3904 | test_cmp expect actual |
| 3905 | ) |
| 3906 | ' |
| 3907 | |
| 3908 | # Testcase 12b1, Moving two directory hierarchies into each other |
| 3909 | # (Related to testcases 1c and 12c) |
| 3910 | # Commit O: node1/{leaf1, leaf2}, node2/{leaf3, leaf4} |
| 3911 | # Commit A: node1/{leaf1, leaf2, node2/{leaf3, leaf4}} |
| 3912 | # Commit B: node2/{leaf3, leaf4, node1/{leaf1, leaf2}} |
| 3913 | # Expected: node1/node2/{leaf3, leaf4} |
| 3914 | # node2/node1/{leaf1, leaf2} |
| 3915 | # NOTE: If there were new files added to the old node1/ or node2/ directories, |
| 3916 | # then we would need to detect renames for those directories and would |
| 3917 | # find that: |
| 3918 | # commit A renames node2/ -> node1/node2/ |
| 3919 | # commit B renames node1/ -> node2/node1/ |
| 3920 | # Applying those directory renames to the initial result (making all |
| 3921 | # four paths experience a transitive renaming), yields |
| 3922 | # node1/node2/node1/{leaf1, leaf2} |
| 3923 | # node2/node1/node2/{leaf3, leaf4} |
| 3924 | # as the result. It may be really weird to have two directories |
| 3925 | # rename each other, but simple rules give weird results when given |
| 3926 | # weird inputs. HOWEVER, the "If" at the beginning of those NOTE was |
| 3927 | # false; there were no new files added and thus there is no directory |
| 3928 | # rename detection to perform. As such, we just have simple renames |
| 3929 | # and the expected answer is: |
| 3930 | # node1/node2/{leaf3, leaf4} |
| 3931 | # node2/node1/{leaf1, leaf2} |
| 3932 | |
| 3933 | test_setup_12b1 () { |
| 3934 | git init 12b1 && |
| 3935 | ( |
| 3936 | cd 12b1 && |
| 3937 | |
| 3938 | mkdir -p node1 node2 && |
| 3939 | echo leaf1 >node1/leaf1 && |
| 3940 | echo leaf2 >node1/leaf2 && |
| 3941 | echo leaf3 >node2/leaf3 && |
| 3942 | echo leaf4 >node2/leaf4 && |
| 3943 | git add node1 node2 && |
| 3944 | test_tick && |
| 3945 | git commit -m "O" && |
| 3946 | |
| 3947 | git branch O && |
| 3948 | git branch A && |
| 3949 | git branch B && |
| 3950 | |
| 3951 | git checkout A && |
| 3952 | git mv node2/ node1/ && |
| 3953 | test_tick && |
| 3954 | git commit -m "A" && |
| 3955 | |
| 3956 | git checkout B && |
| 3957 | git mv node1/ node2/ && |
| 3958 | test_tick && |
| 3959 | git commit -m "B" |
| 3960 | ) |
| 3961 | } |
| 3962 | |
| 3963 | test_expect_success '12b1: Moving two directory hierarchies into each other' ' |
| 3964 | test_setup_12b1 && |
| 3965 | ( |
| 3966 | cd 12b1 && |
| 3967 | |
| 3968 | git checkout A^0 && |
| 3969 | |
| 3970 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 3971 | |
| 3972 | git ls-files -s >out && |
| 3973 | test_line_count = 4 out && |
| 3974 | |
| 3975 | git rev-parse >actual \ |
| 3976 | HEAD:node2/node1/leaf1 \ |
| 3977 | HEAD:node2/node1/leaf2 \ |
| 3978 | HEAD:node1/node2/leaf3 \ |
| 3979 | HEAD:node1/node2/leaf4 && |
| 3980 | git rev-parse >expect \ |
| 3981 | O:node1/leaf1 \ |
| 3982 | O:node1/leaf2 \ |
| 3983 | O:node2/leaf3 \ |
| 3984 | O:node2/leaf4 && |
| 3985 | test_cmp expect actual |
| 3986 | ) |
| 3987 | ' |
| 3988 | |
| 3989 | # Testcase 12b2, Moving two directory hierarchies into each other |
| 3990 | # (Related to testcases 1c and 12c) |
| 3991 | # Commit O: node1/{leaf1, leaf2}, node2/{leaf3, leaf4} |
| 3992 | # Commit A: node1/{leaf1, leaf2, leaf5, node2/{leaf3, leaf4}} |
| 3993 | # Commit B: node2/{leaf3, leaf4, leaf6, node1/{leaf1, leaf2}} |
| 3994 | # Expected: node1/node2/{node1/{leaf1, leaf2}, leaf6} |
| 3995 | # node2/node1/{node2/{leaf3, leaf4}, leaf5} |
| 3996 | # NOTE: Without directory renames, we would expect |
| 3997 | # A: node2/leaf3 -> node1/node2/leaf3 |
| 3998 | # A: node2/leaf1 -> node1/node2/leaf4 |
| 3999 | # A: Adds node1/leaf5 |
| 4000 | # B: node1/leaf1 -> node2/node1/leaf1 |
| 4001 | # B: node1/leaf2 -> node2/node1/leaf2 |
| 4002 | # B: Adds node2/leaf6 |
| 4003 | # with directory rename detection, we note that |
| 4004 | # commit A renames node2/ -> node1/node2/ |
| 4005 | # commit B renames node1/ -> node2/node1/ |
| 4006 | # therefore, applying A's directory rename to the paths added in B gives: |
| 4007 | # B: node1/leaf1 -> node1/node2/node1/leaf1 |
| 4008 | # B: node1/leaf2 -> node1/node2/node1/leaf2 |
| 4009 | # B: Adds node1/node2/leaf6 |
| 4010 | # and applying B's directory rename to the paths added in A gives: |
| 4011 | # A: node2/leaf3 -> node2/node1/node2/leaf3 |
| 4012 | # A: node2/leaf1 -> node2/node1/node2/leaf4 |
| 4013 | # A: Adds node2/node1/leaf5 |
| 4014 | # resulting in the expected |
| 4015 | # node1/node2/{node1/{leaf1, leaf2}, leaf6} |
| 4016 | # node2/node1/{node2/{leaf3, leaf4}, leaf5} |
| 4017 | # |
| 4018 | # You may ask, is it weird to have two directories rename each other? |
| 4019 | # To which, I can do no more than shrug my shoulders and say that |
| 4020 | # even simple rules give weird results when given weird inputs. |
| 4021 | |
| 4022 | test_setup_12b2 () { |
| 4023 | git init 12b2 && |
| 4024 | ( |
| 4025 | cd 12b2 && |
| 4026 | |
| 4027 | mkdir -p node1 node2 && |
| 4028 | echo leaf1 >node1/leaf1 && |
| 4029 | echo leaf2 >node1/leaf2 && |
| 4030 | echo leaf3 >node2/leaf3 && |
| 4031 | echo leaf4 >node2/leaf4 && |
| 4032 | git add node1 node2 && |
| 4033 | test_tick && |
| 4034 | git commit -m "O" && |
| 4035 | |
| 4036 | git branch O && |
| 4037 | git branch A && |
| 4038 | git branch B && |
| 4039 | |
| 4040 | git checkout A && |
| 4041 | git mv node2/ node1/ && |
| 4042 | echo leaf5 >node1/leaf5 && |
| 4043 | git add node1/leaf5 && |
| 4044 | test_tick && |
| 4045 | git commit -m "A" && |
| 4046 | |
| 4047 | git checkout B && |
| 4048 | git mv node1/ node2/ && |
| 4049 | echo leaf6 >node2/leaf6 && |
| 4050 | git add node2/leaf6 && |
| 4051 | test_tick && |
| 4052 | git commit -m "B" |
| 4053 | ) |
| 4054 | } |
| 4055 | |
| 4056 | test_expect_success '12b2: Moving two directory hierarchies into each other' ' |
| 4057 | test_setup_12b2 && |
| 4058 | ( |
| 4059 | cd 12b2 && |
| 4060 | |
| 4061 | git checkout A^0 && |
| 4062 | |
| 4063 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 4064 | |
| 4065 | git ls-files -s >out && |
| 4066 | test_line_count = 6 out && |
| 4067 | |
| 4068 | git rev-parse >actual \ |
| 4069 | HEAD:node1/node2/node1/leaf1 \ |
| 4070 | HEAD:node1/node2/node1/leaf2 \ |
| 4071 | HEAD:node2/node1/node2/leaf3 \ |
| 4072 | HEAD:node2/node1/node2/leaf4 \ |
| 4073 | HEAD:node2/node1/leaf5 \ |
| 4074 | HEAD:node1/node2/leaf6 && |
| 4075 | git rev-parse >expect \ |
| 4076 | O:node1/leaf1 \ |
| 4077 | O:node1/leaf2 \ |
| 4078 | O:node2/leaf3 \ |
| 4079 | O:node2/leaf4 \ |
| 4080 | A:node1/leaf5 \ |
| 4081 | B:node2/leaf6 && |
| 4082 | test_cmp expect actual |
| 4083 | ) |
| 4084 | ' |
| 4085 | |
| 4086 | # Testcase 12c1, Moving two directory hierarchies into each other w/ content merge |
| 4087 | # (Related to testcase 12b) |
| 4088 | # Commit O: node1/{ leaf1_1, leaf2_1}, node2/{leaf3_1, leaf4_1} |
| 4089 | # Commit A: node1/{ leaf1_2, leaf2_2, node2/{leaf3_2, leaf4_2}} |
| 4090 | # Commit B: node2/{node1/{leaf1_3, leaf2_3}, leaf3_3, leaf4_3} |
| 4091 | # Expected: Content merge conflicts for each of: |
| 4092 | # node1/node2/node1/{leaf1, leaf2}, |
| 4093 | # node2/node1/node2/{leaf3, leaf4} |
| 4094 | # NOTE: This is *exactly* like 12b1, except that every path is modified on |
| 4095 | # each side of the merge. |
| 4096 | |
| 4097 | test_setup_12c1 () { |
| 4098 | git init 12c1 && |
| 4099 | ( |
| 4100 | cd 12c1 && |
| 4101 | |
| 4102 | mkdir -p node1 node2 && |
| 4103 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf1\n" >node1/leaf1 && |
| 4104 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf2\n" >node1/leaf2 && |
| 4105 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf3\n" >node2/leaf3 && |
| 4106 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf4\n" >node2/leaf4 && |
| 4107 | git add node1 node2 && |
| 4108 | test_tick && |
| 4109 | git commit -m "O" && |
| 4110 | |
| 4111 | git branch O && |
| 4112 | git branch A && |
| 4113 | git branch B && |
| 4114 | |
| 4115 | git checkout A && |
| 4116 | git mv node2/ node1/ && |
| 4117 | for i in $(git ls-files); do echo side A >>$i; done && |
| 4118 | git add -u && |
| 4119 | test_tick && |
| 4120 | git commit -m "A" && |
| 4121 | |
| 4122 | git checkout B && |
| 4123 | git mv node1/ node2/ && |
| 4124 | for i in $(git ls-files); do echo side B >>$i; done && |
| 4125 | git add -u && |
| 4126 | test_tick && |
| 4127 | git commit -m "B" |
| 4128 | ) |
| 4129 | } |
| 4130 | |
| 4131 | test_expect_success '12c1: Moving one directory hierarchy into another w/ content merge' ' |
| 4132 | test_setup_12c1 && |
| 4133 | ( |
| 4134 | cd 12c1 && |
| 4135 | |
| 4136 | git checkout A^0 && |
| 4137 | |
| 4138 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 4139 | |
| 4140 | git ls-files -u >out && |
| 4141 | test_line_count = 12 out && |
| 4142 | |
| 4143 | git rev-parse >actual \ |
| 4144 | :1:node2/node1/leaf1 \ |
| 4145 | :1:node2/node1/leaf2 \ |
| 4146 | :1:node1/node2/leaf3 \ |
| 4147 | :1:node1/node2/leaf4 \ |
| 4148 | :2:node2/node1/leaf1 \ |
| 4149 | :2:node2/node1/leaf2 \ |
| 4150 | :2:node1/node2/leaf3 \ |
| 4151 | :2:node1/node2/leaf4 \ |
| 4152 | :3:node2/node1/leaf1 \ |
| 4153 | :3:node2/node1/leaf2 \ |
| 4154 | :3:node1/node2/leaf3 \ |
| 4155 | :3:node1/node2/leaf4 && |
| 4156 | git rev-parse >expect \ |
| 4157 | O:node1/leaf1 \ |
| 4158 | O:node1/leaf2 \ |
| 4159 | O:node2/leaf3 \ |
| 4160 | O:node2/leaf4 \ |
| 4161 | A:node1/leaf1 \ |
| 4162 | A:node1/leaf2 \ |
| 4163 | A:node1/node2/leaf3 \ |
| 4164 | A:node1/node2/leaf4 \ |
| 4165 | B:node2/node1/leaf1 \ |
| 4166 | B:node2/node1/leaf2 \ |
| 4167 | B:node2/leaf3 \ |
| 4168 | B:node2/leaf4 && |
| 4169 | test_cmp expect actual |
| 4170 | ) |
| 4171 | ' |
| 4172 | |
| 4173 | # Testcase 12c2, Moving two directory hierarchies into each other w/ content merge |
| 4174 | # (Related to testcase 12b) |
| 4175 | # Commit O: node1/{ leaf1_1, leaf2_1}, node2/{leaf3_1, leaf4_1} |
| 4176 | # Commit A: node1/{ leaf1_2, leaf2_2, node2/{leaf3_2, leaf4_2}, leaf5} |
| 4177 | # Commit B: node2/{node1/{leaf1_3, leaf2_3}, leaf3_3, leaf4_3, leaf6} |
| 4178 | # Expected: Content merge conflicts for each of: |
| 4179 | # node1/node2/node1/{leaf1, leaf2} |
| 4180 | # node2/node1/node2/{leaf3, leaf4} |
| 4181 | # plus |
| 4182 | # node2/node1/leaf5 |
| 4183 | # node1/node2/leaf6 |
| 4184 | # NOTE: This is *exactly* like 12b2, except that every path from O is modified |
| 4185 | # on each side of the merge. |
| 4186 | |
| 4187 | test_setup_12c2 () { |
| 4188 | git init 12c2 && |
| 4189 | ( |
| 4190 | cd 12c2 && |
| 4191 | |
| 4192 | mkdir -p node1 node2 && |
| 4193 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf1\n" >node1/leaf1 && |
| 4194 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf2\n" >node1/leaf2 && |
| 4195 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf3\n" >node2/leaf3 && |
| 4196 | printf "1\n2\n3\n4\n5\n6\n7\n8\nleaf4\n" >node2/leaf4 && |
| 4197 | git add node1 node2 && |
| 4198 | test_tick && |
| 4199 | git commit -m "O" && |
| 4200 | |
| 4201 | git branch O && |
| 4202 | git branch A && |
| 4203 | git branch B && |
| 4204 | |
| 4205 | git checkout A && |
| 4206 | git mv node2/ node1/ && |
| 4207 | for i in $(git ls-files); do echo side A >>$i; done && |
| 4208 | git add -u && |
| 4209 | echo leaf5 >node1/leaf5 && |
| 4210 | git add node1/leaf5 && |
| 4211 | test_tick && |
| 4212 | git commit -m "A" && |
| 4213 | |
| 4214 | git checkout B && |
| 4215 | git mv node1/ node2/ && |
| 4216 | for i in $(git ls-files); do echo side B >>$i; done && |
| 4217 | git add -u && |
| 4218 | echo leaf6 >node2/leaf6 && |
| 4219 | git add node2/leaf6 && |
| 4220 | test_tick && |
| 4221 | git commit -m "B" |
| 4222 | ) |
| 4223 | } |
| 4224 | |
| 4225 | test_expect_success '12c2: Moving one directory hierarchy into another w/ content merge' ' |
| 4226 | test_setup_12c2 && |
| 4227 | ( |
| 4228 | cd 12c2 && |
| 4229 | |
| 4230 | git checkout A^0 && |
| 4231 | |
| 4232 | test_must_fail git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 4233 | |
| 4234 | git ls-files -s >out && |
| 4235 | test_line_count = 14 out && |
| 4236 | git ls-files -u >out && |
| 4237 | test_line_count = 12 out && |
| 4238 | |
| 4239 | git rev-parse >actual \ |
| 4240 | :1:node1/node2/node1/leaf1 \ |
| 4241 | :1:node1/node2/node1/leaf2 \ |
| 4242 | :1:node2/node1/node2/leaf3 \ |
| 4243 | :1:node2/node1/node2/leaf4 \ |
| 4244 | :2:node1/node2/node1/leaf1 \ |
| 4245 | :2:node1/node2/node1/leaf2 \ |
| 4246 | :2:node2/node1/node2/leaf3 \ |
| 4247 | :2:node2/node1/node2/leaf4 \ |
| 4248 | :3:node1/node2/node1/leaf1 \ |
| 4249 | :3:node1/node2/node1/leaf2 \ |
| 4250 | :3:node2/node1/node2/leaf3 \ |
| 4251 | :3:node2/node1/node2/leaf4 \ |
| 4252 | :0:node2/node1/leaf5 \ |
| 4253 | :0:node1/node2/leaf6 && |
| 4254 | git rev-parse >expect \ |
| 4255 | O:node1/leaf1 \ |
| 4256 | O:node1/leaf2 \ |
| 4257 | O:node2/leaf3 \ |
| 4258 | O:node2/leaf4 \ |
| 4259 | A:node1/leaf1 \ |
| 4260 | A:node1/leaf2 \ |
| 4261 | A:node1/node2/leaf3 \ |
| 4262 | A:node1/node2/leaf4 \ |
| 4263 | B:node2/node1/leaf1 \ |
| 4264 | B:node2/node1/leaf2 \ |
| 4265 | B:node2/leaf3 \ |
| 4266 | B:node2/leaf4 \ |
| 4267 | A:node1/leaf5 \ |
| 4268 | B:node2/leaf6 && |
| 4269 | test_cmp expect actual |
| 4270 | ) |
| 4271 | ' |
| 4272 | |
| 4273 | # Testcase 12d, Rename/merge of subdirectory into the root |
| 4274 | # Commit O: a/b/subdir/foo |
| 4275 | # Commit A: subdir/foo |
| 4276 | # Commit B: a/b/subdir/foo, a/b/bar |
| 4277 | # Expected: subdir/foo, bar |
| 4278 | |
| 4279 | test_setup_12d () { |
| 4280 | git init 12d && |
| 4281 | ( |
| 4282 | cd 12d && |
| 4283 | |
| 4284 | mkdir -p a/b/subdir && |
| 4285 | test_commit a/b/subdir/foo && |
| 4286 | |
| 4287 | git branch O && |
| 4288 | git branch A && |
| 4289 | git branch B && |
| 4290 | |
| 4291 | git checkout A && |
| 4292 | mkdir subdir && |
| 4293 | git mv a/b/subdir/foo.t subdir/foo.t && |
| 4294 | test_tick && |
| 4295 | git commit -m "A" && |
| 4296 | |
| 4297 | git checkout B && |
| 4298 | test_commit a/b/bar |
| 4299 | ) |
| 4300 | } |
| 4301 | |
| 4302 | test_expect_success '12d: Rename/merge subdir into the root, variant 1' ' |
| 4303 | test_setup_12d && |
| 4304 | ( |
| 4305 | cd 12d && |
| 4306 | |
| 4307 | git checkout A^0 && |
| 4308 | |
| 4309 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 4310 | |
| 4311 | git ls-files -s >out && |
| 4312 | test_line_count = 2 out && |
| 4313 | |
| 4314 | git rev-parse >actual \ |
| 4315 | HEAD:subdir/foo.t HEAD:bar.t && |
| 4316 | git rev-parse >expect \ |
| 4317 | O:a/b/subdir/foo.t B:a/b/bar.t && |
| 4318 | test_cmp expect actual && |
| 4319 | |
| 4320 | git hash-object bar.t >actual && |
| 4321 | git rev-parse B:a/b/bar.t >expect && |
| 4322 | test_cmp expect actual && |
| 4323 | |
| 4324 | test_must_fail git rev-parse HEAD:a/b/subdir/foo.t && |
| 4325 | test_must_fail git rev-parse HEAD:a/b/bar.t && |
| 4326 | test_path_is_missing a/ && |
| 4327 | test_path_is_file bar.t |
| 4328 | ) |
| 4329 | ' |
| 4330 | |
| 4331 | # Testcase 12e, Rename/merge of subdirectory into the root |
| 4332 | # Commit O: a/b/foo |
| 4333 | # Commit A: foo |
| 4334 | # Commit B: a/b/foo, a/b/bar |
| 4335 | # Expected: foo, bar |
| 4336 | |
| 4337 | test_setup_12e () { |
| 4338 | git init 12e && |
| 4339 | ( |
| 4340 | cd 12e && |
| 4341 | |
| 4342 | mkdir -p a/b && |
| 4343 | test_commit a/b/foo && |
| 4344 | |
| 4345 | git branch O && |
| 4346 | git branch A && |
| 4347 | git branch B && |
| 4348 | |
| 4349 | git checkout A && |
| 4350 | mkdir subdir && |
| 4351 | git mv a/b/foo.t foo.t && |
| 4352 | test_tick && |
| 4353 | git commit -m "A" && |
| 4354 | |
| 4355 | git checkout B && |
| 4356 | test_commit a/b/bar |
| 4357 | ) |
| 4358 | } |
| 4359 | |
| 4360 | test_expect_success '12e: Rename/merge subdir into the root, variant 2' ' |
| 4361 | test_setup_12e && |
| 4362 | ( |
| 4363 | cd 12e && |
| 4364 | |
| 4365 | git checkout A^0 && |
| 4366 | |
| 4367 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 4368 | |
| 4369 | git ls-files -s >out && |
| 4370 | test_line_count = 2 out && |
| 4371 | |
| 4372 | git rev-parse >actual \ |
| 4373 | HEAD:foo.t HEAD:bar.t && |
| 4374 | git rev-parse >expect \ |
| 4375 | O:a/b/foo.t B:a/b/bar.t && |
| 4376 | test_cmp expect actual && |
| 4377 | |
| 4378 | git hash-object bar.t >actual && |
| 4379 | git rev-parse B:a/b/bar.t >expect && |
| 4380 | test_cmp expect actual && |
| 4381 | |
| 4382 | test_must_fail git rev-parse HEAD:a/b/foo.t && |
| 4383 | test_must_fail git rev-parse HEAD:a/b/bar.t && |
| 4384 | test_path_is_missing a/ && |
| 4385 | test_path_is_file bar.t |
| 4386 | ) |
| 4387 | ' |
| 4388 | |
| 4389 | # Testcase 12f, Rebase of patches with big directory rename |
| 4390 | # Commit O: |
| 4391 | # dir/subdir/{a,b,c,d,e_O,Makefile_TOP_O} |
| 4392 | # dir/subdir/tweaked/{f,g,h,Makefile_SUB_O} |
| 4393 | # dir/unchanged/<LOTS OF FILES> |
| 4394 | # Commit A: |
| 4395 | # (Remove f & g, move e into newsubdir, rename dir/->folder/, modify files) |
| 4396 | # folder/subdir/{a,b,c,d,Makefile_TOP_A} |
| 4397 | # folder/subdir/newsubdir/e_A |
| 4398 | # folder/subdir/tweaked/{h,Makefile_SUB_A} |
| 4399 | # folder/unchanged/<LOTS OF FILES> |
| 4400 | # Commit B1: |
| 4401 | # (add newfile.{c,py}, modify underscored files) |
| 4402 | # dir/{a,b,c,d,e_B1,Makefile_TOP_B1,newfile.c} |
| 4403 | # dir/tweaked/{f,g,h,Makefile_SUB_B1,newfile.py} |
| 4404 | # dir/unchanged/<LOTS OF FILES> |
| 4405 | # Commit B2: |
| 4406 | # (Modify e further, add newfile.rs) |
| 4407 | # dir/{a,b,c,d,e_B2,Makefile_TOP_B1,newfile.c,newfile.rs} |
| 4408 | # dir/tweaked/{f,g,h,Makefile_SUB_B1,newfile.py} |
| 4409 | # dir/unchanged/<LOTS OF FILES> |
| 4410 | # Expected: |
| 4411 | # B1-picked: |
| 4412 | # folder/subdir/{a,b,c,d,Makefile_TOP_Merge1,newfile.c} |
| 4413 | # folder/subdir/newsubdir/e_Merge1 |
| 4414 | # folder/subdir/tweaked/{h,Makefile_SUB_Merge1,newfile.py} |
| 4415 | # folder/unchanged/<LOTS OF FILES> |
| 4416 | # B2-picked: |
| 4417 | # folder/subdir/{a,b,c,d,Makefile_TOP_Merge1,newfile.c,newfile.rs} |
| 4418 | # folder/subdir/newsubdir/e_Merge2 |
| 4419 | # folder/subdir/tweaked/{h,Makefile_SUB_Merge1,newfile.py} |
| 4420 | # folder/unchanged/<LOTS OF FILES> |
| 4421 | # Things being checked here: |
| 4422 | # 1. dir/subdir/newfile.c does not get pushed into folder/subdir/newsubdir/. |
| 4423 | # dir/subdir/{a,b,c,d} -> folder/subdir/{a,b,c,d} looks like |
| 4424 | # dir/ -> folder/, |
| 4425 | # whereas dir/subdir/e -> folder/subdir/newsubdir/e looks like |
| 4426 | # dir/subdir/ -> folder/subdir/newsubdir/ |
| 4427 | # and if we note that newfile.c is found in dir/subdir/, we might overlook |
| 4428 | # the dir/ -> folder/ rule that has more weight. Older git versions did |
| 4429 | # this. |
| 4430 | # 2. The code to do trivial directory resolves. Note that |
| 4431 | # dir/subdir/unchanged/ is unchanged and can be deleted, and files in the |
| 4432 | # new folder/subdir/unchanged/ are not needed as a target to any renames. |
| 4433 | # Thus, in the second collect_merge_info_callback() we can just resolve |
| 4434 | # these two directories trivially without recursing.) |
| 4435 | # 3. Exercising the codepaths for caching renames and deletes from one cherry |
| 4436 | # pick and re-applying them in the subsequent one. |
| 4437 | |
| 4438 | test_setup_12f () { |
| 4439 | git init 12f && |
| 4440 | ( |
| 4441 | cd 12f && |
| 4442 | |
| 4443 | mkdir -p dir/unchanged && |
| 4444 | mkdir -p dir/subdir/tweaked && |
| 4445 | echo a >dir/subdir/a && |
| 4446 | echo b >dir/subdir/b && |
| 4447 | echo c >dir/subdir/c && |
| 4448 | echo d >dir/subdir/d && |
| 4449 | test_seq 1 10 >dir/subdir/e && |
| 4450 | test_seq 10 20 >dir/subdir/Makefile && |
| 4451 | echo f >dir/subdir/tweaked/f && |
| 4452 | echo g >dir/subdir/tweaked/g && |
| 4453 | echo h >dir/subdir/tweaked/h && |
| 4454 | test_seq 20 30 >dir/subdir/tweaked/Makefile && |
| 4455 | for i in $(test_seq 1 88); do |
| 4456 | echo content $i >dir/unchanged/file_$i |
| 4457 | done && |
| 4458 | git add . && |
| 4459 | git commit -m "O" && |
| 4460 | |
| 4461 | git branch O && |
| 4462 | git branch A && |
| 4463 | git branch B && |
| 4464 | |
| 4465 | git switch A && |
| 4466 | git rm dir/subdir/tweaked/f dir/subdir/tweaked/g && |
| 4467 | test_seq 2 10 >dir/subdir/e && |
| 4468 | test_seq 11 20 >dir/subdir/Makefile && |
| 4469 | test_seq 21 30 >dir/subdir/tweaked/Makefile && |
| 4470 | mkdir dir/subdir/newsubdir && |
| 4471 | git mv dir/subdir/e dir/subdir/newsubdir/ && |
| 4472 | git mv dir folder && |
| 4473 | git add . && |
| 4474 | git commit -m "A" && |
| 4475 | |
| 4476 | git switch B && |
| 4477 | mkdir dir/subdir/newsubdir/ && |
| 4478 | echo c code >dir/subdir/newfile.c && |
| 4479 | echo python code >dir/subdir/newsubdir/newfile.py && |
| 4480 | test_seq 1 11 >dir/subdir/e && |
| 4481 | test_seq 10 21 >dir/subdir/Makefile && |
| 4482 | test_seq 20 31 >dir/subdir/tweaked/Makefile && |
| 4483 | git add . && |
| 4484 | git commit -m "B1" && |
| 4485 | |
| 4486 | echo rust code >dir/subdir/newfile.rs && |
| 4487 | test_seq 1 12 >dir/subdir/e && |
| 4488 | git add . && |
| 4489 | git commit -m "B2" |
| 4490 | ) |
| 4491 | } |
| 4492 | |
| 4493 | test_expect_success '12f: Trivial directory resolve, caching, all kinds of fun' ' |
| 4494 | test_setup_12f && |
| 4495 | ( |
| 4496 | cd 12f && |
| 4497 | |
| 4498 | git checkout A^0 && |
| 4499 | git branch Bmod B && |
| 4500 | |
| 4501 | GIT_TRACE2_PERF="$(pwd)/trace.output" git -c merge.directoryRenames=true rebase A Bmod && |
| 4502 | |
| 4503 | echo Checking the pick of B1... && |
| 4504 | |
| 4505 | test_must_fail git rev-parse Bmod~1:dir && |
| 4506 | |
| 4507 | git ls-tree -r Bmod~1 >out && |
| 4508 | test_line_count = 98 out && |
| 4509 | |
| 4510 | git diff --name-status A Bmod~1 >actual && |
| 4511 | q_to_tab >expect <<-\EOF && |
| 4512 | MQfolder/subdir/Makefile |
| 4513 | AQfolder/subdir/newfile.c |
| 4514 | MQfolder/subdir/newsubdir/e |
| 4515 | AQfolder/subdir/newsubdir/newfile.py |
| 4516 | MQfolder/subdir/tweaked/Makefile |
| 4517 | EOF |
| 4518 | test_cmp expect actual && |
| 4519 | |
| 4520 | # Three-way merged files |
| 4521 | test_seq 2 11 >e_Merge1 && |
| 4522 | test_seq 11 21 >Makefile_TOP && |
| 4523 | test_seq 21 31 >Makefile_SUB && |
| 4524 | git hash-object >expect \ |
| 4525 | e_Merge1 \ |
| 4526 | Makefile_TOP \ |
| 4527 | Makefile_SUB && |
| 4528 | git rev-parse >actual \ |
| 4529 | Bmod~1:folder/subdir/newsubdir/e \ |
| 4530 | Bmod~1:folder/subdir/Makefile \ |
| 4531 | Bmod~1:folder/subdir/tweaked/Makefile && |
| 4532 | test_cmp expect actual && |
| 4533 | |
| 4534 | # New files showed up at the right location with right contents |
| 4535 | git rev-parse >expect \ |
| 4536 | B~1:dir/subdir/newfile.c \ |
| 4537 | B~1:dir/subdir/newsubdir/newfile.py && |
| 4538 | git rev-parse >actual \ |
| 4539 | Bmod~1:folder/subdir/newfile.c \ |
| 4540 | Bmod~1:folder/subdir/newsubdir/newfile.py && |
| 4541 | test_cmp expect actual && |
| 4542 | |
| 4543 | # Removed files |
| 4544 | test_path_is_missing folder/subdir/tweaked/f && |
| 4545 | test_path_is_missing folder/subdir/tweaked/g && |
| 4546 | |
| 4547 | # Unchanged files or directories |
| 4548 | git rev-parse >actual \ |
| 4549 | Bmod~1:folder/subdir/a \ |
| 4550 | Bmod~1:folder/subdir/b \ |
| 4551 | Bmod~1:folder/subdir/c \ |
| 4552 | Bmod~1:folder/subdir/d \ |
| 4553 | Bmod~1:folder/unchanged \ |
| 4554 | Bmod~1:folder/subdir/tweaked/h && |
| 4555 | git rev-parse >expect \ |
| 4556 | O:dir/subdir/a \ |
| 4557 | O:dir/subdir/b \ |
| 4558 | O:dir/subdir/c \ |
| 4559 | O:dir/subdir/d \ |
| 4560 | O:dir/unchanged \ |
| 4561 | O:dir/subdir/tweaked/h && |
| 4562 | test_cmp expect actual && |
| 4563 | |
| 4564 | echo Checking the pick of B2... && |
| 4565 | |
| 4566 | test_must_fail git rev-parse Bmod:dir && |
| 4567 | |
| 4568 | git ls-tree -r Bmod >out && |
| 4569 | test_line_count = 99 out && |
| 4570 | |
| 4571 | git diff --name-status Bmod~1 Bmod >actual && |
| 4572 | q_to_tab >expect <<-\EOF && |
| 4573 | AQfolder/subdir/newfile.rs |
| 4574 | MQfolder/subdir/newsubdir/e |
| 4575 | EOF |
| 4576 | test_cmp expect actual && |
| 4577 | |
| 4578 | # Three-way merged file |
| 4579 | test_seq 2 12 >e_Merge2 && |
| 4580 | git hash-object e_Merge2 >expect && |
| 4581 | git rev-parse Bmod:folder/subdir/newsubdir/e >actual && |
| 4582 | test_cmp expect actual && |
| 4583 | |
| 4584 | grep region_enter.*collect_merge_info trace.output >collect && |
| 4585 | test_line_count = 4 collect && |
| 4586 | grep region_enter.*process_entries$ trace.output >process && |
| 4587 | test_line_count = 2 process |
| 4588 | ) |
| 4589 | ' |
| 4590 | |
| 4591 | # Testcase 12g, Testcase with two kinds of "relevant" renames |
| 4592 | # Commit O: somefile_O, subdir/{a_O,b_O} |
| 4593 | # Commit A: somefile_A, subdir/{a_O,b_O,c_A} |
| 4594 | # Commit B: newfile_B, newdir/{a_B,b_B} |
| 4595 | # Expected: newfile_{merged}, newdir/{a_B,b_B,c_A} |
| 4596 | |
| 4597 | test_setup_12g () { |
| 4598 | git init 12g && |
| 4599 | ( |
| 4600 | cd 12g && |
| 4601 | |
| 4602 | mkdir -p subdir && |
| 4603 | test_write_lines upon a time there was a >somefile && |
| 4604 | test_write_lines 1 2 3 4 5 6 7 8 9 10 >subdir/a && |
| 4605 | test_write_lines one two three four five six >subdir/b && |
| 4606 | git add . && |
| 4607 | test_tick && |
| 4608 | git commit -m "O" && |
| 4609 | |
| 4610 | git branch O && |
| 4611 | git branch A && |
| 4612 | git branch B && |
| 4613 | |
| 4614 | git switch A && |
| 4615 | test_write_lines once upon a time there was a >somefile && |
| 4616 | > subdir/c && |
| 4617 | git add somefile subdir/c && |
| 4618 | test_tick && |
| 4619 | git commit -m "A" && |
| 4620 | |
| 4621 | git checkout B && |
| 4622 | git mv somefile newfile && |
| 4623 | git mv subdir newdir && |
| 4624 | echo repo >>newfile && |
| 4625 | test_write_lines 1 2 3 4 5 6 7 8 9 10 11 >newdir/a && |
| 4626 | test_write_lines one two three four five six seven >newdir/b && |
| 4627 | git add newfile newdir && |
| 4628 | test_tick && |
| 4629 | git commit -m "B" |
| 4630 | ) |
| 4631 | } |
| 4632 | |
| 4633 | test_expect_success '12g: Testcase with two kinds of "relevant" renames' ' |
| 4634 | test_setup_12g && |
| 4635 | ( |
| 4636 | cd 12g && |
| 4637 | |
| 4638 | git checkout A^0 && |
| 4639 | |
| 4640 | git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 4641 | |
| 4642 | test_write_lines once upon a time there was a repo >expect && |
| 4643 | test_cmp expect newfile && |
| 4644 | |
| 4645 | git ls-files -s >out && |
| 4646 | test_line_count = 4 out && |
| 4647 | |
| 4648 | git rev-parse >actual \ |
| 4649 | HEAD:newdir/a HEAD:newdir/b HEAD:newdir/c && |
| 4650 | git rev-parse >expect \ |
| 4651 | B:newdir/a B:newdir/b A:subdir/c && |
| 4652 | test_cmp expect actual && |
| 4653 | |
| 4654 | test_must_fail git rev-parse HEAD:subdir/a && |
| 4655 | test_must_fail git rev-parse HEAD:subdir/b && |
| 4656 | test_must_fail git rev-parse HEAD:subdir/c && |
| 4657 | test_path_is_missing subdir/ && |
| 4658 | test_path_is_file newdir/c |
| 4659 | ) |
| 4660 | ' |
| 4661 | |
| 4662 | # Testcase 12h, Testcase with two kinds of "relevant" renames |
| 4663 | # Commit O: olddir/{a_1, b} |
| 4664 | # Commit A: newdir/{a_2, b} |
| 4665 | # Commit B: olddir/{alpha_1, b} |
| 4666 | # Expected: newdir/{alpha_2, b} |
| 4667 | |
| 4668 | test_setup_12h () { |
| 4669 | git init 12h && |
| 4670 | ( |
| 4671 | cd 12h && |
| 4672 | |
| 4673 | mkdir olddir && |
| 4674 | test_seq 3 8 >olddir/a && |
| 4675 | >olddir/b && |
| 4676 | git add olddir && |
| 4677 | git commit -m orig && |
| 4678 | |
| 4679 | git branch O && |
| 4680 | git branch A && |
| 4681 | git branch B && |
| 4682 | |
| 4683 | git switch A && |
| 4684 | test_seq 3 10 >olddir/a && |
| 4685 | git add olddir/a && |
| 4686 | git mv olddir newdir && |
| 4687 | git commit -m A && |
| 4688 | |
| 4689 | git switch B && |
| 4690 | |
| 4691 | git mv olddir/a olddir/alpha && |
| 4692 | git commit -m B |
| 4693 | ) |
| 4694 | } |
| 4695 | |
| 4696 | test_expect_failure '12h: renaming a file within a renamed directory' ' |
| 4697 | test_setup_12h && |
| 4698 | ( |
| 4699 | cd 12h && |
| 4700 | |
| 4701 | git checkout A^0 && |
| 4702 | |
| 4703 | test_might_fail git -c merge.directoryRenames=true merge -s recursive B^0 && |
| 4704 | |
| 4705 | git ls-files >tracked && |
| 4706 | test_line_count = 2 tracked && |
| 4707 | |
| 4708 | test_path_is_missing olddir/a && |
| 4709 | test_path_is_file newdir/alpha && |
| 4710 | test_path_is_file newdir/b && |
| 4711 | |
| 4712 | git rev-parse >actual \ |
| 4713 | HEAD:newdir/alpha HEAD:newdir/b && |
| 4714 | git rev-parse >expect \ |
| 4715 | A:newdir/a O:oldir/b && |
| 4716 | test_cmp expect actual |
| 4717 | ) |
| 4718 | ' |
| 4719 | |
| 4720 | # Testcase 12i, Directory rename causes rename-to-self |
| 4721 | # Commit O: source/{subdir/foo, bar, baz_1} |
| 4722 | # Commit A: source/{foo, bar, baz_1} |
| 4723 | # Commit B: source/{subdir/{foo, bar}, baz_2} |
| 4724 | # Expected: source/{foo, bar, baz_2}, with conflicts on |
| 4725 | # source/bar vs. source/subdir/bar |
| 4726 | |
| 4727 | test_setup_12i () { |
| 4728 | git init 12i && |
| 4729 | ( |
| 4730 | cd 12i && |
| 4731 | |
| 4732 | mkdir -p source/subdir && |
| 4733 | echo foo >source/subdir/foo && |
| 4734 | printf "%d\n" 1 2 3 4 5 6 7 >source/bar && |
| 4735 | echo baz >source/baz && |
| 4736 | git add source && |
| 4737 | git commit -m orig && |
| 4738 | |
| 4739 | git branch O && |
| 4740 | git branch A && |
| 4741 | git branch B && |
| 4742 | |
| 4743 | git switch A && |
| 4744 | git mv source/subdir/foo source/foo && |
| 4745 | git commit -m A && |
| 4746 | |
| 4747 | git switch B && |
| 4748 | git mv source/bar source/subdir/bar && |
| 4749 | echo more baz >>source/baz && |
| 4750 | git add source/baz && |
| 4751 | git commit -m B |
| 4752 | ) |
| 4753 | } |
| 4754 | |
| 4755 | test_expect_success '12i: Directory rename causes rename-to-self' ' |
| 4756 | test_setup_12i && |
| 4757 | ( |
| 4758 | cd 12i && |
| 4759 | |
| 4760 | git checkout A^0 && |
| 4761 | |
| 4762 | # NOTE: A potentially better resolution would be for |
| 4763 | # source/bar -> source/subdir/bar |
| 4764 | # to use the directory rename to become |
| 4765 | # source/bar -> source/bar |
| 4766 | # (a rename to self), and thus we end up with bar with |
| 4767 | # a path conflict (given merge.directoryRenames=conflict). |
| 4768 | # However, since the relevant renames optimization |
| 4769 | # prevents us from noticing |
| 4770 | # source/bar -> source/subdir/bar |
| 4771 | # as a rename and looking at it just as |
| 4772 | # delete source/bar |
| 4773 | # add source/subdir/bar |
| 4774 | # the directory rename of source/subdir/bar -> source/bar does |
| 4775 | # not look like a rename-to-self situation but a |
| 4776 | # rename-on-top-of-other-file situation. We do not want |
| 4777 | # stage 1 entries from an unrelated file, so we expect an |
| 4778 | # error about there being a file in the way. |
| 4779 | |
| 4780 | test_must_fail git -c merge.directoryRenames=conflict merge -s recursive B^0 >out && |
| 4781 | |
| 4782 | test_grep "CONFLICT (implicit dir rename).*source/bar in the way" out && |
| 4783 | test_path_is_missing source/bar && |
| 4784 | test_path_is_file source/subdir/bar && |
| 4785 | test_path_is_file source/baz && |
| 4786 | |
| 4787 | git ls-files >actual && |
| 4788 | uniq <actual >tracked && |
| 4789 | test_line_count = 3 tracked && |
| 4790 | |
| 4791 | git status --porcelain -uno >actual && |
| 4792 | cat >expect <<-\EOF && |
| 4793 | M source/baz |
| 4794 | R source/bar -> source/subdir/bar |
| 4795 | EOF |
| 4796 | test_cmp expect actual |
| 4797 | ) |
| 4798 | ' |
| 4799 | |
| 4800 | # Testcase 12i2, Identical to 12i except that source/subdir/bar modified on unrenamed side |
| 4801 | # Commit O: source/{subdir/foo, bar, baz_1} |
| 4802 | # Commit A: source/{foo, bar_2, baz_1} |
| 4803 | # Commit B: source/{subdir/{foo, bar}, baz_2} |
| 4804 | # Expected: source/{foo, bar, baz_2}, with conflicts on |
| 4805 | # source/bar vs. source/subdir/bar |
| 4806 | |
| 4807 | test_setup_12i2 () { |
| 4808 | git init 12i2 && |
| 4809 | ( |
| 4810 | cd 12i2 && |
| 4811 | |
| 4812 | mkdir -p source/subdir && |
| 4813 | echo foo >source/subdir/foo && |
| 4814 | printf "%d\n" 1 2 3 4 5 6 7 >source/bar && |
| 4815 | echo baz >source/baz && |
| 4816 | git add source && |
| 4817 | git commit -m orig && |
| 4818 | |
| 4819 | git branch O && |
| 4820 | git branch A && |
| 4821 | git branch B && |
| 4822 | |
| 4823 | git switch A && |
| 4824 | git mv source/subdir/foo source/foo && |
| 4825 | echo 8 >> source/bar && |
| 4826 | git add source/bar && |
| 4827 | git commit -m A && |
| 4828 | |
| 4829 | git switch B && |
| 4830 | git mv source/bar source/subdir/bar && |
| 4831 | echo more baz >>source/baz && |
| 4832 | git add source/baz && |
| 4833 | git commit -m B |
| 4834 | ) |
| 4835 | } |
| 4836 | |
| 4837 | test_expect_success '12i2: Directory rename causes rename-to-self' ' |
| 4838 | test_setup_12i2 && |
| 4839 | ( |
| 4840 | cd 12i2 && |
| 4841 | |
| 4842 | git checkout A^0 && |
| 4843 | |
| 4844 | test_must_fail git -c merge.directoryRenames=conflict merge -s recursive B^0 && |
| 4845 | |
| 4846 | test_path_is_missing source/subdir && |
| 4847 | test_path_is_file source/bar && |
| 4848 | test_path_is_file source/baz && |
| 4849 | |
| 4850 | git ls-files >actual && |
| 4851 | uniq <actual >tracked && |
| 4852 | test_line_count = 3 tracked && |
| 4853 | |
| 4854 | git status --porcelain -uno >actual && |
| 4855 | cat >expect <<-\EOF && |
| 4856 | UU source/bar |
| 4857 | M source/baz |
| 4858 | EOF |
| 4859 | test_cmp expect actual |
| 4860 | ) |
| 4861 | ' |
| 4862 | |
| 4863 | # Testcase 12j, Directory rename to root causes rename-to-self |
| 4864 | # Commit O: {subdir/foo, bar, baz_1} |
| 4865 | # Commit A: {foo, bar, baz_1} |
| 4866 | # Commit B: {subdir/{foo, bar}, baz_2} |
| 4867 | # Expected: {foo, bar, baz_2}, with conflicts on bar vs. subdir/bar |
| 4868 | |
| 4869 | test_setup_12j () { |
| 4870 | git init 12j && |
| 4871 | ( |
| 4872 | cd 12j && |
| 4873 | |
| 4874 | mkdir -p subdir && |
| 4875 | echo foo >subdir/foo && |
| 4876 | echo bar >bar && |
| 4877 | echo baz >baz && |
| 4878 | git add . && |
| 4879 | git commit -m orig && |
| 4880 | |
| 4881 | git branch O && |
| 4882 | git branch A && |
| 4883 | git branch B && |
| 4884 | |
| 4885 | git switch A && |
| 4886 | git mv subdir/foo foo && |
| 4887 | git commit -m A && |
| 4888 | |
| 4889 | git switch B && |
| 4890 | git mv bar subdir/bar && |
| 4891 | echo more baz >>baz && |
| 4892 | git add baz && |
| 4893 | git commit -m B |
| 4894 | ) |
| 4895 | } |
| 4896 | |
| 4897 | test_expect_success '12j: Directory rename to root causes rename-to-self' ' |
| 4898 | test_setup_12j && |
| 4899 | ( |
| 4900 | cd 12j && |
| 4901 | |
| 4902 | git checkout A^0 && |
| 4903 | |
| 4904 | # NOTE: A potentially better resolution would be for |
| 4905 | # bar -> subdir/bar |
| 4906 | # to use the directory rename to become |
| 4907 | # bar -> bar |
| 4908 | # (a rename to self), and thus we end up with bar with |
| 4909 | # a path conflict (given merge.directoryRenames=conflict). |
| 4910 | # However, since the relevant renames optimization |
| 4911 | # prevents us from noticing |
| 4912 | # bar -> subdir/bar |
| 4913 | # as a rename and looking at it just as |
| 4914 | # delete bar |
| 4915 | # add subdir/bar |
| 4916 | # the directory rename of subdir/bar -> bar does not look |
| 4917 | # like a rename-to-self situation but a |
| 4918 | # rename-on-top-of-other-file situation. We do not want |
| 4919 | # stage 1 entries from an unrelated file, so we expect an |
| 4920 | # error about there being a file in the way. |
| 4921 | |
| 4922 | test_must_fail git -c merge.directoryRenames=conflict merge -s recursive B^0 >out && |
| 4923 | test_grep "CONFLICT (implicit dir rename).*bar in the way" out && |
| 4924 | |
| 4925 | test_path_is_missing bar && |
| 4926 | test_path_is_file subdir/bar && |
| 4927 | test_path_is_file baz && |
| 4928 | |
| 4929 | git ls-files >actual && |
| 4930 | uniq <actual >tracked && |
| 4931 | test_line_count = 3 tracked && |
| 4932 | |
| 4933 | git status --porcelain -uno >actual && |
| 4934 | cat >expect <<-\EOF && |
| 4935 | M baz |
| 4936 | R bar -> subdir/bar |
| 4937 | EOF |
| 4938 | test_cmp expect actual |
| 4939 | ) |
| 4940 | ' |
| 4941 | |
| 4942 | # Testcase 12k, Directory rename with sibling causes rename-to-self |
| 4943 | # Commit O: dirB/foo, dirA/{bar, baz_1} |
| 4944 | # Commit A: dirA/{foo, bar, baz_1} |
| 4945 | # Commit B: dirB/{foo, bar}, dirA/baz_2 |
| 4946 | # Expected: dirA/{foo, bar, baz_2}, with conflicts on dirA/bar vs. dirB/bar |
| 4947 | |
| 4948 | test_setup_12k () { |
| 4949 | git init 12k && |
| 4950 | ( |
| 4951 | cd 12k && |
| 4952 | |
| 4953 | mkdir dirA dirB && |
| 4954 | echo foo >dirB/foo && |
| 4955 | echo bar >dirA/bar && |
| 4956 | echo baz >dirA/baz && |
| 4957 | git add . && |
| 4958 | git commit -m orig && |
| 4959 | |
| 4960 | git branch O && |
| 4961 | git branch A && |
| 4962 | git branch B && |
| 4963 | |
| 4964 | git switch A && |
| 4965 | git mv dirB/* dirA/ && |
| 4966 | git commit -m A && |
| 4967 | |
| 4968 | git switch B && |
| 4969 | git mv dirA/bar dirB/bar && |
| 4970 | echo more baz >>dirA/baz && |
| 4971 | git add dirA/baz && |
| 4972 | git commit -m B |
| 4973 | ) |
| 4974 | } |
| 4975 | |
| 4976 | test_expect_success '12k: Directory rename with sibling causes rename-to-self' ' |
| 4977 | test_setup_12k && |
| 4978 | ( |
| 4979 | cd 12k && |
| 4980 | |
| 4981 | git checkout A^0 && |
| 4982 | |
| 4983 | # NOTE: A potentially better resolution would be for |
| 4984 | # dirA/bar -> dirB/bar |
| 4985 | # to use the directory rename (dirB/ -> dirA/) to become |
| 4986 | # dirA/bar -> dirA/bar |
| 4987 | # (a rename to self), and thus we end up with bar with |
| 4988 | # a path conflict (given merge.directoryRenames=conflict). |
| 4989 | # However, since the relevant renames optimization |
| 4990 | # prevents us from noticing |
| 4991 | # dirA/bar -> dirB/bar |
| 4992 | # as a rename and looking at it just as |
| 4993 | # delete dirA/bar |
| 4994 | # add dirB/bar |
| 4995 | # the directory rename of dirA/bar -> dirB/bar does |
| 4996 | # not look like a rename-to-self situation but a |
| 4997 | # rename-on-top-of-other-file situation. We do not want |
| 4998 | # stage 1 entries from an unrelated file, so we expect an |
| 4999 | # error about there being a file in the way. |
| 5000 |
Showing first 5,000 of 6,066 lines.
View raw