git/t/t2200-add-update.sh

191 lines
4.0 KiB
Bash
Raw Normal View History

#!/bin/sh
test_description='git add -u
This test creates a working tree state with three files:
top (previously committed, modified)
dir/sub (previously committed, modified)
dir/other (untracked)
and issues a git add -u with path limiting on "dir" to add
only the updates to dir/sub.
Also tested are "git add -u" without limiting, and "git add -u"
without contents changes, and other conditions'
TEST_PASSES_SANITIZE_LEAK=true
. ./test-lib.sh
test_expect_success setup '
echo initial >check &&
echo initial >top &&
echo initial >foo &&
mkdir dir1 dir2 &&
echo initial >dir1/sub1 &&
echo initial >dir1/sub2 &&
echo initial >dir2/sub3 &&
git add check dir1 dir2 top foo &&
test_tick &&
git commit -m initial &&
echo changed >check &&
echo changed >top &&
echo changed >dir2/sub3 &&
rm -f dir1/sub1 &&
echo other >dir2/other
'
test_expect_success update '
git add -u dir1 dir2
'
test_expect_success 'update noticed a removal' '
test "$(git ls-files dir1/sub1)" = ""
'
test_expect_success 'update touched correct path' '
test "$(git diff-files --name-status dir2/sub3)" = ""
'
test_expect_success 'update did not touch other tracked files' '
test "$(git diff-files --name-status check)" = "M check" &&
test "$(git diff-files --name-status top)" = "M top"
'
test_expect_success 'update did not touch untracked files' '
test "$(git ls-files dir2/other)" = ""
'
test_expect_success 'cache tree has not been corrupted' '
git ls-files -s |
sed -e "s/ 0 / /" >expect &&
git ls-tree -r $(git write-tree) |
sed -e "s/ blob / /" >current &&
test_cmp expect current
'
test_expect_success 'update from a subdirectory' '
(
cd dir1 &&
echo more >sub2 &&
git add -u sub2
)
'
test_expect_success 'change gets noticed' '
test "$(git diff-files --name-status dir1)" = ""
'
test_expect_success 'non-qualified update in subdir updates from the root' '
(
cd dir1 &&
echo even more >>sub2 &&
add: simplify -u/-A without pathspec Since Git 2.0, "add -u" and "add -A" run from a subdirectory without any pathspec mean "everything in the working tree" (before 2.0, they were limited to the current directory). The limiting to the current directory was implemented by inserting "." to the command line when the end user did not give us any pathspec. At 2.0, we updated the code to insert ":/" (instead of '.') to consider everything from the top-level, by using a pathspec magic "top". The call to parse_pathspec() using the command line arguments is, however, made with PATHSPEC_PREFER_FULL option since 5a76aff1 (add: convert to use parse_pathspec, 2013-07-14), which predates Git 2.0. In retrospect, there was no need to turn "adding . to limit to the directory" into "adding :/ to unlimit to everywhere" in Git 2.0; instead we could just have done "if there is no pathspec on the command line, just let it be". The parse_pathspec() then would give us a pathspec that matches everything and all is well. Incidentally such a simplification also fixes a corner case bug that stems from the fact that ":/" does not necessarily mean any magic. A user would say "git --literal-pathspecs add -u :/" from the command line when she has a directory ':' and wants to add everything in it (and she knows that her :/ will be taken as 'everything under the sun' magic pathspec unless she disables the magic with --literal-pathspecs). The internal use of ':/' would behave the same way as such an explicitly given ":/" when run with "--literal-pathspecs", and will not add everything under the sun as the code originally intended. Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-10-25 10:31:11 +08:00
git --literal-pathspecs add -u &&
echo even more >>sub2 &&
git add -u
) &&
git diff-files --name-only >actual &&
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>' Using 'test_must_be_empty' is shorter and more idiomatic than >empty && test_cmp empty out as it saves the creation of an empty file. Furthermore, sometimes the expected empty file doesn't have such a descriptive name like 'empty', and its creation is far away from the place where it's finally used for comparison (e.g. in 't7600-merge.sh', where two expected empty files are created in the 'setup' test, but are used only about 500 lines later). These cases were found by instrumenting 'test_cmp' to error out the test script when it's used to compare empty files, and then converted manually. Note that even after this patch there still remain a lot of cases where we use 'test_cmp' to check empty files: - Sometimes the expected output is not hard-coded in the test, but 'test_cmp' is used to ensure that two similar git commands produce the same output, and that output happens to be empty, e.g. the test 'submodule update --merge - ignores --merge for new submodules' in 't7406-submodule-update.sh'. - Repetitive common tasks, including preparing the expected results and running 'test_cmp', are often extracted into a helper function, and some of this helper's callsites expect no output. - For the same reason as above, the whole 'test_expect_success' block is within a helper function, e.g. in 't3070-wildmatch.sh'. - Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update (-p)' in 't9400-git-cvsserver-server.sh'. Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-20 05:57:25 +08:00
test_must_be_empty actual
'
test_expect_success 'replace a file with a symlink' '
rm foo &&
test_ln_s_add top foo
'
test_expect_success 'add everything changed' '
git add -u &&
test -z "$(git diff-files)"
'
test_expect_success 'touch and then add -u' '
touch check &&
git add -u &&
test -z "$(git diff-files)"
'
test_expect_success 'touch and then add explicitly' '
touch check &&
git add check &&
test -z "$(git diff-files)"
'
test_expect_success 'add -n -u should not add but just report' '
(
echo "add '\''check'\''" &&
echo "remove '\''top'\''"
) >expect &&
before=$(git ls-files -s check top) &&
git count-objects -v >objects_before &&
echo changed >>check &&
rm -f top &&
git add -n -u >actual &&
after=$(git ls-files -s check top) &&
git count-objects -v >objects_after &&
test "$before" = "$after" &&
test_cmp objects_before objects_after &&
test_cmp expect actual
'
test_expect_success 'add -u resolves unmerged paths' '
git reset --hard &&
one=$(echo 1 | git hash-object -w --stdin) &&
two=$(echo 2 | git hash-object -w --stdin) &&
three=$(echo 3 | git hash-object -w --stdin) &&
{
for path in path1 path2
do
echo "100644 $one 1 $path"
echo "100644 $two 2 $path"
echo "100644 $three 3 $path"
done
echo "100644 $one 1 path3"
echo "100644 $one 1 path4"
echo "100644 $one 3 path5"
echo "100644 $one 3 path6"
} |
git update-index --index-info &&
echo 3 >path1 &&
echo 2 >path3 &&
echo 2 >path5 &&
# Fail to explicitly resolve removed paths with "git add"
test_must_fail git add --no-all path4 &&
test_must_fail git add --no-all path6 &&
Fix "add -u" that sometimes fails to resolve unmerged paths "git add -u" updates the index with the updated contents from the working tree by internally running "diff-files" to grab the set of paths that are different from the index. Then it updates the index entries for the paths that are modified in the working tree, and deletes the index entries for the paths that are deleted in the working tree. It ignored the output from the diff-files that indicated that a path is unmerged. For these paths, it instead relied on the fact that an unmerged path is followed by the result of comparison between stage #2 (ours) and the working tree, and used that to update or delete such a path when it is used to record the resolution of a conflict. As the result, when a path did not have stage #2 (e.g. "we deleted while the other side added"), these unmerged stages were left behind, instead of recording what the user resolved in the working tree. Since we recently fixed "diff-files" to indicate if the corresponding path exists on the working tree for an unmerged path, we do not have to rely on the comparison with stage #2 anymore. We can instead tell the diff-files not to compare with higher stages, and use the unmerged output to update the index to reflect the state of the working tree. The changes to the test vector in t2200 illustrates the nature of the bug and the fix. The test expected stage #1 and #3 entries be left behind, but it was codifying the buggy behaviour. Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-04-21 09:11:19 +08:00
# "add -u" should notice removals no matter what stages
# the index entries are in.
git add -u &&
git ls-files -s path1 path2 path3 path4 path5 path6 >actual &&
{
echo "100644 $three 0 path1"
echo "100644 $two 0 path3"
echo "100644 $two 0 path5"
Fix "add -u" that sometimes fails to resolve unmerged paths "git add -u" updates the index with the updated contents from the working tree by internally running "diff-files" to grab the set of paths that are different from the index. Then it updates the index entries for the paths that are modified in the working tree, and deletes the index entries for the paths that are deleted in the working tree. It ignored the output from the diff-files that indicated that a path is unmerged. For these paths, it instead relied on the fact that an unmerged path is followed by the result of comparison between stage #2 (ours) and the working tree, and used that to update or delete such a path when it is used to record the resolution of a conflict. As the result, when a path did not have stage #2 (e.g. "we deleted while the other side added"), these unmerged stages were left behind, instead of recording what the user resolved in the working tree. Since we recently fixed "diff-files" to indicate if the corresponding path exists on the working tree for an unmerged path, we do not have to rely on the comparison with stage #2 anymore. We can instead tell the diff-files not to compare with higher stages, and use the unmerged output to update the index to reflect the state of the working tree. The changes to the test vector in t2200 illustrates the nature of the bug and the fix. The test expected stage #1 and #3 entries be left behind, but it was codifying the buggy behaviour. Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-04-21 09:11:19 +08:00
} >expect &&
test_cmp expect actual
'
test_expect_success '"add -u non-existent" should fail' '
test_must_fail git add -u non-existent &&
git ls-files >actual &&
! grep "non-existent" actual
'
test_done