Merge branch 'en/unicode-in-refnames'
[git] / t / t6046-merge-skip-unneeded-updates.sh
1 #!/bin/sh
2
3 test_description="merge cases"
4
5 # The setup for all of them, pictorially, is:
6 #
7 #      A
8 #      o
9 #     / \
10 #  O o   ?
11 #     \ /
12 #      o
13 #      B
14 #
15 # To help make it easier to follow the flow of tests, they have been
16 # divided into sections and each test will start with a quick explanation
17 # of what commits O, A, and B contain.
18 #
19 # Notation:
20 #    z/{b,c}   means  files z/b and z/c both exist
21 #    x/d_1     means  file x/d exists with content d1.  (Purpose of the
22 #                     underscore notation is to differentiate different
23 #                     files that might be renamed into each other's paths.)
24
25 . ./test-lib.sh
26
27
28 ###########################################################################
29 # SECTION 1: Cases involving no renames (one side has subset of changes of
30 #            the other side)
31 ###########################################################################
32
33 # Testcase 1a, Changes on A, subset of changes on B
34 #   Commit O: b_1
35 #   Commit A: b_2
36 #   Commit B: b_3
37 #   Expected: b_2
38
39 test_expect_success '1a-setup: Modify(A)/Modify(B), change on B subset of A' '
40         test_create_repo 1a &&
41         (
42                 cd 1a &&
43
44                 test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
45                 git add b &&
46                 test_tick &&
47                 git commit -m "O" &&
48
49                 git branch O &&
50                 git branch A &&
51                 git branch B &&
52
53                 git checkout A &&
54                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
55                 git add b &&
56                 test_tick &&
57                 git commit -m "A" &&
58
59                 git checkout B &&
60                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
61                 git add b &&
62                 test_tick &&
63                 git commit -m "B"
64         )
65 '
66
67 test_expect_success '1a-check-L: Modify(A)/Modify(B), change on B subset of A' '
68         test_when_finished "git -C 1a reset --hard" &&
69         test_when_finished "git -C 1a clean -fd" &&
70         (
71                 cd 1a &&
72
73                 git checkout A^0 &&
74
75                 test-tool chmtime =31337 b &&
76                 test-tool chmtime -v +0 b >expected-mtime &&
77
78                 GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
79
80                 test_i18ngrep "Skipped b" out &&
81                 test_must_be_empty err &&
82
83                 test-tool chmtime -v +0 b >actual-mtime &&
84                 test_cmp expected-mtime actual-mtime &&
85
86                 git ls-files -s >index_files &&
87                 test_line_count = 1 index_files &&
88
89                 git rev-parse >actual HEAD:b &&
90                 git rev-parse >expect A:b &&
91                 test_cmp expect actual &&
92
93                 git hash-object b   >actual &&
94                 git rev-parse   A:b >expect &&
95                 test_cmp expect actual
96         )
97 '
98
99 test_expect_success '1a-check-R: Modify(A)/Modify(B), change on B subset of A' '
100         test_when_finished "git -C 1a reset --hard" &&
101         test_when_finished "git -C 1a clean -fd" &&
102         (
103                 cd 1a &&
104
105                 git checkout B^0 &&
106
107                 GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
108
109                 test_i18ngrep "Auto-merging b" out &&
110                 test_must_be_empty err &&
111
112                 git ls-files -s >index_files &&
113                 test_line_count = 1 index_files &&
114
115                 git rev-parse >actual HEAD:b &&
116                 git rev-parse >expect A:b &&
117                 test_cmp expect actual &&
118
119                 git hash-object b   >actual &&
120                 git rev-parse   A:b >expect &&
121                 test_cmp expect actual
122         )
123 '
124
125
126 ###########################################################################
127 # SECTION 2: Cases involving basic renames
128 ###########################################################################
129
130 # Testcase 2a, Changes on A, rename on B
131 #   Commit O: b_1
132 #   Commit A: b_2
133 #   Commit B: c_1
134 #   Expected: c_2
135
136 test_expect_success '2a-setup: Modify(A)/rename(B)' '
137         test_create_repo 2a &&
138         (
139                 cd 2a &&
140
141                 test_seq 1 10 >b &&
142                 git add b &&
143                 test_tick &&
144                 git commit -m "O" &&
145
146                 git branch O &&
147                 git branch A &&
148                 git branch B &&
149
150                 git checkout A &&
151                 test_seq 1 11 >b &&
152                 git add b &&
153                 test_tick &&
154                 git commit -m "A" &&
155
156                 git checkout B &&
157                 git mv b c &&
158                 test_tick &&
159                 git commit -m "B"
160         )
161 '
162
163 test_expect_success '2a-check-L: Modify/rename, merge into modify side' '
164         test_when_finished "git -C 2a reset --hard" &&
165         test_when_finished "git -C 2a clean -fd" &&
166         (
167                 cd 2a &&
168
169                 git checkout A^0 &&
170
171                 GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
172
173                 test_i18ngrep ! "Skipped c" out &&
174                 test_must_be_empty err &&
175
176                 git ls-files -s >index_files &&
177                 test_line_count = 1 index_files &&
178
179                 git rev-parse >actual HEAD:c &&
180                 git rev-parse >expect A:b &&
181                 test_cmp expect actual &&
182
183                 git hash-object c   >actual &&
184                 git rev-parse   A:b >expect &&
185                 test_cmp expect actual &&
186
187                 test_must_fail git rev-parse HEAD:b &&
188                 test_path_is_missing b
189         )
190 '
191
192 test_expect_success '2a-check-R: Modify/rename, merge into rename side' '
193         test_when_finished "git -C 2a reset --hard" &&
194         test_when_finished "git -C 2a clean -fd" &&
195         (
196                 cd 2a &&
197
198                 git checkout B^0 &&
199
200                 GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
201
202                 test_i18ngrep ! "Skipped c" out &&
203                 test_must_be_empty err &&
204
205                 git ls-files -s >index_files &&
206                 test_line_count = 1 index_files &&
207
208                 git rev-parse >actual HEAD:c &&
209                 git rev-parse >expect A:b &&
210                 test_cmp expect actual &&
211
212                 git hash-object c   >actual &&
213                 git rev-parse   A:b >expect &&
214                 test_cmp expect actual &&
215
216                 test_must_fail git rev-parse HEAD:b &&
217                 test_path_is_missing b
218         )
219 '
220
221 # Testcase 2b, Changed and renamed on A, subset of changes on B
222 #   Commit O: b_1
223 #   Commit A: c_2
224 #   Commit B: b_3
225 #   Expected: c_2
226
227 test_expect_success '2b-setup: Rename+Mod(A)/Mod(B), B mods subset of A' '
228         test_create_repo 2b &&
229         (
230                 cd 2b &&
231
232                 test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
233                 git add b &&
234                 test_tick &&
235                 git commit -m "O" &&
236
237                 git branch O &&
238                 git branch A &&
239                 git branch B &&
240
241                 git checkout A &&
242                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
243                 git add b &&
244                 git mv b c &&
245                 test_tick &&
246                 git commit -m "A" &&
247
248                 git checkout B &&
249                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
250                 git add b &&
251                 test_tick &&
252                 git commit -m "B"
253         )
254 '
255
256 test_expect_success '2b-check-L: Rename+Mod(A)/Mod(B), B mods subset of A' '
257         test_when_finished "git -C 2b reset --hard" &&
258         test_when_finished "git -C 2b clean -fd" &&
259         (
260                 cd 2b &&
261
262                 git checkout A^0 &&
263
264                 test-tool chmtime =31337 c &&
265                 test-tool chmtime -v +0 c >expected-mtime &&
266
267                 GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
268
269                 test_i18ngrep "Skipped c" out &&
270                 test_must_be_empty err &&
271
272                 test-tool chmtime -v +0 c >actual-mtime &&
273                 test_cmp expected-mtime actual-mtime &&
274
275                 git ls-files -s >index_files &&
276                 test_line_count = 1 index_files &&
277
278                 git rev-parse >actual HEAD:c &&
279                 git rev-parse >expect A:c &&
280                 test_cmp expect actual &&
281
282                 git hash-object c   >actual &&
283                 git rev-parse   A:c >expect &&
284                 test_cmp expect actual &&
285
286                 test_must_fail git rev-parse HEAD:b &&
287                 test_path_is_missing b
288         )
289 '
290
291 test_expect_success '2b-check-R: Rename+Mod(A)/Mod(B), B mods subset of A' '
292         test_when_finished "git -C 2b reset --hard" &&
293         test_when_finished "git -C 2b clean -fd" &&
294         (
295                 cd 2b &&
296
297                 git checkout B^0 &&
298
299                 GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
300
301                 test_i18ngrep "Auto-merging c" out &&
302                 test_must_be_empty err &&
303
304                 git ls-files -s >index_files &&
305                 test_line_count = 1 index_files &&
306
307                 git rev-parse >actual HEAD:c &&
308                 git rev-parse >expect A:c &&
309                 test_cmp expect actual &&
310
311                 git hash-object c   >actual &&
312                 git rev-parse   A:c >expect &&
313                 test_cmp expect actual &&
314
315                 test_must_fail git rev-parse HEAD:b &&
316                 test_path_is_missing b
317         )
318 '
319
320 # Testcase 2c, Changes on A, rename on B
321 #   Commit O: b_1
322 #   Commit A: b_2, c_3
323 #   Commit B: c_1
324 #   Expected: rename/add conflict c_2 vs c_3
325 #
326 #   NOTE: Since A modified b_1->b_2, and B renamed b_1->c_1, the threeway
327 #         merge of those files should result in c_2.  We then should have a
328 #         rename/add conflict between c_2 and c_3.  However, if we note in
329 #         merge_content() that A had the right contents (b_2 has same
330 #         contents as c_2, just at a different name), and that A had the
331 #         right path present (c_3 existed) and thus decides that it can
332 #         skip the update, then we're in trouble.  This test verifies we do
333 #         not make that particular mistake.
334
335 test_expect_success '2c-setup: Modify b & add c VS rename b->c' '
336         test_create_repo 2c &&
337         (
338                 cd 2c &&
339
340                 test_seq 1 10 >b &&
341                 git add b &&
342                 test_tick &&
343                 git commit -m "O" &&
344
345                 git branch O &&
346                 git branch A &&
347                 git branch B &&
348
349                 git checkout A &&
350                 test_seq 1 11 >b &&
351                 echo whatever >c &&
352                 git add b c &&
353                 test_tick &&
354                 git commit -m "A" &&
355
356                 git checkout B &&
357                 git mv b c &&
358                 test_tick &&
359                 git commit -m "B"
360         )
361 '
362
363 test_expect_success '2c-check: Modify b & add c VS rename b->c' '
364         (
365                 cd 2c &&
366
367                 git checkout A^0 &&
368
369                 GIT_MERGE_VERBOSITY=3 &&
370                 export GIT_MERGE_VERBOSITY &&
371                 test_must_fail git merge -s recursive B^0 >out 2>err &&
372
373                 test_i18ngrep "CONFLICT (rename/add): Rename b->c" out &&
374                 test_i18ngrep ! "Skipped c" out &&
375                 test_must_be_empty err
376
377                 # FIXME: rename/add conflicts are horribly broken right now;
378                 # when I get back to my patch series fixing it and
379                 # rename/rename(2to1) conflicts to bring them in line with
380                 # how add/add conflicts behave, then checks like the below
381                 # could be added.  But that patch series is waiting until
382                 # the rename-directory-detection series lands, which this
383                 # is part of.  And in the mean time, I do not want to further
384                 # enforce broken behavior.  So for now, the main test is the
385                 # one above that err is an empty file.
386
387                 #git ls-files -s >index_files &&
388                 #test_line_count = 2 index_files &&
389
390                 #git rev-parse >actual :2:c :3:c &&
391                 #git rev-parse >expect A:b  A:c  &&
392                 #test_cmp expect actual &&
393
394                 #git cat-file -p A:b >>merged &&
395                 #git cat-file -p A:c >>merge-me &&
396                 #>empty &&
397                 #test_must_fail git merge-file \
398                 #       -L "Temporary merge branch 1" \
399                 #       -L "" \
400                 #       -L "Temporary merge branch 2" \
401                 #       merged empty merge-me &&
402                 #sed -e "s/^\([<=>]\)/\1\1\1/" merged >merged-internal &&
403
404                 #git hash-object c               >actual &&
405                 #git hash-object merged-internal >expect &&
406                 #test_cmp expect actual &&
407
408                 #test_path_is_missing b
409         )
410 '
411
412
413 ###########################################################################
414 # SECTION 3: Cases involving directory renames
415 #
416 # NOTE:
417 #   Directory renames only apply when one side renames a directory, and the
418 #   other side adds or renames a path into that directory.  Applying the
419 #   directory rename to that new path creates a new pathname that didn't
420 #   exist on either side of history.  Thus, it is impossible for the
421 #   merge contents to already be at the right path, so all of these checks
422 #   exist just to make sure that updates are not skipped.
423 ###########################################################################
424
425 # Testcase 3a, Change + rename into dir foo on A, dir rename foo->bar on B
426 #   Commit O: bq_1, foo/whatever
427 #   Commit A: foo/{bq_2, whatever}
428 #   Commit B: bq_1, bar/whatever
429 #   Expected: bar/{bq_2, whatever}
430
431 test_expect_success '3a-setup: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
432         test_create_repo 3a &&
433         (
434                 cd 3a &&
435
436                 mkdir foo &&
437                 test_seq 1 10 >bq &&
438                 test_write_lines a b c d e f g h i j k >foo/whatever &&
439                 git add bq foo/whatever &&
440                 test_tick &&
441                 git commit -m "O" &&
442
443                 git branch O &&
444                 git branch A &&
445                 git branch B &&
446
447                 git checkout A &&
448                 test_seq 1 11 >bq &&
449                 git add bq &&
450                 git mv bq foo/ &&
451                 test_tick &&
452                 git commit -m "A" &&
453
454                 git checkout B &&
455                 git mv foo/ bar/ &&
456                 test_tick &&
457                 git commit -m "B"
458         )
459 '
460
461 test_expect_success '3a-check-L: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
462         test_when_finished "git -C 3a reset --hard" &&
463         test_when_finished "git -C 3a clean -fd" &&
464         (
465                 cd 3a &&
466
467                 git checkout A^0 &&
468
469                 GIT_MERGE_VERBOSITY=3 git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err &&
470
471                 test_i18ngrep ! "Skipped bar/bq" out &&
472                 test_must_be_empty err &&
473
474                 git ls-files -s >index_files &&
475                 test_line_count = 2 index_files &&
476
477                 git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
478                 git rev-parse >expect A:foo/bq    A:foo/whatever &&
479                 test_cmp expect actual &&
480
481                 git hash-object bar/bq   bar/whatever   >actual &&
482                 git rev-parse   A:foo/bq A:foo/whatever >expect &&
483                 test_cmp expect actual &&
484
485                 test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
486                 test_path_is_missing bq foo/bq foo/whatever
487         )
488 '
489
490 test_expect_success '3a-check-R: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
491         test_when_finished "git -C 3a reset --hard" &&
492         test_when_finished "git -C 3a clean -fd" &&
493         (
494                 cd 3a &&
495
496                 git checkout B^0 &&
497
498                 GIT_MERGE_VERBOSITY=3 git -c merge.directoryRenames=true merge -s recursive A^0 >out 2>err &&
499
500                 test_i18ngrep ! "Skipped bar/bq" out &&
501                 test_must_be_empty err &&
502
503                 git ls-files -s >index_files &&
504                 test_line_count = 2 index_files &&
505
506                 git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
507                 git rev-parse >expect A:foo/bq    A:foo/whatever &&
508                 test_cmp expect actual &&
509
510                 git hash-object bar/bq   bar/whatever   >actual &&
511                 git rev-parse   A:foo/bq A:foo/whatever >expect &&
512                 test_cmp expect actual &&
513
514                 test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
515                 test_path_is_missing bq foo/bq foo/whatever
516         )
517 '
518
519 # Testcase 3b, rename into dir foo on A, dir rename foo->bar + change on B
520 #   Commit O: bq_1, foo/whatever
521 #   Commit A: foo/{bq_1, whatever}
522 #   Commit B: bq_2, bar/whatever
523 #   Expected: bar/{bq_2, whatever}
524
525 test_expect_success '3b-setup: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
526         test_create_repo 3b &&
527         (
528                 cd 3b &&
529
530                 mkdir foo &&
531                 test_seq 1 10 >bq &&
532                 test_write_lines a b c d e f g h i j k >foo/whatever &&
533                 git add bq foo/whatever &&
534                 test_tick &&
535                 git commit -m "O" &&
536
537                 git branch O &&
538                 git branch A &&
539                 git branch B &&
540
541                 git checkout A &&
542                 git mv bq foo/ &&
543                 test_tick &&
544                 git commit -m "A" &&
545
546                 git checkout B &&
547                 test_seq 1 11 >bq &&
548                 git add bq &&
549                 git mv foo/ bar/ &&
550                 test_tick &&
551                 git commit -m "B"
552         )
553 '
554
555 test_expect_success '3b-check-L: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
556         test_when_finished "git -C 3b reset --hard" &&
557         test_when_finished "git -C 3b clean -fd" &&
558         (
559                 cd 3b &&
560
561                 git checkout A^0 &&
562
563                 GIT_MERGE_VERBOSITY=3 git -c merge.directoryRenames=true merge -s recursive B^0 >out 2>err &&
564
565                 test_i18ngrep ! "Skipped bar/bq" out &&
566                 test_must_be_empty err &&
567
568                 git ls-files -s >index_files &&
569                 test_line_count = 2 index_files &&
570
571                 git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
572                 git rev-parse >expect B:bq        A:foo/whatever &&
573                 test_cmp expect actual &&
574
575                 git hash-object bar/bq bar/whatever   >actual &&
576                 git rev-parse   B:bq   A:foo/whatever >expect &&
577                 test_cmp expect actual &&
578
579                 test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
580                 test_path_is_missing bq foo/bq foo/whatever
581         )
582 '
583
584 test_expect_success '3b-check-R: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
585         test_when_finished "git -C 3b reset --hard" &&
586         test_when_finished "git -C 3b clean -fd" &&
587         (
588                 cd 3b &&
589
590                 git checkout B^0 &&
591
592                 GIT_MERGE_VERBOSITY=3 git -c merge.directoryRenames=true merge -s recursive A^0 >out 2>err &&
593
594                 test_i18ngrep ! "Skipped bar/bq" out &&
595                 test_must_be_empty err &&
596
597                 git ls-files -s >index_files &&
598                 test_line_count = 2 index_files &&
599
600                 git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
601                 git rev-parse >expect B:bq        A:foo/whatever &&
602                 test_cmp expect actual &&
603
604                 git hash-object bar/bq bar/whatever   >actual &&
605                 git rev-parse   B:bq   A:foo/whatever >expect &&
606                 test_cmp expect actual &&
607
608                 test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
609                 test_path_is_missing bq foo/bq foo/whatever
610         )
611 '
612
613 ###########################################################################
614 # SECTION 4: Cases involving dirty changes
615 ###########################################################################
616
617 # Testcase 4a, Changed on A, subset of changes on B, locally modified
618 #   Commit O: b_1
619 #   Commit A: b_2
620 #   Commit B: b_3
621 #   Working copy: b_4
622 #   Expected: b_2 for merge, b_4 in working copy
623
624 test_expect_success '4a-setup: Change on A, change on B subset of A, dirty mods present' '
625         test_create_repo 4a &&
626         (
627                 cd 4a &&
628
629                 test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
630                 git add b &&
631                 test_tick &&
632                 git commit -m "O" &&
633
634                 git branch O &&
635                 git branch A &&
636                 git branch B &&
637
638                 git checkout A &&
639                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
640                 git add b &&
641                 test_tick &&
642                 git commit -m "A" &&
643
644                 git checkout B &&
645                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
646                 git add b &&
647                 test_tick &&
648                 git commit -m "B"
649         )
650 '
651
652 # NOTE: For as long as we continue using unpack_trees() without index_only
653 #   set to true, it will error out on a case like this claiming the the locally
654 #   modified file would be overwritten by the merge.  Getting this testcase
655 #   correct requires doing the merge in-memory first, then realizing that no
656 #   updates to the file are necessary, and thus that we can just leave the path
657 #   alone.
658 test_expect_failure '4a-check: Change on A, change on B subset of A, dirty mods present' '
659         test_when_finished "git -C 4a reset --hard" &&
660         test_when_finished "git -C 4a clean -fd" &&
661         (
662                 cd 4a &&
663
664                 git checkout A^0 &&
665                 echo "File rewritten" >b &&
666
667                 test-tool chmtime =31337 b &&
668                 test-tool chmtime -v +0 b >expected-mtime &&
669
670                 GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
671
672                 test_i18ngrep "Skipped b" out &&
673                 test_must_be_empty err &&
674
675                 test-tool chmtime -v +0 b >actual-mtime &&
676                 test_cmp expected-mtime actual-mtime &&
677
678                 git ls-files -s >index_files &&
679                 test_line_count = 1 index_files &&
680
681                 git rev-parse >actual :0:b &&
682                 git rev-parse >expect A:b &&
683                 test_cmp expect actual &&
684
685                 git hash-object b >actual &&
686                 echo "File rewritten" | git hash-object --stdin >expect &&
687                 test_cmp expect actual
688         )
689 '
690
691 # Testcase 4b, Changed+renamed on A, subset of changes on B, locally modified
692 #   Commit O: b_1
693 #   Commit A: c_2
694 #   Commit B: b_3
695 #   Working copy: c_4
696 #   Expected: c_2
697
698 test_expect_success '4b-setup: Rename+Mod(A)/Mod(B), change on B subset of A, dirty mods present' '
699         test_create_repo 4b &&
700         (
701                 cd 4b &&
702
703                 test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
704                 git add b &&
705                 test_tick &&
706                 git commit -m "O" &&
707
708                 git branch O &&
709                 git branch A &&
710                 git branch B &&
711
712                 git checkout A &&
713                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
714                 git add b &&
715                 git mv b c &&
716                 test_tick &&
717                 git commit -m "A" &&
718
719                 git checkout B &&
720                 test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
721                 git add b &&
722                 test_tick &&
723                 git commit -m "B"
724         )
725 '
726
727 test_expect_success '4b-check: Rename+Mod(A)/Mod(B), change on B subset of A, dirty mods present' '
728         test_when_finished "git -C 4b reset --hard" &&
729         test_when_finished "git -C 4b clean -fd" &&
730         (
731                 cd 4b &&
732
733                 git checkout A^0 &&
734                 echo "File rewritten" >c &&
735
736                 test-tool chmtime =31337 c &&
737                 test-tool chmtime -v +0 c >expected-mtime &&
738
739                 GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
740
741                 test_i18ngrep "Skipped c" out &&
742                 test_must_be_empty err &&
743
744                 test-tool chmtime -v +0 c >actual-mtime &&
745                 test_cmp expected-mtime actual-mtime &&
746
747                 git ls-files -s >index_files &&
748                 test_line_count = 1 index_files &&
749
750                 git rev-parse >actual :0:c &&
751                 git rev-parse >expect A:c &&
752                 test_cmp expect actual &&
753
754                 git hash-object c >actual &&
755                 echo "File rewritten" | git hash-object --stdin >expect &&
756                 test_cmp expect actual &&
757
758                 test_must_fail git rev-parse HEAD:b &&
759                 test_path_is_missing b
760         )
761 '
762
763 test_done