2018-04-19 17:58:19 +00:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
test_description="merge cases"
|
|
|
|
|
|
|
|
# The setup for all of them, pictorially, is:
|
|
|
|
#
|
|
|
|
# A
|
|
|
|
# o
|
|
|
|
# / \
|
|
|
|
# O o ?
|
|
|
|
# \ /
|
|
|
|
# o
|
|
|
|
# B
|
|
|
|
#
|
|
|
|
# To help make it easier to follow the flow of tests, they have been
|
|
|
|
# divided into sections and each test will start with a quick explanation
|
|
|
|
# of what commits O, A, and B contain.
|
|
|
|
#
|
|
|
|
# Notation:
|
|
|
|
# z/{b,c} means files z/b and z/c both exist
|
|
|
|
# x/d_1 means file x/d exists with content d1. (Purpose of the
|
|
|
|
# underscore notation is to differentiate different
|
|
|
|
# files that might be renamed into each other's paths.)
|
|
|
|
|
|
|
|
. ./test-lib.sh
|
|
|
|
|
|
|
|
|
|
|
|
###########################################################################
|
|
|
|
# SECTION 1: Cases involving no renames (one side has subset of changes of
|
|
|
|
# the other side)
|
|
|
|
###########################################################################
|
|
|
|
|
|
|
|
# Testcase 1a, Changes on A, subset of changes on B
|
|
|
|
# Commit O: b_1
|
|
|
|
# Commit A: b_2
|
|
|
|
# Commit B: b_3
|
|
|
|
# Expected: b_2
|
|
|
|
|
|
|
|
test_expect_success '1a-setup: Modify(A)/Modify(B), change on B subset of A' '
|
|
|
|
test_create_repo 1a &&
|
|
|
|
(
|
|
|
|
cd 1a &&
|
|
|
|
|
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
merge-recursive: fix check for skipability of working tree updates
The can-working-tree-updates-be-skipped check has had a long and blemished
history. The update can be skipped iff:
a) The merge is clean
b) The merge matches what was in HEAD (content, mode, pathname)
c) The target path is usable (i.e. not involved in D/F conflict)
Traditionally, we split b into parts:
b1) The merged result matches the content and mode found in HEAD
b2) The merged target path existed in HEAD
Steps a & b1 are easy to check; we have always gotten those right. While
it is easy to overlook step c, this was fixed seven years ago with commit
4ab9a157d069 ("merge_content(): Check whether D/F conflicts are still
present", 2010-09-20). merge-recursive didn't have a readily available
way to directly check step b2, so various approximations were used:
* In commit b2c8c0a76274 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-02-28), it was noted that although
the code claimed it was skipping the update, it did not actually skip
the update. The code was made to skip it, but used lstat(path, ...)
as an approximation to path-was-tracked-in-index-before-merge.
* In commit 5b448b853030 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-08-11), the problem with using
lstat was noted. It was changed to the approximation
path2 && strcmp(path, path2)
which is also wrong. !path2 || strcmp(path, path2) would have been
better, but would have fallen short with directory renames.
* In c5b761fb2711 ("merge-recursive: ensure we write updates for
directory-renamed file", 2018-02-14), the problem with the previous
approximation was noted and changed to
was_tracked(path)
That looks close to what we were trying to answer, but was_tracked()
as implemented at the time should have been named is_tracked(); it
returned something different than what we were looking for.
* To make matters more complex, fixing was_tracked() isn't sufficient
because the splitting of b into b1 and b2 is wrong. Consider the
following merge with a rename/add conflict:
side A: modify foo, add unrelated bar
side B: rename foo->bar (but don't modify the mode or contents)
In this case, the three-way merge of original foo, A's foo, and B's
bar will result in a desired pathname of bar with the same
mode/contents that A had for foo. Thus, A had the right mode and
contents for the file, and it had the right pathname present (namely,
bar), but the bar that was present was unrelated to the contents, so
the working tree update was not skippable.
Fix this by introducing a new function:
was_tracked_and_matches(o, path, &mfi.oid, mfi.mode)
and use it to directly check for condition b.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-19 17:58:23 +00:00
|
|
|
test_expect_success '1a-check-L: Modify(A)/Modify(B), change on B subset of A' '
|
2018-04-19 17:58:19 +00:00
|
|
|
test_when_finished "git -C 1a reset --hard" &&
|
|
|
|
test_when_finished "git -C 1a clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 1a &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
|
|
|
|
test-tool chmtime =31337 b &&
|
|
|
|
test-tool chmtime -v +0 b >expected-mtime &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep "Skipped b" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
test-tool chmtime -v +0 b >actual-mtime &&
|
|
|
|
test_cmp expected-mtime actual-mtime &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:b &&
|
|
|
|
git rev-parse >expect A:b &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object b >actual &&
|
|
|
|
git rev-parse A:b >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '1a-check-R: Modify(A)/Modify(B), change on B subset of A' '
|
|
|
|
test_when_finished "git -C 1a reset --hard" &&
|
|
|
|
test_when_finished "git -C 1a clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 1a &&
|
|
|
|
|
|
|
|
git checkout B^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep "Auto-merging b" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:b &&
|
|
|
|
git rev-parse >expect A:b &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object b >actual &&
|
|
|
|
git rev-parse A:b >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
|
|
###########################################################################
|
|
|
|
# SECTION 2: Cases involving basic renames
|
|
|
|
###########################################################################
|
|
|
|
|
|
|
|
# Testcase 2a, Changes on A, rename on B
|
|
|
|
# Commit O: b_1
|
|
|
|
# Commit A: b_2
|
|
|
|
# Commit B: c_1
|
|
|
|
# Expected: c_2
|
|
|
|
|
|
|
|
test_expect_success '2a-setup: Modify(A)/rename(B)' '
|
|
|
|
test_create_repo 2a &&
|
|
|
|
(
|
|
|
|
cd 2a &&
|
|
|
|
|
|
|
|
test_seq 1 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
test_seq 1 11 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
git mv b c &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
merge-recursive: fix check for skipability of working tree updates
The can-working-tree-updates-be-skipped check has had a long and blemished
history. The update can be skipped iff:
a) The merge is clean
b) The merge matches what was in HEAD (content, mode, pathname)
c) The target path is usable (i.e. not involved in D/F conflict)
Traditionally, we split b into parts:
b1) The merged result matches the content and mode found in HEAD
b2) The merged target path existed in HEAD
Steps a & b1 are easy to check; we have always gotten those right. While
it is easy to overlook step c, this was fixed seven years ago with commit
4ab9a157d069 ("merge_content(): Check whether D/F conflicts are still
present", 2010-09-20). merge-recursive didn't have a readily available
way to directly check step b2, so various approximations were used:
* In commit b2c8c0a76274 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-02-28), it was noted that although
the code claimed it was skipping the update, it did not actually skip
the update. The code was made to skip it, but used lstat(path, ...)
as an approximation to path-was-tracked-in-index-before-merge.
* In commit 5b448b853030 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-08-11), the problem with using
lstat was noted. It was changed to the approximation
path2 && strcmp(path, path2)
which is also wrong. !path2 || strcmp(path, path2) would have been
better, but would have fallen short with directory renames.
* In c5b761fb2711 ("merge-recursive: ensure we write updates for
directory-renamed file", 2018-02-14), the problem with the previous
approximation was noted and changed to
was_tracked(path)
That looks close to what we were trying to answer, but was_tracked()
as implemented at the time should have been named is_tracked(); it
returned something different than what we were looking for.
* To make matters more complex, fixing was_tracked() isn't sufficient
because the splitting of b into b1 and b2 is wrong. Consider the
following merge with a rename/add conflict:
side A: modify foo, add unrelated bar
side B: rename foo->bar (but don't modify the mode or contents)
In this case, the three-way merge of original foo, A's foo, and B's
bar will result in a desired pathname of bar with the same
mode/contents that A had for foo. Thus, A had the right mode and
contents for the file, and it had the right pathname present (namely,
bar), but the bar that was present was unrelated to the contents, so
the working tree update was not skippable.
Fix this by introducing a new function:
was_tracked_and_matches(o, path, &mfi.oid, mfi.mode)
and use it to directly check for condition b.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-19 17:58:23 +00:00
|
|
|
test_expect_success '2a-check-L: Modify/rename, merge into modify side' '
|
2018-04-19 17:58:19 +00:00
|
|
|
test_when_finished "git -C 2a reset --hard" &&
|
|
|
|
test_when_finished "git -C 2a clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 2a &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep ! "Skipped c" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:c &&
|
|
|
|
git rev-parse >expect A:b &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object c >actual &&
|
|
|
|
git rev-parse A:b >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:b &&
|
|
|
|
test_path_is_missing b
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '2a-check-R: Modify/rename, merge into rename side' '
|
|
|
|
test_when_finished "git -C 2a reset --hard" &&
|
|
|
|
test_when_finished "git -C 2a clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 2a &&
|
|
|
|
|
|
|
|
git checkout B^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep ! "Skipped c" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:c &&
|
|
|
|
git rev-parse >expect A:b &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object c >actual &&
|
|
|
|
git rev-parse A:b >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:b &&
|
|
|
|
test_path_is_missing b
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
# Testcase 2b, Changed and renamed on A, subset of changes on B
|
|
|
|
# Commit O: b_1
|
|
|
|
# Commit A: c_2
|
|
|
|
# Commit B: b_3
|
|
|
|
# Expected: c_2
|
|
|
|
|
|
|
|
test_expect_success '2b-setup: Rename+Mod(A)/Mod(B), B mods subset of A' '
|
|
|
|
test_create_repo 2b &&
|
|
|
|
(
|
|
|
|
cd 2b &&
|
|
|
|
|
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
|
|
|
|
git add b &&
|
|
|
|
git mv b c &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '2b-check-L: Rename+Mod(A)/Mod(B), B mods subset of A' '
|
|
|
|
test_when_finished "git -C 2b reset --hard" &&
|
|
|
|
test_when_finished "git -C 2b clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 2b &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
|
|
|
|
test-tool chmtime =31337 c &&
|
|
|
|
test-tool chmtime -v +0 c >expected-mtime &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep "Skipped c" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
test-tool chmtime -v +0 c >actual-mtime &&
|
|
|
|
test_cmp expected-mtime actual-mtime &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:c &&
|
|
|
|
git rev-parse >expect A:c &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object c >actual &&
|
|
|
|
git rev-parse A:c >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:b &&
|
|
|
|
test_path_is_missing b
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '2b-check-R: Rename+Mod(A)/Mod(B), B mods subset of A' '
|
|
|
|
test_when_finished "git -C 2b reset --hard" &&
|
|
|
|
test_when_finished "git -C 2b clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 2b &&
|
|
|
|
|
|
|
|
git checkout B^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep "Auto-merging c" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:c &&
|
|
|
|
git rev-parse >expect A:c &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object c >actual &&
|
|
|
|
git rev-parse A:c >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:b &&
|
|
|
|
test_path_is_missing b
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
# Testcase 2c, Changes on A, rename on B
|
|
|
|
# Commit O: b_1
|
|
|
|
# Commit A: b_2, c_3
|
|
|
|
# Commit B: c_1
|
|
|
|
# Expected: rename/add conflict c_2 vs c_3
|
|
|
|
#
|
|
|
|
# NOTE: Since A modified b_1->b_2, and B renamed b_1->c_1, the threeway
|
|
|
|
# merge of those files should result in c_2. We then should have a
|
|
|
|
# rename/add conflict between c_2 and c_3. However, if we note in
|
|
|
|
# merge_content() that A had the right contents (b_2 has same
|
|
|
|
# contents as c_2, just at a different name), and that A had the
|
|
|
|
# right path present (c_3 existed) and thus decides that it can
|
|
|
|
# skip the update, then we're in trouble. This test verifies we do
|
|
|
|
# not make that particular mistake.
|
|
|
|
|
|
|
|
test_expect_success '2c-setup: Modify b & add c VS rename b->c' '
|
|
|
|
test_create_repo 2c &&
|
|
|
|
(
|
|
|
|
cd 2c &&
|
|
|
|
|
|
|
|
test_seq 1 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
test_seq 1 11 >b &&
|
|
|
|
echo whatever >c &&
|
|
|
|
git add b c &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
git mv b c &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
merge-recursive: fix check for skipability of working tree updates
The can-working-tree-updates-be-skipped check has had a long and blemished
history. The update can be skipped iff:
a) The merge is clean
b) The merge matches what was in HEAD (content, mode, pathname)
c) The target path is usable (i.e. not involved in D/F conflict)
Traditionally, we split b into parts:
b1) The merged result matches the content and mode found in HEAD
b2) The merged target path existed in HEAD
Steps a & b1 are easy to check; we have always gotten those right. While
it is easy to overlook step c, this was fixed seven years ago with commit
4ab9a157d069 ("merge_content(): Check whether D/F conflicts are still
present", 2010-09-20). merge-recursive didn't have a readily available
way to directly check step b2, so various approximations were used:
* In commit b2c8c0a76274 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-02-28), it was noted that although
the code claimed it was skipping the update, it did not actually skip
the update. The code was made to skip it, but used lstat(path, ...)
as an approximation to path-was-tracked-in-index-before-merge.
* In commit 5b448b853030 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-08-11), the problem with using
lstat was noted. It was changed to the approximation
path2 && strcmp(path, path2)
which is also wrong. !path2 || strcmp(path, path2) would have been
better, but would have fallen short with directory renames.
* In c5b761fb2711 ("merge-recursive: ensure we write updates for
directory-renamed file", 2018-02-14), the problem with the previous
approximation was noted and changed to
was_tracked(path)
That looks close to what we were trying to answer, but was_tracked()
as implemented at the time should have been named is_tracked(); it
returned something different than what we were looking for.
* To make matters more complex, fixing was_tracked() isn't sufficient
because the splitting of b into b1 and b2 is wrong. Consider the
following merge with a rename/add conflict:
side A: modify foo, add unrelated bar
side B: rename foo->bar (but don't modify the mode or contents)
In this case, the three-way merge of original foo, A's foo, and B's
bar will result in a desired pathname of bar with the same
mode/contents that A had for foo. Thus, A had the right mode and
contents for the file, and it had the right pathname present (namely,
bar), but the bar that was present was unrelated to the contents, so
the working tree update was not skippable.
Fix this by introducing a new function:
was_tracked_and_matches(o, path, &mfi.oid, mfi.mode)
and use it to directly check for condition b.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-19 17:58:23 +00:00
|
|
|
test_expect_success '2c-check: Modify b & add c VS rename b->c' '
|
2018-04-19 17:58:19 +00:00
|
|
|
(
|
|
|
|
cd 2c &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
|
2018-07-13 05:52:02 +00:00
|
|
|
GIT_MERGE_VERBOSITY=3 &&
|
|
|
|
export GIT_MERGE_VERBOSITY &&
|
|
|
|
test_must_fail git merge -s recursive B^0 >out 2>err &&
|
2018-04-19 17:58:19 +00:00
|
|
|
|
|
|
|
test_i18ngrep "CONFLICT (rename/add): Rename b->c" out &&
|
|
|
|
test_i18ngrep ! "Skipped c" out &&
|
|
|
|
test_must_be_empty err
|
|
|
|
|
|
|
|
# FIXME: rename/add conflicts are horribly broken right now;
|
|
|
|
# when I get back to my patch series fixing it and
|
|
|
|
# rename/rename(2to1) conflicts to bring them in line with
|
|
|
|
# how add/add conflicts behave, then checks like the below
|
|
|
|
# could be added. But that patch series is waiting until
|
|
|
|
# the rename-directory-detection series lands, which this
|
|
|
|
# is part of. And in the mean time, I do not want to further
|
|
|
|
# enforce broken behavior. So for now, the main test is the
|
|
|
|
# one above that err is an empty file.
|
|
|
|
|
|
|
|
#git ls-files -s >index_files &&
|
|
|
|
#test_line_count = 2 index_files &&
|
|
|
|
|
|
|
|
#git rev-parse >actual :2:c :3:c &&
|
|
|
|
#git rev-parse >expect A:b A:c &&
|
|
|
|
#test_cmp expect actual &&
|
|
|
|
|
|
|
|
#git cat-file -p A:b >>merged &&
|
|
|
|
#git cat-file -p A:c >>merge-me &&
|
|
|
|
#>empty &&
|
|
|
|
#test_must_fail git merge-file \
|
|
|
|
# -L "Temporary merge branch 1" \
|
|
|
|
# -L "" \
|
|
|
|
# -L "Temporary merge branch 2" \
|
|
|
|
# merged empty merge-me &&
|
|
|
|
#sed -e "s/^\([<=>]\)/\1\1\1/" merged >merged-internal &&
|
|
|
|
|
|
|
|
#git hash-object c >actual &&
|
|
|
|
#git hash-object merged-internal >expect &&
|
|
|
|
#test_cmp expect actual &&
|
|
|
|
|
|
|
|
#test_path_is_missing b
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
|
|
###########################################################################
|
|
|
|
# SECTION 3: Cases involving directory renames
|
|
|
|
#
|
|
|
|
# NOTE:
|
|
|
|
# Directory renames only apply when one side renames a directory, and the
|
|
|
|
# other side adds or renames a path into that directory. Applying the
|
|
|
|
# directory rename to that new path creates a new pathname that didn't
|
|
|
|
# exist on either side of history. Thus, it is impossible for the
|
|
|
|
# merge contents to already be at the right path, so all of these checks
|
|
|
|
# exist just to make sure that updates are not skipped.
|
|
|
|
###########################################################################
|
|
|
|
|
|
|
|
# Testcase 3a, Change + rename into dir foo on A, dir rename foo->bar on B
|
|
|
|
# Commit O: bq_1, foo/whatever
|
|
|
|
# Commit A: foo/{bq_2, whatever}
|
|
|
|
# Commit B: bq_1, bar/whatever
|
|
|
|
# Expected: bar/{bq_2, whatever}
|
|
|
|
|
|
|
|
test_expect_success '3a-setup: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
|
|
|
|
test_create_repo 3a &&
|
|
|
|
(
|
|
|
|
cd 3a &&
|
|
|
|
|
|
|
|
mkdir foo &&
|
|
|
|
test_seq 1 10 >bq &&
|
|
|
|
test_write_lines a b c d e f g h i j k >foo/whatever &&
|
|
|
|
git add bq foo/whatever &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
test_seq 1 11 >bq &&
|
|
|
|
git add bq &&
|
|
|
|
git mv bq foo/ &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
git mv foo/ bar/ &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
merge-recursive: fix check for skipability of working tree updates
The can-working-tree-updates-be-skipped check has had a long and blemished
history. The update can be skipped iff:
a) The merge is clean
b) The merge matches what was in HEAD (content, mode, pathname)
c) The target path is usable (i.e. not involved in D/F conflict)
Traditionally, we split b into parts:
b1) The merged result matches the content and mode found in HEAD
b2) The merged target path existed in HEAD
Steps a & b1 are easy to check; we have always gotten those right. While
it is easy to overlook step c, this was fixed seven years ago with commit
4ab9a157d069 ("merge_content(): Check whether D/F conflicts are still
present", 2010-09-20). merge-recursive didn't have a readily available
way to directly check step b2, so various approximations were used:
* In commit b2c8c0a76274 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-02-28), it was noted that although
the code claimed it was skipping the update, it did not actually skip
the update. The code was made to skip it, but used lstat(path, ...)
as an approximation to path-was-tracked-in-index-before-merge.
* In commit 5b448b853030 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-08-11), the problem with using
lstat was noted. It was changed to the approximation
path2 && strcmp(path, path2)
which is also wrong. !path2 || strcmp(path, path2) would have been
better, but would have fallen short with directory renames.
* In c5b761fb2711 ("merge-recursive: ensure we write updates for
directory-renamed file", 2018-02-14), the problem with the previous
approximation was noted and changed to
was_tracked(path)
That looks close to what we were trying to answer, but was_tracked()
as implemented at the time should have been named is_tracked(); it
returned something different than what we were looking for.
* To make matters more complex, fixing was_tracked() isn't sufficient
because the splitting of b into b1 and b2 is wrong. Consider the
following merge with a rename/add conflict:
side A: modify foo, add unrelated bar
side B: rename foo->bar (but don't modify the mode or contents)
In this case, the three-way merge of original foo, A's foo, and B's
bar will result in a desired pathname of bar with the same
mode/contents that A had for foo. Thus, A had the right mode and
contents for the file, and it had the right pathname present (namely,
bar), but the bar that was present was unrelated to the contents, so
the working tree update was not skippable.
Fix this by introducing a new function:
was_tracked_and_matches(o, path, &mfi.oid, mfi.mode)
and use it to directly check for condition b.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-19 17:58:23 +00:00
|
|
|
test_expect_success '3a-check-L: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
|
2018-04-19 17:58:19 +00:00
|
|
|
test_when_finished "git -C 3a reset --hard" &&
|
|
|
|
test_when_finished "git -C 3a clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 3a &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep ! "Skipped bar/bq" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 2 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
|
|
|
|
git rev-parse >expect A:foo/bq A:foo/whatever &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object bar/bq bar/whatever >actual &&
|
|
|
|
git rev-parse A:foo/bq A:foo/whatever >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
|
|
|
|
test_path_is_missing bq foo/bq foo/whatever
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '3a-check-R: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
|
|
|
|
test_when_finished "git -C 3a reset --hard" &&
|
|
|
|
test_when_finished "git -C 3a clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 3a &&
|
|
|
|
|
|
|
|
git checkout B^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep ! "Skipped bar/bq" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 2 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
|
|
|
|
git rev-parse >expect A:foo/bq A:foo/whatever &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object bar/bq bar/whatever >actual &&
|
|
|
|
git rev-parse A:foo/bq A:foo/whatever >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
|
|
|
|
test_path_is_missing bq foo/bq foo/whatever
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
# Testcase 3b, rename into dir foo on A, dir rename foo->bar + change on B
|
|
|
|
# Commit O: bq_1, foo/whatever
|
|
|
|
# Commit A: foo/{bq_1, whatever}
|
|
|
|
# Commit B: bq_2, bar/whatever
|
|
|
|
# Expected: bar/{bq_2, whatever}
|
|
|
|
|
|
|
|
test_expect_success '3b-setup: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
|
|
|
|
test_create_repo 3b &&
|
|
|
|
(
|
|
|
|
cd 3b &&
|
|
|
|
|
|
|
|
mkdir foo &&
|
|
|
|
test_seq 1 10 >bq &&
|
|
|
|
test_write_lines a b c d e f g h i j k >foo/whatever &&
|
|
|
|
git add bq foo/whatever &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
git mv bq foo/ &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
test_seq 1 11 >bq &&
|
|
|
|
git add bq &&
|
|
|
|
git mv foo/ bar/ &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '3b-check-L: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
|
|
|
|
test_when_finished "git -C 3b reset --hard" &&
|
|
|
|
test_when_finished "git -C 3b clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 3b &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep ! "Skipped bar/bq" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 2 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
|
|
|
|
git rev-parse >expect B:bq A:foo/whatever &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object bar/bq bar/whatever >actual &&
|
|
|
|
git rev-parse B:bq A:foo/whatever >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
|
|
|
|
test_path_is_missing bq foo/bq foo/whatever
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
merge-recursive: fix check for skipability of working tree updates
The can-working-tree-updates-be-skipped check has had a long and blemished
history. The update can be skipped iff:
a) The merge is clean
b) The merge matches what was in HEAD (content, mode, pathname)
c) The target path is usable (i.e. not involved in D/F conflict)
Traditionally, we split b into parts:
b1) The merged result matches the content and mode found in HEAD
b2) The merged target path existed in HEAD
Steps a & b1 are easy to check; we have always gotten those right. While
it is easy to overlook step c, this was fixed seven years ago with commit
4ab9a157d069 ("merge_content(): Check whether D/F conflicts are still
present", 2010-09-20). merge-recursive didn't have a readily available
way to directly check step b2, so various approximations were used:
* In commit b2c8c0a76274 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-02-28), it was noted that although
the code claimed it was skipping the update, it did not actually skip
the update. The code was made to skip it, but used lstat(path, ...)
as an approximation to path-was-tracked-in-index-before-merge.
* In commit 5b448b853030 ("merge-recursive: When we detect we can skip
an update, actually skip it", 2011-08-11), the problem with using
lstat was noted. It was changed to the approximation
path2 && strcmp(path, path2)
which is also wrong. !path2 || strcmp(path, path2) would have been
better, but would have fallen short with directory renames.
* In c5b761fb2711 ("merge-recursive: ensure we write updates for
directory-renamed file", 2018-02-14), the problem with the previous
approximation was noted and changed to
was_tracked(path)
That looks close to what we were trying to answer, but was_tracked()
as implemented at the time should have been named is_tracked(); it
returned something different than what we were looking for.
* To make matters more complex, fixing was_tracked() isn't sufficient
because the splitting of b into b1 and b2 is wrong. Consider the
following merge with a rename/add conflict:
side A: modify foo, add unrelated bar
side B: rename foo->bar (but don't modify the mode or contents)
In this case, the three-way merge of original foo, A's foo, and B's
bar will result in a desired pathname of bar with the same
mode/contents that A had for foo. Thus, A had the right mode and
contents for the file, and it had the right pathname present (namely,
bar), but the bar that was present was unrelated to the contents, so
the working tree update was not skippable.
Fix this by introducing a new function:
was_tracked_and_matches(o, path, &mfi.oid, mfi.mode)
and use it to directly check for condition b.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-19 17:58:23 +00:00
|
|
|
test_expect_success '3b-check-R: bq_1->foo/bq_2 on A, foo/->bar/ on B' '
|
2018-04-19 17:58:19 +00:00
|
|
|
test_when_finished "git -C 3b reset --hard" &&
|
|
|
|
test_when_finished "git -C 3b clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 3b &&
|
|
|
|
|
|
|
|
git checkout B^0 &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive A^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep ! "Skipped bar/bq" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 2 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual HEAD:bar/bq HEAD:bar/whatever &&
|
|
|
|
git rev-parse >expect B:bq A:foo/whatever &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object bar/bq bar/whatever >actual &&
|
|
|
|
git rev-parse B:bq A:foo/whatever >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:bq HEAD:foo/bq &&
|
|
|
|
test_path_is_missing bq foo/bq foo/whatever
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
###########################################################################
|
|
|
|
# SECTION 4: Cases involving dirty changes
|
|
|
|
###########################################################################
|
|
|
|
|
|
|
|
# Testcase 4a, Changed on A, subset of changes on B, locally modified
|
|
|
|
# Commit O: b_1
|
|
|
|
# Commit A: b_2
|
|
|
|
# Commit B: b_3
|
|
|
|
# Working copy: b_4
|
|
|
|
# Expected: b_2 for merge, b_4 in working copy
|
|
|
|
|
|
|
|
test_expect_success '4a-setup: Change on A, change on B subset of A, dirty mods present' '
|
|
|
|
test_create_repo 4a &&
|
|
|
|
(
|
|
|
|
cd 4a &&
|
|
|
|
|
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
# NOTE: For as long as we continue using unpack_trees() without index_only
|
|
|
|
# set to true, it will error out on a case like this claiming the the locally
|
|
|
|
# modified file would be overwritten by the merge. Getting this testcase
|
|
|
|
# correct requires doing the merge in-memory first, then realizing that no
|
|
|
|
# updates to the file are necessary, and thus that we can just leave the path
|
|
|
|
# alone.
|
|
|
|
test_expect_failure '4a-check: Change on A, change on B subset of A, dirty mods present' '
|
|
|
|
test_when_finished "git -C 4a reset --hard" &&
|
|
|
|
test_when_finished "git -C 4a clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 4a &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
echo "File rewritten" >b &&
|
|
|
|
|
|
|
|
test-tool chmtime =31337 b &&
|
|
|
|
test-tool chmtime -v +0 b >expected-mtime &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep "Skipped b" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
test-tool chmtime -v +0 b >actual-mtime &&
|
|
|
|
test_cmp expected-mtime actual-mtime &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual :0:b &&
|
|
|
|
git rev-parse >expect A:b &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object b >actual &&
|
|
|
|
echo "File rewritten" | git hash-object --stdin >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
# Testcase 4b, Changed+renamed on A, subset of changes on B, locally modified
|
|
|
|
# Commit O: b_1
|
|
|
|
# Commit A: c_2
|
|
|
|
# Commit B: b_3
|
|
|
|
# Working copy: c_4
|
|
|
|
# Expected: c_2
|
|
|
|
|
|
|
|
test_expect_success '4b-setup: Rename+Mod(A)/Mod(B), change on B subset of A, dirty mods present' '
|
|
|
|
test_create_repo 4b &&
|
|
|
|
(
|
|
|
|
cd 4b &&
|
|
|
|
|
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "O" &&
|
|
|
|
|
|
|
|
git branch O &&
|
|
|
|
git branch A &&
|
|
|
|
git branch B &&
|
|
|
|
|
|
|
|
git checkout A &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 10.5 >b &&
|
|
|
|
git add b &&
|
|
|
|
git mv b c &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "A" &&
|
|
|
|
|
|
|
|
git checkout B &&
|
|
|
|
test_write_lines 1 2 3 4 5 5.5 6 7 8 9 10 >b &&
|
|
|
|
git add b &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "B"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '4b-check: Rename+Mod(A)/Mod(B), change on B subset of A, dirty mods present' '
|
|
|
|
test_when_finished "git -C 4b reset --hard" &&
|
|
|
|
test_when_finished "git -C 4b clean -fd" &&
|
|
|
|
(
|
|
|
|
cd 4b &&
|
|
|
|
|
|
|
|
git checkout A^0 &&
|
|
|
|
echo "File rewritten" >c &&
|
|
|
|
|
|
|
|
test-tool chmtime =31337 c &&
|
|
|
|
test-tool chmtime -v +0 c >expected-mtime &&
|
|
|
|
|
|
|
|
GIT_MERGE_VERBOSITY=3 git merge -s recursive B^0 >out 2>err &&
|
|
|
|
|
|
|
|
test_i18ngrep "Skipped c" out &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
|
|
|
test-tool chmtime -v +0 c >actual-mtime &&
|
|
|
|
test_cmp expected-mtime actual-mtime &&
|
|
|
|
|
|
|
|
git ls-files -s >index_files &&
|
|
|
|
test_line_count = 1 index_files &&
|
|
|
|
|
|
|
|
git rev-parse >actual :0:c &&
|
|
|
|
git rev-parse >expect A:c &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git hash-object c >actual &&
|
|
|
|
echo "File rewritten" | git hash-object --stdin >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
test_must_fail git rev-parse HEAD:b &&
|
|
|
|
test_path_is_missing b
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_done
|