2007-07-02 11:14:49 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Copyright (c) 2007 Johannes E Schindelin
|
|
|
|
#
|
|
|
|
|
2008-09-03 08:59:27 +00:00
|
|
|
test_description='Test git stash'
|
2007-07-02 11:14:49 +00:00
|
|
|
|
2020-11-18 23:44:26 +00:00
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
tests: mark tests relying on the current default for `init.defaultBranch`
In addition to the manual adjustment to let the `linux-gcc` CI job run
the test suite with `master` and then with `main`, this patch makes sure
that GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME is set in all test scripts
that currently rely on the initial branch name being `master by default.
To determine which test scripts to mark up, the first step was to
force-set the default branch name to `master` in
- all test scripts that contain the keyword `master`,
- t4211, which expects `t/t4211/history.export` with a hard-coded ref to
initialize the default branch,
- t5560 because it sources `t/t556x_common` which uses `master`,
- t8002 and t8012 because both source `t/annotate-tests.sh` which also
uses `master`)
This trick was performed by this command:
$ sed -i '/^ *\. \.\/\(test-lib\|lib-\(bash\|cvs\|git-svn\)\|gitweb-lib\)\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' $(git grep -l master t/t[0-9]*.sh) \
t/t4211*.sh t/t5560*.sh t/t8002*.sh t/t8012*.sh
After that, careful, manual inspection revealed that some of the test
scripts containing the needle `master` do not actually rely on a
specific default branch name: either they mention `master` only in a
comment, or they initialize that branch specificially, or they do not
actually refer to the current default branch. Therefore, the
aforementioned modification was undone in those test scripts thusly:
$ git checkout HEAD -- \
t/t0027-auto-crlf.sh t/t0060-path-utils.sh \
t/t1011-read-tree-sparse-checkout.sh \
t/t1305-config-include.sh t/t1309-early-config.sh \
t/t1402-check-ref-format.sh t/t1450-fsck.sh \
t/t2024-checkout-dwim.sh \
t/t2106-update-index-assume-unchanged.sh \
t/t3040-subprojects-basic.sh t/t3301-notes.sh \
t/t3308-notes-merge.sh t/t3423-rebase-reword.sh \
t/t3436-rebase-more-options.sh \
t/t4015-diff-whitespace.sh t/t4257-am-interactive.sh \
t/t5323-pack-redundant.sh t/t5401-update-hooks.sh \
t/t5511-refspec.sh t/t5526-fetch-submodules.sh \
t/t5529-push-errors.sh t/t5530-upload-pack-error.sh \
t/t5548-push-porcelain.sh \
t/t5552-skipping-fetch-negotiator.sh \
t/t5572-pull-submodule.sh t/t5608-clone-2gb.sh \
t/t5614-clone-submodules-shallow.sh \
t/t7508-status.sh t/t7606-merge-custom.sh \
t/t9302-fast-import-unpack-limit.sh
We excluded one set of test scripts in these commands, though: the range
of `git p4` tests. The reason? `git p4` stores the (foreign) remote
branch in the branch called `p4/master`, which is obviously not the
default branch. Manual analysis revealed that only five of these tests
actually require a specific default branch name to pass; They were
modified thusly:
$ sed -i '/^ *\. \.\/lib-git-p4\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' t/t980[0167]*.sh t/t9811*.sh
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-11-18 23:44:19 +00:00
|
|
|
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
|
|
|
|
2007-07-02 11:14:49 +00:00
|
|
|
. ./test-lib.sh
|
2022-06-30 10:18:34 +00:00
|
|
|
. "$TEST_DIRECTORY"/lib-unique-files.sh
|
2007-07-02 11:14:49 +00:00
|
|
|
|
stash: don't show "git stash push" usage on bad "git stash" usage
Change the usage message emitted by "git stash --invalid-option" to
emit usage information for "git stash" in general, and not just for
the "push" command. I.e. before:
$ git stash --invalid-option
error: unknown option `invalid-option'
usage: git stash [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [-m|--message <message>]
[--] [<pathspec>...]]
[...]
After:
$ git stash --invalid-option
error: unknown option `invalid-option'
usage: git stash list [<options>]
or: git stash show [<options>] [<stash>]
or: git stash drop [-q|--quiet] [<stash>]
or: git stash ( pop | apply ) [--index] [-q|--quiet] [<stash>]
or: git stash branch <branchname> [<stash>]
or: git stash clear
or: git stash [push [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [-m|--message <message>]
[--pathspec-from-file=<file> [--pathspec-file-nul]]
[--] [<pathspec>...]]
or: git stash save [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [<message>]
[...]
That we emitted the usage for just "push" in the case of the
subcommand not being explicitly specified was an unintentional
side-effect of how it was implemented. When it was converted to C in
d553f538b8a (stash: convert push to builtin, 2019-02-25) the pattern
of having per-subcommand usage information was rightly continued. The
"git-stash.sh" shellscript did not have that, and always printed the
equivalent of "git_stash_usage".
But in doing so the case of push being implicit and explicit was
conflated. A variable was added to track this in 8c3713cede7 (stash:
eliminate crude option parsing, 2020-02-17), but it did not update the
usage output accordingly.
This still leaves e.g. "git stash push -h" emitting the
"git_stash_usage" output, instead of "git_stash_push_usage". That
should be fixed, but is a much deeper misbehavior in parse_options()
not being aware of subcommands at all. I.e. in how
PARSE_OPT_KEEP_UNKNOWN and PARSE_OPT_NO_INTERNAL_HELP combine in
commands such as "git stash".
Perhaps PARSE_OPT_KEEP_UNKNOWN should imply
PARSE_OPT_NO_INTERNAL_HELP, or better yet parse_options() should be
extended to fully handle these subcommand cases that we handle
manually in "git stash", "git commit-graph", "git multi-pack-index"
etc. All of those musings would be a much bigger change than this
isolated fix though, so let's leave that for some other time.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-16 12:54:21 +00:00
|
|
|
test_expect_success 'usage on cmd and subcommand invalid option' '
|
|
|
|
test_expect_code 129 git stash --invalid-option 2>usage &&
|
|
|
|
grep "or: git stash" usage &&
|
|
|
|
|
|
|
|
test_expect_code 129 git stash push --invalid-option 2>usage &&
|
|
|
|
! grep "or: git stash" usage
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'usage on main command -h emits a summary of subcommands' '
|
|
|
|
test_expect_code 129 git stash -h >usage &&
|
|
|
|
grep -F "usage: git stash list" usage &&
|
|
|
|
grep -F "or: git stash show" usage
|
|
|
|
'
|
|
|
|
|
2022-08-19 16:04:10 +00:00
|
|
|
test_expect_success 'usage for subcommands should emit subcommand usage' '
|
stash: don't show "git stash push" usage on bad "git stash" usage
Change the usage message emitted by "git stash --invalid-option" to
emit usage information for "git stash" in general, and not just for
the "push" command. I.e. before:
$ git stash --invalid-option
error: unknown option `invalid-option'
usage: git stash [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [-m|--message <message>]
[--] [<pathspec>...]]
[...]
After:
$ git stash --invalid-option
error: unknown option `invalid-option'
usage: git stash list [<options>]
or: git stash show [<options>] [<stash>]
or: git stash drop [-q|--quiet] [<stash>]
or: git stash ( pop | apply ) [--index] [-q|--quiet] [<stash>]
or: git stash branch <branchname> [<stash>]
or: git stash clear
or: git stash [push [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [-m|--message <message>]
[--pathspec-from-file=<file> [--pathspec-file-nul]]
[--] [<pathspec>...]]
or: git stash save [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [<message>]
[...]
That we emitted the usage for just "push" in the case of the
subcommand not being explicitly specified was an unintentional
side-effect of how it was implemented. When it was converted to C in
d553f538b8a (stash: convert push to builtin, 2019-02-25) the pattern
of having per-subcommand usage information was rightly continued. The
"git-stash.sh" shellscript did not have that, and always printed the
equivalent of "git_stash_usage".
But in doing so the case of push being implicit and explicit was
conflated. A variable was added to track this in 8c3713cede7 (stash:
eliminate crude option parsing, 2020-02-17), but it did not update the
usage output accordingly.
This still leaves e.g. "git stash push -h" emitting the
"git_stash_usage" output, instead of "git_stash_push_usage". That
should be fixed, but is a much deeper misbehavior in parse_options()
not being aware of subcommands at all. I.e. in how
PARSE_OPT_KEEP_UNKNOWN and PARSE_OPT_NO_INTERNAL_HELP combine in
commands such as "git stash".
Perhaps PARSE_OPT_KEEP_UNKNOWN should imply
PARSE_OPT_NO_INTERNAL_HELP, or better yet parse_options() should be
extended to fully handle these subcommand cases that we handle
manually in "git stash", "git commit-graph", "git multi-pack-index"
etc. All of those musings would be a much bigger change than this
isolated fix though, so let's leave that for some other time.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-16 12:54:21 +00:00
|
|
|
test_expect_code 129 git stash push -h >usage &&
|
|
|
|
grep -F "usage: git stash [push" usage
|
|
|
|
'
|
|
|
|
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp () {
|
|
|
|
for i in "$1" "$2"
|
|
|
|
do
|
|
|
|
sed -e 's/^index 0000000\.\.[0-9a-f]*/index 0000000..1234567/' \
|
|
|
|
-e 's/^index [0-9a-f]*\.\.[0-9a-f]*/index 1234567..89abcde/' \
|
|
|
|
-e 's/^index [0-9a-f]*,[0-9a-f]*\.\.[0-9a-f]*/index 1234567,7654321..89abcde/' \
|
|
|
|
"$i" >"$i.compare" || return 1
|
|
|
|
done &&
|
|
|
|
test_cmp "$1.compare" "$2.compare" &&
|
|
|
|
rm -f "$1.compare" "$2.compare"
|
|
|
|
}
|
|
|
|
|
2022-03-02 22:27:22 +00:00
|
|
|
setup_stash() {
|
2019-02-25 23:16:10 +00:00
|
|
|
echo 1 >file &&
|
2007-07-02 11:14:49 +00:00
|
|
|
git add file &&
|
2015-04-22 19:30:58 +00:00
|
|
|
echo unrelated >other-file &&
|
|
|
|
git add other-file &&
|
2007-07-02 11:14:49 +00:00
|
|
|
test_tick &&
|
|
|
|
git commit -m initial &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo 2 >file &&
|
2007-07-02 11:14:49 +00:00
|
|
|
git add file &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo 3 >file &&
|
2007-07-02 11:14:49 +00:00
|
|
|
test_tick &&
|
|
|
|
git stash &&
|
|
|
|
git diff-files --quiet &&
|
|
|
|
git diff-index --cached --quiet HEAD
|
2022-03-02 22:27:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success 'stash some dirty working directory' '
|
|
|
|
setup_stash
|
2007-07-02 11:14:49 +00:00
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:10 +00:00
|
|
|
cat >expect <<EOF
|
2007-07-02 11:14:49 +00:00
|
|
|
diff --git a/file b/file
|
|
|
|
index 0cfbf08..00750ed 100644
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@ -1 +1 @@
|
|
|
|
-2
|
|
|
|
+3
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'parents of stash' '
|
|
|
|
test $(git rev-parse stash^) = $(git rev-parse HEAD) &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git diff stash^2..stash >output &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expect output
|
2007-07-02 11:14:49 +00:00
|
|
|
'
|
|
|
|
|
stash: fix accidental apply of non-existent stashes
Once upon a time, "git rev-parse ref@{9999999}" did not
generate an error. Therefore when we got an invalid stash
reference in "stash apply", we could end up not noticing
until quite late. Commit b0f0ecd (detached-stash: work
around git rev-parse failure to detect bad log refs,
2010-08-21) handled this by checking for the "Log for stash
has only %d entries" warning on stderr when we validated the
ref.
A few days later, e6eedc3 (rev-parse: exit with non-zero
status if ref@{n} is not valid., 2010-08-24) fixed the
original issue. That made the extra stderr test superfluous,
but also introduced a new bug. Now the early call to:
git rev-parse --symbolic "$@"
fails, but we don't notice the exit code. Worse, its empty
output means we think the user didn't provide us a ref, and
we try to apply stash@{0}.
This patch checks the rev-parse exit code and fails early in
the revision parsing process. We can also get rid of the
stderr test; as a bonus, this means that "stash apply" can
now run under GIT_TRACE=1 properly.
Signed-off-by: Jeff King <peff@peff.net>
Acked-by: Jon Seymour <jon.seymour@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-04-05 21:20:25 +00:00
|
|
|
test_expect_success 'applying bogus stash does nothing' '
|
|
|
|
test_must_fail git stash apply stash@{1} &&
|
|
|
|
echo 1 >expect &&
|
|
|
|
test_cmp expect file
|
|
|
|
'
|
|
|
|
|
2011-04-05 21:23:15 +00:00
|
|
|
test_expect_success 'apply does not need clean working directory' '
|
|
|
|
echo 4 >other-file &&
|
|
|
|
git stash apply &&
|
|
|
|
echo 3 >expect &&
|
|
|
|
test_cmp expect file
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'apply does not clobber working directory changes' '
|
|
|
|
git reset --hard &&
|
|
|
|
echo 4 >file &&
|
|
|
|
test_must_fail git stash apply &&
|
|
|
|
echo 4 >expect &&
|
|
|
|
test_cmp expect file
|
2007-07-02 11:14:49 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'apply stashed changes' '
|
2011-04-05 21:23:15 +00:00
|
|
|
git reset --hard &&
|
|
|
|
echo 5 >other-file &&
|
2007-07-02 11:14:49 +00:00
|
|
|
git add other-file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m other-file &&
|
|
|
|
git stash apply &&
|
|
|
|
test 3 = $(cat file) &&
|
|
|
|
test 1 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'apply stashed changes (including index)' '
|
|
|
|
git reset --hard HEAD^ &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo 6 >other-file &&
|
2007-07-02 11:14:49 +00:00
|
|
|
git add other-file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m other-file &&
|
|
|
|
git stash apply --index &&
|
|
|
|
test 3 = $(cat file) &&
|
|
|
|
test 2 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file)
|
|
|
|
'
|
|
|
|
|
2007-07-25 22:32:22 +00:00
|
|
|
test_expect_success 'unstashing in a subdirectory' '
|
|
|
|
git reset --hard HEAD &&
|
|
|
|
mkdir subdir &&
|
2010-09-07 01:42:54 +00:00
|
|
|
(
|
|
|
|
cd subdir &&
|
|
|
|
git stash apply
|
2010-09-06 18:39:54 +00:00
|
|
|
)
|
2008-03-02 20:58:51 +00:00
|
|
|
'
|
|
|
|
|
2015-05-20 18:01:32 +00:00
|
|
|
test_expect_success 'stash drop complains of extra options' '
|
|
|
|
test_must_fail git stash drop --foo
|
|
|
|
'
|
|
|
|
|
2008-03-02 20:58:51 +00:00
|
|
|
test_expect_success 'drop top stash' '
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git stash list >expected &&
|
|
|
|
echo 7 >file &&
|
2008-03-02 20:58:51 +00:00
|
|
|
git stash &&
|
|
|
|
git stash drop &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git stash list >actual &&
|
|
|
|
test_cmp expected actual &&
|
2008-03-02 20:58:51 +00:00
|
|
|
git stash apply &&
|
|
|
|
test 3 = $(cat file) &&
|
|
|
|
test 1 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'drop middle stash' '
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo 8 >file &&
|
2008-03-02 20:58:51 +00:00
|
|
|
git stash &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo 9 >file &&
|
2008-03-02 20:58:51 +00:00
|
|
|
git stash &&
|
|
|
|
git stash drop stash@{1} &&
|
|
|
|
test 2 = $(git stash list | wc -l) &&
|
|
|
|
git stash apply &&
|
|
|
|
test 9 = $(cat file) &&
|
|
|
|
test 1 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file) &&
|
|
|
|
git reset --hard &&
|
|
|
|
git stash drop &&
|
|
|
|
git stash apply &&
|
|
|
|
test 3 = $(cat file) &&
|
|
|
|
test 1 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file)
|
|
|
|
'
|
|
|
|
|
2016-10-24 23:40:13 +00:00
|
|
|
test_expect_success 'drop middle stash by index' '
|
|
|
|
git reset --hard &&
|
|
|
|
echo 8 >file &&
|
|
|
|
git stash &&
|
|
|
|
echo 9 >file &&
|
|
|
|
git stash &&
|
|
|
|
git stash drop 1 &&
|
|
|
|
test 2 = $(git stash list | wc -l) &&
|
|
|
|
git stash apply &&
|
|
|
|
test 9 = $(cat file) &&
|
|
|
|
test 1 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file) &&
|
|
|
|
git reset --hard &&
|
|
|
|
git stash drop &&
|
|
|
|
git stash apply &&
|
|
|
|
test 3 = $(cat file) &&
|
|
|
|
test 1 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file)
|
|
|
|
'
|
|
|
|
|
2022-03-02 22:27:22 +00:00
|
|
|
test_expect_success 'drop stash reflog updates refs/stash' '
|
|
|
|
git reset --hard &&
|
|
|
|
git rev-parse refs/stash >expect &&
|
|
|
|
echo 9 >file &&
|
|
|
|
git stash &&
|
|
|
|
git stash drop stash@{0} &&
|
|
|
|
git rev-parse refs/stash >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2024-01-19 20:18:58 +00:00
|
|
|
test_expect_success 'drop stash reflog updates refs/stash with rewrite' '
|
2022-03-02 22:27:22 +00:00
|
|
|
git init repo &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
setup_stash
|
|
|
|
) &&
|
|
|
|
echo 9 >repo/file &&
|
|
|
|
|
|
|
|
old_oid="$(git -C repo rev-parse stash@{0})" &&
|
|
|
|
git -C repo stash &&
|
|
|
|
new_oid="$(git -C repo rev-parse stash@{0})" &&
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
2024-01-19 20:18:58 +00:00
|
|
|
$new_oid
|
|
|
|
$old_oid
|
2022-03-02 22:27:22 +00:00
|
|
|
EOF
|
2024-01-19 20:18:58 +00:00
|
|
|
git -C repo reflog show refs/stash --format=%H >actual &&
|
2022-03-02 22:27:22 +00:00
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git -C repo stash drop stash@{1} &&
|
2024-01-19 20:18:58 +00:00
|
|
|
git -C repo reflog show refs/stash --format=%H >actual &&
|
2022-03-02 22:27:22 +00:00
|
|
|
cat >expect <<-EOF &&
|
2024-01-19 20:18:58 +00:00
|
|
|
$new_oid
|
2022-03-02 22:27:22 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2008-03-02 20:58:51 +00:00
|
|
|
test_expect_success 'stash pop' '
|
|
|
|
git reset --hard &&
|
|
|
|
git stash pop &&
|
|
|
|
test 3 = $(cat file) &&
|
|
|
|
test 1 = $(git show :file) &&
|
|
|
|
test 1 = $(git show HEAD:file) &&
|
|
|
|
test 0 = $(git stash list | wc -l)
|
2007-07-25 22:32:22 +00:00
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:10 +00:00
|
|
|
cat >expect <<EOF
|
2008-07-06 21:20:10 +00:00
|
|
|
diff --git a/file2 b/file2
|
|
|
|
new file mode 100644
|
|
|
|
index 0000000..1fe912c
|
|
|
|
--- /dev/null
|
|
|
|
+++ b/file2
|
|
|
|
@@ -0,0 +1 @@
|
|
|
|
+bar2
|
|
|
|
EOF
|
|
|
|
|
2019-02-25 23:16:10 +00:00
|
|
|
cat >expect1 <<EOF
|
2008-07-06 21:20:10 +00:00
|
|
|
diff --git a/file b/file
|
|
|
|
index 257cc56..5716ca5 100644
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@ -1 +1 @@
|
|
|
|
-foo
|
|
|
|
+bar
|
|
|
|
EOF
|
|
|
|
|
2019-02-25 23:16:10 +00:00
|
|
|
cat >expect2 <<EOF
|
2008-07-06 21:20:10 +00:00
|
|
|
diff --git a/file b/file
|
|
|
|
index 7601807..5716ca5 100644
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@ -1 +1 @@
|
|
|
|
-baz
|
|
|
|
+bar
|
|
|
|
diff --git a/file2 b/file2
|
|
|
|
new file mode 100644
|
|
|
|
index 0000000..1fe912c
|
|
|
|
--- /dev/null
|
|
|
|
+++ b/file2
|
|
|
|
@@ -0,0 +1 @@
|
|
|
|
+bar2
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'stash branch' '
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >file &&
|
2010-10-31 01:46:54 +00:00
|
|
|
git commit file -m first &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar >file &&
|
|
|
|
echo bar2 >file2 &&
|
2008-07-06 21:20:10 +00:00
|
|
|
git add file2 &&
|
|
|
|
git stash &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo baz >file &&
|
2008-07-06 21:20:10 +00:00
|
|
|
git commit file -m second &&
|
|
|
|
git stash branch stashbranch &&
|
|
|
|
test refs/heads/stashbranch = $(git symbolic-ref HEAD) &&
|
2020-11-18 23:44:26 +00:00
|
|
|
test $(git rev-parse HEAD) = $(git rev-parse main^) &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git diff --cached >output &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expect output &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git diff >output &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expect1 output &&
|
2008-07-06 21:20:10 +00:00
|
|
|
git add file &&
|
|
|
|
git commit -m alternate\ second &&
|
2020-11-18 23:44:26 +00:00
|
|
|
git diff main..stashbranch >output &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp output expect2 &&
|
2008-07-06 21:20:10 +00:00
|
|
|
test 0 = $(git stash list | wc -l)
|
|
|
|
'
|
|
|
|
|
2009-06-18 01:07:37 +00:00
|
|
|
test_expect_success 'apply -q is quiet' '
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >file &&
|
2009-06-18 01:07:37 +00:00
|
|
|
git stash &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git stash apply -q >output.out 2>&1 &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty output.out
|
2009-06-18 01:07:37 +00:00
|
|
|
'
|
|
|
|
|
stash: make internal resets quiet and refresh index
Add the options '-q' and '--refresh' to the 'git reset' executed in
'reset_head()', and '--refresh' to the 'git reset -q' executed in
'do_push_stash(...)'.
'stash' is implemented such that git commands invoked as part of it (e.g.,
'clean', 'read-tree', 'reset', etc.) have their informational output
silenced. However, the 'reset' in 'reset_head()' is *not* called with '-q',
leading to the potential for a misleading printout from 'git stash apply
--index' if the stash included a removed file:
Unstaged changes after reset: D <deleted file>
Not only is this confusing in its own right (since, after the reset, 'git
stash' execution would stage the deletion in the index), it would be printed
even when the stash was applied with the '-q' option. As a result, the
messaging is removed entirely by calling 'git status' with '-q'.
Additionally, because the default behavior of 'git reset -q' is to skip
refreshing the index, but later operations in 'git stash' subcommands expect
a non-stale index, enable '--refresh' as well.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Victoria Dye <vdye@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-03-15 01:49:42 +00:00
|
|
|
test_expect_success 'apply --index -q is quiet' '
|
|
|
|
# Added file, deleted file, modified file all staged for commit
|
|
|
|
echo foo >new-file &&
|
|
|
|
echo test >file &&
|
|
|
|
git add new-file file &&
|
|
|
|
git rm other-file &&
|
|
|
|
|
|
|
|
git stash &&
|
|
|
|
git stash apply --index -q >output.out 2>&1 &&
|
|
|
|
test_must_be_empty output.out
|
|
|
|
'
|
|
|
|
|
2009-06-18 01:07:37 +00:00
|
|
|
test_expect_success 'save -q is quiet' '
|
2019-02-25 23:16:10 +00:00
|
|
|
git stash save --quiet >output.out 2>&1 &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty output.out
|
2009-06-18 01:07:37 +00:00
|
|
|
'
|
|
|
|
|
stash: make sure we have a valid index before writing it
In 'do_apply_stash()' we refresh the index in the end. Since
34933d0eff ("stash: make sure to write refreshed cache", 2019-09-11),
we also write that refreshed index when --quiet is given to 'git stash
apply'.
However if '--index' is not given to 'git stash apply', we also
discard the index in the else clause just before. We need to do so
because we use an external 'git update-index --add --stdin', which
leads to an out of date in-core index.
Later we call 'refresh_and_write_cache', which now leads to writing
the discarded index, which means we essentially write an empty index
file. This is obviously not correct, or the behaviour the user
wanted. We should not modify the users index without being asked to
do so.
Make sure to re-read the index after discarding the current in-core
index, to avoid dealing with outdated information. Instead we could
also drop the 'discard_cache()' + 'read_cache()', however that would
make it easy to fall into the same trap as 34933d0eff did, so it's
better to avoid that.
We can also drop the 'refresh_and_write_cache' completely in the quiet
case. Previously in legacy stash we relied on 'git status' to refresh
the index after calling 'git read-tree' when '--index' was passed to
'git apply'. However the 'reset_tree()' call that replaced 'git
read-tree' always passes options that are equivalent to '-m', making
the refresh of the index unnecessary.
Reported-by: Grzegorz Rajchman <rayman17@gmail.com>
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-11-13 15:01:36 +00:00
|
|
|
test_expect_success 'pop -q works and is quiet' '
|
2019-02-25 23:16:10 +00:00
|
|
|
git stash pop -q >output.out 2>&1 &&
|
stash: make sure we have a valid index before writing it
In 'do_apply_stash()' we refresh the index in the end. Since
34933d0eff ("stash: make sure to write refreshed cache", 2019-09-11),
we also write that refreshed index when --quiet is given to 'git stash
apply'.
However if '--index' is not given to 'git stash apply', we also
discard the index in the else clause just before. We need to do so
because we use an external 'git update-index --add --stdin', which
leads to an out of date in-core index.
Later we call 'refresh_and_write_cache', which now leads to writing
the discarded index, which means we essentially write an empty index
file. This is obviously not correct, or the behaviour the user
wanted. We should not modify the users index without being asked to
do so.
Make sure to re-read the index after discarding the current in-core
index, to avoid dealing with outdated information. Instead we could
also drop the 'discard_cache()' + 'read_cache()', however that would
make it easy to fall into the same trap as 34933d0eff did, so it's
better to avoid that.
We can also drop the 'refresh_and_write_cache' completely in the quiet
case. Previously in legacy stash we relied on 'git status' to refresh
the index after calling 'git read-tree' when '--index' was passed to
'git apply'. However the 'reset_tree()' call that replaced 'git
read-tree' always passes options that are equivalent to '-m', making
the refresh of the index unnecessary.
Reported-by: Grzegorz Rajchman <rayman17@gmail.com>
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-11-13 15:01:36 +00:00
|
|
|
echo bar >expect &&
|
|
|
|
git show :file >actual &&
|
|
|
|
test_cmp expect actual &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty output.out
|
2009-06-18 01:07:37 +00:00
|
|
|
'
|
|
|
|
|
2010-02-15 16:05:46 +00:00
|
|
|
test_expect_success 'pop -q --index works and is quiet' '
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >file &&
|
2010-02-15 16:05:46 +00:00
|
|
|
git add file &&
|
|
|
|
git stash save --quiet &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git stash pop -q --index >output.out 2>&1 &&
|
stash: make sure we have a valid index before writing it
In 'do_apply_stash()' we refresh the index in the end. Since
34933d0eff ("stash: make sure to write refreshed cache", 2019-09-11),
we also write that refreshed index when --quiet is given to 'git stash
apply'.
However if '--index' is not given to 'git stash apply', we also
discard the index in the else clause just before. We need to do so
because we use an external 'git update-index --add --stdin', which
leads to an out of date in-core index.
Later we call 'refresh_and_write_cache', which now leads to writing
the discarded index, which means we essentially write an empty index
file. This is obviously not correct, or the behaviour the user
wanted. We should not modify the users index without being asked to
do so.
Make sure to re-read the index after discarding the current in-core
index, to avoid dealing with outdated information. Instead we could
also drop the 'discard_cache()' + 'read_cache()', however that would
make it easy to fall into the same trap as 34933d0eff did, so it's
better to avoid that.
We can also drop the 'refresh_and_write_cache' completely in the quiet
case. Previously in legacy stash we relied on 'git status' to refresh
the index after calling 'git read-tree' when '--index' was passed to
'git apply'. However the 'reset_tree()' call that replaced 'git
read-tree' always passes options that are equivalent to '-m', making
the refresh of the index unnecessary.
Reported-by: Grzegorz Rajchman <rayman17@gmail.com>
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-11-13 15:01:36 +00:00
|
|
|
git diff-files file2 >file2.diff &&
|
|
|
|
test_must_be_empty file2.diff &&
|
2010-02-15 16:05:46 +00:00
|
|
|
test foo = "$(git show :file)" &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty output.out
|
2010-02-15 16:05:46 +00:00
|
|
|
'
|
|
|
|
|
2009-06-18 01:07:37 +00:00
|
|
|
test_expect_success 'drop -q is quiet' '
|
|
|
|
git stash &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git stash drop -q >output.out 2>&1 &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty output.out
|
2009-06-18 01:07:37 +00:00
|
|
|
'
|
|
|
|
|
stash: make internal resets quiet and refresh index
Add the options '-q' and '--refresh' to the 'git reset' executed in
'reset_head()', and '--refresh' to the 'git reset -q' executed in
'do_push_stash(...)'.
'stash' is implemented such that git commands invoked as part of it (e.g.,
'clean', 'read-tree', 'reset', etc.) have their informational output
silenced. However, the 'reset' in 'reset_head()' is *not* called with '-q',
leading to the potential for a misleading printout from 'git stash apply
--index' if the stash included a removed file:
Unstaged changes after reset: D <deleted file>
Not only is this confusing in its own right (since, after the reset, 'git
stash' execution would stage the deletion in the index), it would be printed
even when the stash was applied with the '-q' option. As a result, the
messaging is removed entirely by calling 'git status' with '-q'.
Additionally, because the default behavior of 'git reset -q' is to skip
refreshing the index, but later operations in 'git stash' subcommands expect
a non-stale index, enable '--refresh' as well.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Victoria Dye <vdye@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-03-15 01:49:42 +00:00
|
|
|
test_expect_success 'stash push -q --staged refreshes the index' '
|
|
|
|
git reset --hard &&
|
|
|
|
echo test >file &&
|
|
|
|
git add file &&
|
|
|
|
git stash push -q --staged &&
|
|
|
|
git diff-files >output.out &&
|
|
|
|
test_must_be_empty output.out
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash apply -q --index refreshes the index' '
|
|
|
|
echo test >other-file &&
|
|
|
|
git add other-file &&
|
|
|
|
echo another-change >other-file &&
|
|
|
|
git diff-files >expect &&
|
|
|
|
git stash &&
|
|
|
|
|
|
|
|
git stash apply -q --index &&
|
|
|
|
git diff-files >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2009-07-27 18:37:10 +00:00
|
|
|
test_expect_success 'stash -k' '
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar3 >file &&
|
|
|
|
echo bar4 >file2 &&
|
2009-07-27 18:37:10 +00:00
|
|
|
git add file2 &&
|
|
|
|
git stash -k &&
|
|
|
|
test bar,bar4 = $(cat file),$(cat file2)
|
|
|
|
'
|
|
|
|
|
2011-04-07 17:04:19 +00:00
|
|
|
test_expect_success 'stash --no-keep-index' '
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar33 >file &&
|
|
|
|
echo bar44 >file2 &&
|
2011-04-07 17:04:19 +00:00
|
|
|
git add file2 &&
|
|
|
|
git stash --no-keep-index &&
|
|
|
|
test bar,bar2 = $(cat file),$(cat file2)
|
|
|
|
'
|
|
|
|
|
2021-10-18 16:09:06 +00:00
|
|
|
test_expect_success 'stash --staged' '
|
|
|
|
echo bar3 >file &&
|
|
|
|
echo bar4 >file2 &&
|
|
|
|
git add file2 &&
|
|
|
|
git stash --staged &&
|
|
|
|
test bar3,bar2 = $(cat file),$(cat file2) &&
|
|
|
|
git reset --hard &&
|
|
|
|
git stash pop &&
|
|
|
|
test bar,bar4 = $(cat file),$(cat file2)
|
|
|
|
'
|
|
|
|
|
2020-02-17 17:25:21 +00:00
|
|
|
test_expect_success 'dont assume push with non-option args' '
|
|
|
|
test_must_fail git stash -q drop 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep -e "subcommand wasn'\''t specified; '\''push'\'' can'\''t be assumed due to unexpected token '\''drop'\''" err
|
2020-02-17 17:25:21 +00:00
|
|
|
'
|
|
|
|
|
2009-08-18 21:38:40 +00:00
|
|
|
test_expect_success 'stash --invalid-option' '
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar5 >file &&
|
|
|
|
echo bar6 >file2 &&
|
2009-08-18 21:38:40 +00:00
|
|
|
git add file2 &&
|
|
|
|
test_must_fail git stash --invalid-option &&
|
|
|
|
test_must_fail git stash save --invalid-option &&
|
2017-02-28 20:33:39 +00:00
|
|
|
test bar5,bar6 = $(cat file),$(cat file2)
|
2009-08-18 21:38:40 +00:00
|
|
|
'
|
|
|
|
|
2010-04-18 18:27:49 +00:00
|
|
|
test_expect_success 'stash an added file' '
|
|
|
|
git reset --hard &&
|
|
|
|
echo new >file3 &&
|
|
|
|
git add file3 &&
|
|
|
|
git stash save "added file" &&
|
|
|
|
! test -r file3 &&
|
|
|
|
git stash apply &&
|
|
|
|
test new = "$(cat file3)"
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:11 +00:00
|
|
|
test_expect_success 'stash --intent-to-add file' '
|
|
|
|
git reset --hard &&
|
|
|
|
echo new >file4 &&
|
|
|
|
git add --intent-to-add file4 &&
|
|
|
|
test_when_finished "git rm -f file4" &&
|
|
|
|
test_must_fail git stash
|
|
|
|
'
|
|
|
|
|
2010-04-18 18:27:49 +00:00
|
|
|
test_expect_success 'stash rm then recreate' '
|
|
|
|
git reset --hard &&
|
|
|
|
git rm file &&
|
|
|
|
echo bar7 >file &&
|
|
|
|
git stash save "rm then recreate" &&
|
|
|
|
test bar = "$(cat file)" &&
|
|
|
|
git stash apply &&
|
|
|
|
test bar7 = "$(cat file)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash rm and ignore' '
|
|
|
|
git reset --hard &&
|
|
|
|
git rm file &&
|
|
|
|
echo file >.gitignore &&
|
|
|
|
git stash save "rm and ignore" &&
|
|
|
|
test bar = "$(cat file)" &&
|
2010-10-31 01:46:54 +00:00
|
|
|
test file = "$(cat .gitignore)" &&
|
2010-04-18 18:27:49 +00:00
|
|
|
git stash apply &&
|
|
|
|
! test -r file &&
|
|
|
|
test file = "$(cat .gitignore)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash rm and ignore (stage .gitignore)' '
|
|
|
|
git reset --hard &&
|
|
|
|
git rm file &&
|
|
|
|
echo file >.gitignore &&
|
|
|
|
git add .gitignore &&
|
|
|
|
git stash save "rm and ignore (stage .gitignore)" &&
|
|
|
|
test bar = "$(cat file)" &&
|
2010-10-31 01:46:54 +00:00
|
|
|
! test -r .gitignore &&
|
2010-04-18 18:27:49 +00:00
|
|
|
git stash apply &&
|
|
|
|
! test -r file &&
|
|
|
|
test file = "$(cat .gitignore)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'stash file to symlink' '
|
|
|
|
git reset --hard &&
|
|
|
|
rm file &&
|
|
|
|
ln -s file2 file &&
|
|
|
|
git stash save "file to symlink" &&
|
2022-02-22 21:54:29 +00:00
|
|
|
test_path_is_file_not_symlink file &&
|
2010-04-18 18:27:49 +00:00
|
|
|
test bar = "$(cat file)" &&
|
|
|
|
git stash apply &&
|
2022-02-22 21:54:30 +00:00
|
|
|
test_path_is_symlink file &&
|
|
|
|
test "$(test_readlink file)" = file2
|
2010-04-18 18:27:49 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'stash file to symlink (stage rm)' '
|
|
|
|
git reset --hard &&
|
|
|
|
git rm file &&
|
|
|
|
ln -s file2 file &&
|
|
|
|
git stash save "file to symlink (stage rm)" &&
|
2022-02-22 21:54:29 +00:00
|
|
|
test_path_is_file_not_symlink file &&
|
2010-04-18 18:27:49 +00:00
|
|
|
test bar = "$(cat file)" &&
|
|
|
|
git stash apply &&
|
2022-02-22 21:54:30 +00:00
|
|
|
test_path_is_symlink file &&
|
|
|
|
test "$(test_readlink file)" = file2
|
2010-04-18 18:27:49 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'stash file to symlink (full stage)' '
|
|
|
|
git reset --hard &&
|
|
|
|
rm file &&
|
|
|
|
ln -s file2 file &&
|
|
|
|
git add file &&
|
|
|
|
git stash save "file to symlink (full stage)" &&
|
2022-02-22 21:54:29 +00:00
|
|
|
test_path_is_file_not_symlink file &&
|
2010-04-18 18:27:49 +00:00
|
|
|
test bar = "$(cat file)" &&
|
|
|
|
git stash apply &&
|
2022-02-22 21:54:30 +00:00
|
|
|
test_path_is_symlink file &&
|
|
|
|
test "$(test_readlink file)" = file2
|
2010-04-18 18:27:49 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
# This test creates a commit with a symlink used for the following tests
|
|
|
|
|
2013-06-07 20:53:28 +00:00
|
|
|
test_expect_success 'stash symlink to file' '
|
2010-04-18 18:27:49 +00:00
|
|
|
git reset --hard &&
|
2013-06-07 20:53:28 +00:00
|
|
|
test_ln_s_add file filelink &&
|
2010-04-18 18:27:49 +00:00
|
|
|
git commit -m "Add symlink" &&
|
|
|
|
rm filelink &&
|
|
|
|
cp file filelink &&
|
2013-06-07 20:53:28 +00:00
|
|
|
git stash save "symlink to file"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'this must have re-created the symlink' '
|
2010-04-18 18:27:49 +00:00
|
|
|
test -h filelink &&
|
2013-06-07 20:53:28 +00:00
|
|
|
case "$(ls -l filelink)" in *" filelink -> file") :;; *) false;; esac
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'unstash must re-create the file' '
|
2010-04-18 18:27:49 +00:00
|
|
|
git stash apply &&
|
|
|
|
! test -h filelink &&
|
|
|
|
test bar = "$(cat file)"
|
|
|
|
'
|
|
|
|
|
2013-06-07 20:53:28 +00:00
|
|
|
test_expect_success 'stash symlink to file (stage rm)' '
|
2010-04-18 18:27:49 +00:00
|
|
|
git reset --hard &&
|
|
|
|
git rm filelink &&
|
|
|
|
cp file filelink &&
|
2013-06-07 20:53:28 +00:00
|
|
|
git stash save "symlink to file (stage rm)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'this must have re-created the symlink' '
|
2010-04-18 18:27:49 +00:00
|
|
|
test -h filelink &&
|
2013-06-07 20:53:28 +00:00
|
|
|
case "$(ls -l filelink)" in *" filelink -> file") :;; *) false;; esac
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'unstash must re-create the file' '
|
2010-04-18 18:27:49 +00:00
|
|
|
git stash apply &&
|
|
|
|
! test -h filelink &&
|
|
|
|
test bar = "$(cat file)"
|
|
|
|
'
|
|
|
|
|
2013-06-07 20:53:28 +00:00
|
|
|
test_expect_success 'stash symlink to file (full stage)' '
|
2010-04-18 18:27:49 +00:00
|
|
|
git reset --hard &&
|
|
|
|
rm filelink &&
|
|
|
|
cp file filelink &&
|
|
|
|
git add filelink &&
|
2013-06-07 20:53:28 +00:00
|
|
|
git stash save "symlink to file (full stage)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success SYMLINKS 'this must have re-created the symlink' '
|
2010-04-18 18:27:49 +00:00
|
|
|
test -h filelink &&
|
2013-06-07 20:53:28 +00:00
|
|
|
case "$(ls -l filelink)" in *" filelink -> file") :;; *) false;; esac
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'unstash must re-create the file' '
|
2010-04-18 18:27:49 +00:00
|
|
|
git stash apply &&
|
|
|
|
! test -h filelink &&
|
|
|
|
test bar = "$(cat file)"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_failure 'stash directory to file' '
|
|
|
|
git reset --hard &&
|
|
|
|
mkdir dir &&
|
|
|
|
echo foo >dir/file &&
|
|
|
|
git add dir/file &&
|
|
|
|
git commit -m "Add file in dir" &&
|
|
|
|
rm -fr dir &&
|
|
|
|
echo bar >dir &&
|
|
|
|
git stash save "directory to file" &&
|
2022-02-22 21:54:28 +00:00
|
|
|
test_path_is_dir dir &&
|
2010-04-18 18:27:49 +00:00
|
|
|
test foo = "$(cat dir/file)" &&
|
|
|
|
test_must_fail git stash apply &&
|
|
|
|
test bar = "$(cat dir)" &&
|
|
|
|
git reset --soft HEAD^
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_failure 'stash file to directory' '
|
|
|
|
git reset --hard &&
|
|
|
|
rm file &&
|
|
|
|
mkdir file &&
|
|
|
|
echo foo >file/file &&
|
|
|
|
git stash save "file to directory" &&
|
2022-02-22 21:54:28 +00:00
|
|
|
test_path_is_file file &&
|
2010-04-18 18:27:49 +00:00
|
|
|
test bar = "$(cat file)" &&
|
|
|
|
git stash apply &&
|
2022-02-22 21:54:28 +00:00
|
|
|
test_path_is_file file/file &&
|
2010-04-18 18:27:49 +00:00
|
|
|
test foo = "$(cat file/file)"
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:09 +00:00
|
|
|
test_expect_success 'giving too many ref arguments does not modify files' '
|
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
echo foo >file2 &&
|
|
|
|
git stash &&
|
|
|
|
echo bar >file2 &&
|
|
|
|
git stash &&
|
|
|
|
test-tool chmtime =123456789 file2 &&
|
|
|
|
for type in apply pop "branch stash-branch"
|
|
|
|
do
|
|
|
|
test_must_fail git stash $type stash@{0} stash@{1} 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Too many revisions" err &&
|
2019-02-25 23:16:09 +00:00
|
|
|
test 123456789 = $(test-tool chmtime -g file2) || return 1
|
|
|
|
done
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'drop: too many arguments errors out (does nothing)' '
|
|
|
|
git stash list >expect &&
|
|
|
|
test_must_fail git stash drop stash@{0} stash@{1} 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Too many revisions" err &&
|
2019-02-25 23:16:09 +00:00
|
|
|
git stash list >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'show: too many arguments errors out (does nothing)' '
|
|
|
|
test_must_fail git stash show stash@{0} stash@{1} 2>err 1>out &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Too many revisions" err &&
|
2019-02-25 23:16:09 +00:00
|
|
|
test_must_be_empty out
|
|
|
|
'
|
|
|
|
|
2017-08-19 20:13:24 +00:00
|
|
|
test_expect_success 'stash create - no changes' '
|
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
|
|
|
git stash create >actual &&
|
|
|
|
test_must_be_empty actual
|
|
|
|
'
|
|
|
|
|
2010-08-21 04:09:03 +00:00
|
|
|
test_expect_success 'stash branch - no stashes on stack, stash-like argument' '
|
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >>file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
|
|
|
git stash branch stash-branch ${STASH_ID} &&
|
2020-11-18 23:44:26 +00:00
|
|
|
test_when_finished "git reset --hard HEAD && git checkout main &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git branch -D stash-branch" &&
|
2010-08-21 04:09:03 +00:00
|
|
|
test $(git ls-files --modified | wc -l) -eq 1
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash branch - stashes on stack, stash-like argument' '
|
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >>file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash &&
|
|
|
|
test_when_finished "git stash drop" &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar >>file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
|
|
|
git stash branch stash-branch ${STASH_ID} &&
|
2020-11-18 23:44:26 +00:00
|
|
|
test_when_finished "git reset --hard HEAD && git checkout main &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git branch -D stash-branch" &&
|
2010-08-21 04:09:03 +00:00
|
|
|
test $(git ls-files --modified | wc -l) -eq 1
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:09 +00:00
|
|
|
test_expect_success 'stash branch complains with no arguments' '
|
|
|
|
test_must_fail git stash branch 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "No branch name specified" err
|
2019-02-25 23:16:09 +00:00
|
|
|
'
|
|
|
|
|
2012-03-13 05:01:32 +00:00
|
|
|
test_expect_success 'stash show format defaults to --stat' '
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >>file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash &&
|
|
|
|
test_when_finished "git stash drop" &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar >>file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
2010-09-24 20:40:38 +00:00
|
|
|
cat >expected <<-EOF &&
|
2012-04-30 20:38:58 +00:00
|
|
|
file | 1 +
|
2012-02-01 12:55:07 +00:00
|
|
|
1 file changed, 1 insertion(+)
|
2010-09-24 20:40:38 +00:00
|
|
|
EOF
|
|
|
|
git stash show ${STASH_ID} >actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expected actual
|
2010-08-21 04:09:03 +00:00
|
|
|
'
|
2010-09-24 20:40:38 +00:00
|
|
|
|
2012-03-13 05:01:32 +00:00
|
|
|
test_expect_success 'stash show - stashes on stack, stash-like argument' '
|
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >>file &&
|
2012-03-13 05:01:32 +00:00
|
|
|
git stash &&
|
|
|
|
test_when_finished "git stash drop" &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar >>file &&
|
2012-03-13 05:01:32 +00:00
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
|
|
|
echo "1 0 file" >expected &&
|
|
|
|
git stash show --numstat ${STASH_ID} >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2010-09-24 22:15:34 +00:00
|
|
|
test_expect_success 'stash show -p - stashes on stack, stash-like argument' '
|
2010-09-24 20:40:38 +00:00
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >>file &&
|
2010-09-24 20:40:38 +00:00
|
|
|
git stash &&
|
|
|
|
test_when_finished "git stash drop" &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar >>file &&
|
2010-09-24 20:40:38 +00:00
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
|
|
|
cat >expected <<-EOF &&
|
|
|
|
diff --git a/file b/file
|
|
|
|
index 7601807..935fbd3 100644
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@ -1 +1,2 @@
|
|
|
|
baz
|
|
|
|
+bar
|
|
|
|
EOF
|
|
|
|
git stash show -p ${STASH_ID} >actual &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expected actual
|
2010-09-24 20:40:38 +00:00
|
|
|
'
|
|
|
|
|
2010-09-24 22:15:34 +00:00
|
|
|
test_expect_success 'stash show - no stashes on stack, stash-like argument' '
|
2010-09-24 20:40:38 +00:00
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >>file &&
|
2010-09-24 20:40:38 +00:00
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
2012-03-13 05:01:32 +00:00
|
|
|
echo "1 0 file" >expected &&
|
|
|
|
git stash show --numstat ${STASH_ID} >actual &&
|
|
|
|
test_cmp expected actual
|
2010-09-24 20:40:38 +00:00
|
|
|
'
|
|
|
|
|
2010-09-24 22:15:34 +00:00
|
|
|
test_expect_success 'stash show -p - no stashes on stack, stash-like argument' '
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >>file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
2010-09-24 20:40:38 +00:00
|
|
|
cat >expected <<-EOF &&
|
|
|
|
diff --git a/file b/file
|
|
|
|
index 7601807..71b52c4 100644
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@ -1 +1,2 @@
|
|
|
|
baz
|
|
|
|
+foo
|
|
|
|
EOF
|
|
|
|
git stash show -p ${STASH_ID} >actual &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expected actual
|
2010-08-21 04:09:03 +00:00
|
|
|
'
|
|
|
|
|
stash: setup default diff output format if necessary
In the scripted 'git stash show' when no arguments are passed, we just
pass '--stat' to 'git diff'. When any argument is passed to 'stash
show', we no longer pass '--stat' to 'git diff', and pass whatever
flags are passed directly through to 'git diff'.
By default 'git diff' shows the patch output. So when a user uses
'git stash show --patience', they would be shown the diff as expected,
using the patience algorithm. '--patience' in this case only changes
the diff algorithm, but does not cause 'git diff' to show the diff by
itself. The diff is shown because that's the default behaviour of
'git diff'.
In the C version of 'git stash show', we try to emulate that behaviour
using the internal diff API. However we forgot to set up the default
output format, in case it wasn't set by any of the flags that were
passed through. So 'git stash show --patience' in the builtin version
of stash would be completely silent, while it would show the diff in
the scripted version.
The same thing would happen for other flags that only affect the way a
patch is displayed, rather than switching to a different output format
than the default one.
Fix this by setting up the default output format for 'git diff'.
Reported-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-03-20 22:49:55 +00:00
|
|
|
test_expect_success 'stash show --patience shows diff' '
|
|
|
|
git reset --hard &&
|
|
|
|
echo foo >>file &&
|
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
|
|
|
cat >expected <<-EOF &&
|
|
|
|
diff --git a/file b/file
|
|
|
|
index 7601807..71b52c4 100644
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@ -1 +1,2 @@
|
|
|
|
baz
|
|
|
|
+foo
|
|
|
|
EOF
|
|
|
|
git stash show --patience ${STASH_ID} >actual &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expected actual
|
stash: setup default diff output format if necessary
In the scripted 'git stash show' when no arguments are passed, we just
pass '--stat' to 'git diff'. When any argument is passed to 'stash
show', we no longer pass '--stat' to 'git diff', and pass whatever
flags are passed directly through to 'git diff'.
By default 'git diff' shows the patch output. So when a user uses
'git stash show --patience', they would be shown the diff as expected,
using the patience algorithm. '--patience' in this case only changes
the diff algorithm, but does not cause 'git diff' to show the diff by
itself. The diff is shown because that's the default behaviour of
'git diff'.
In the C version of 'git stash show', we try to emulate that behaviour
using the internal diff API. However we forgot to set up the default
output format, in case it wasn't set by any of the flags that were
passed through. So 'git stash show --patience' in the builtin version
of stash would be completely silent, while it would show the diff in
the scripted version.
The same thing would happen for other flags that only affect the way a
patch is displayed, rather than switching to a different output format
than the default one.
Fix this by setting up the default output format for 'git diff'.
Reported-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-03-20 22:49:55 +00:00
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:12 +00:00
|
|
|
test_expect_success 'drop: fail early if specified stash is not a stash ref' '
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD && git stash clear" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar >file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash &&
|
2010-08-31 14:49:20 +00:00
|
|
|
test_must_fail git stash drop $(git rev-parse stash@{0}) &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash pop &&
|
|
|
|
test bar = "$(cat file)" &&
|
|
|
|
git reset --hard HEAD
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:12 +00:00
|
|
|
test_expect_success 'pop: fail early if specified stash is not a stash ref' '
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash clear &&
|
|
|
|
test_when_finished "git reset --hard HEAD && git stash clear" &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo foo >file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar >file &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash &&
|
2010-08-31 14:49:20 +00:00
|
|
|
test_must_fail git stash pop $(git rev-parse stash@{0}) &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash pop &&
|
|
|
|
test bar = "$(cat file)" &&
|
|
|
|
git reset --hard HEAD
|
|
|
|
'
|
|
|
|
|
2011-06-16 13:42:48 +00:00
|
|
|
test_expect_success 'ref with non-existent reflog' '
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash clear &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar5 >file &&
|
|
|
|
echo bar6 >file2 &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git add file2 &&
|
|
|
|
git stash &&
|
2011-08-30 00:06:07 +00:00
|
|
|
test_must_fail git rev-parse --quiet --verify does-not-exist &&
|
2010-08-31 14:49:20 +00:00
|
|
|
test_must_fail git stash drop does-not-exist &&
|
|
|
|
test_must_fail git stash drop does-not-exist@{0} &&
|
|
|
|
test_must_fail git stash pop does-not-exist &&
|
|
|
|
test_must_fail git stash pop does-not-exist@{0} &&
|
|
|
|
test_must_fail git stash apply does-not-exist &&
|
|
|
|
test_must_fail git stash apply does-not-exist@{0} &&
|
|
|
|
test_must_fail git stash show does-not-exist &&
|
|
|
|
test_must_fail git stash show does-not-exist@{0} &&
|
|
|
|
test_must_fail git stash branch tmp does-not-exist &&
|
|
|
|
test_must_fail git stash branch tmp does-not-exist@{0} &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash drop
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'invalid ref of the form stash@{n}, n >= N' '
|
|
|
|
git stash clear &&
|
2010-08-31 14:49:20 +00:00
|
|
|
test_must_fail git stash drop stash@{0} &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo bar5 >file &&
|
|
|
|
echo bar6 >file2 &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git add file2 &&
|
|
|
|
git stash &&
|
2011-04-05 23:21:13 +00:00
|
|
|
test_must_fail git stash drop stash@{1} &&
|
|
|
|
test_must_fail git stash pop stash@{1} &&
|
|
|
|
test_must_fail git stash apply stash@{1} &&
|
|
|
|
test_must_fail git stash show stash@{1} &&
|
|
|
|
test_must_fail git stash branch tmp stash@{1} &&
|
2010-08-21 04:09:03 +00:00
|
|
|
git stash drop
|
|
|
|
'
|
|
|
|
|
2016-10-24 23:40:13 +00:00
|
|
|
test_expect_success 'invalid ref of the form "n", n >= N' '
|
|
|
|
git stash clear &&
|
|
|
|
test_must_fail git stash drop 0 &&
|
|
|
|
echo bar5 >file &&
|
|
|
|
echo bar6 >file2 &&
|
|
|
|
git add file2 &&
|
|
|
|
git stash &&
|
|
|
|
test_must_fail git stash drop 1 &&
|
|
|
|
test_must_fail git stash pop 1 &&
|
|
|
|
test_must_fail git stash apply 1 &&
|
|
|
|
test_must_fail git stash show 1 &&
|
|
|
|
test_must_fail git stash branch tmp 1 &&
|
|
|
|
git stash drop
|
|
|
|
'
|
|
|
|
|
2019-06-15 11:26:18 +00:00
|
|
|
test_expect_success 'valid ref of the form "n", n < N' '
|
|
|
|
git stash clear &&
|
|
|
|
echo bar5 >file &&
|
|
|
|
echo bar6 >file2 &&
|
|
|
|
git add file2 &&
|
|
|
|
git stash &&
|
|
|
|
git stash show 0 &&
|
|
|
|
git stash branch tmp 0 &&
|
2020-11-18 23:44:26 +00:00
|
|
|
git checkout main &&
|
2019-06-15 11:26:18 +00:00
|
|
|
git stash &&
|
|
|
|
git stash apply 0 &&
|
|
|
|
git reset --hard &&
|
|
|
|
git stash pop 0 &&
|
|
|
|
git stash &&
|
|
|
|
git stash drop 0 &&
|
|
|
|
test_must_fail git stash drop
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:12 +00:00
|
|
|
test_expect_success 'branch: do not drop the stash if the branch exists' '
|
2010-09-28 13:19:51 +00:00
|
|
|
git stash clear &&
|
|
|
|
echo foo >file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m initial &&
|
|
|
|
echo bar >file &&
|
|
|
|
git stash &&
|
2020-11-18 23:44:26 +00:00
|
|
|
test_must_fail git stash branch main stash@{0} &&
|
2010-09-28 13:19:51 +00:00
|
|
|
git rev-parse stash@{0} --
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:12 +00:00
|
|
|
test_expect_success 'branch: should not drop the stash if the apply fails' '
|
2017-08-19 20:13:25 +00:00
|
|
|
git stash clear &&
|
|
|
|
git reset HEAD~1 --hard &&
|
|
|
|
echo foo >file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m initial &&
|
|
|
|
echo bar >file &&
|
|
|
|
git stash &&
|
|
|
|
echo baz >file &&
|
2020-11-18 23:44:26 +00:00
|
|
|
test_when_finished "git checkout main" &&
|
2017-08-19 20:13:25 +00:00
|
|
|
test_must_fail git stash branch new_branch stash@{0} &&
|
|
|
|
git rev-parse stash@{0} --
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:12 +00:00
|
|
|
test_expect_success 'apply: show same status as git status (relative to ./)' '
|
2011-03-14 19:19:36 +00:00
|
|
|
git stash clear &&
|
|
|
|
echo 1 >subdir/subfile1 &&
|
|
|
|
echo 2 >subdir/subfile2 &&
|
|
|
|
git add subdir/subfile1 &&
|
|
|
|
git commit -m subdir &&
|
|
|
|
(
|
|
|
|
cd subdir &&
|
|
|
|
echo x >subfile1 &&
|
|
|
|
echo x >../file &&
|
|
|
|
git status >../expect &&
|
|
|
|
git stash &&
|
|
|
|
sane_unset GIT_MERGE_VERBOSITY &&
|
|
|
|
git stash apply
|
|
|
|
) |
|
2017-03-21 22:12:17 +00:00
|
|
|
sed -e 1d >actual && # drop "Saved..."
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2011-03-14 19:19:36 +00:00
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:10 +00:00
|
|
|
cat >expect <<EOF
|
stash: Don't fail if work dir contains file named 'HEAD'
When performing a plain "git stash" (without --patch), git-diff would fail
with "fatal: ambiguous argument 'HEAD': both revision and filename". The
output was piped into git-update-index, masking the failed exit status.
The output is now sent to a temporary file (which is cleaned up by
existing code), and the exit status is checked. The "HEAD" arg to the
git-diff invocation has been disambiguated too, of course.
In patch mode, "git stash -p" would fail harmlessly, leaving the working
dir untouched. Interactive adding is fine, but the resulting tree was
diffed with an ambiguous 'HEAD' argument.
Use >foo (no space) when redirecting output.
In t3904, checks and operations on each file are in the order they'll
appear when interactively staging.
In t3905, fix a bug in "stash save --include-untracked -q is quiet": The
redirected stdout file was considered untracked, and so was removed from
the working directory. Use test path helper functions where appropriate.
Signed-off-by: Jonathon Mah <me@JonathonMah.com>
Acked-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-31 00:14:01 +00:00
|
|
|
diff --git a/HEAD b/HEAD
|
|
|
|
new file mode 100644
|
|
|
|
index 0000000..fe0cbee
|
|
|
|
--- /dev/null
|
|
|
|
+++ b/HEAD
|
|
|
|
@@ -0,0 +1 @@
|
|
|
|
+file-not-a-ref
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'stash where working directory contains "HEAD" file' '
|
|
|
|
git stash clear &&
|
|
|
|
git reset --hard &&
|
2019-02-25 23:16:10 +00:00
|
|
|
echo file-not-a-ref >HEAD &&
|
stash: Don't fail if work dir contains file named 'HEAD'
When performing a plain "git stash" (without --patch), git-diff would fail
with "fatal: ambiguous argument 'HEAD': both revision and filename". The
output was piped into git-update-index, masking the failed exit status.
The output is now sent to a temporary file (which is cleaned up by
existing code), and the exit status is checked. The "HEAD" arg to the
git-diff invocation has been disambiguated too, of course.
In patch mode, "git stash -p" would fail harmlessly, leaving the working
dir untouched. Interactive adding is fine, but the resulting tree was
diffed with an ambiguous 'HEAD' argument.
Use >foo (no space) when redirecting output.
In t3904, checks and operations on each file are in the order they'll
appear when interactively staging.
In t3905, fix a bug in "stash save --include-untracked -q is quiet": The
redirected stdout file was considered untracked, and so was removed from
the working directory. Use test path helper functions where appropriate.
Signed-off-by: Jonathon Mah <me@JonathonMah.com>
Acked-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-31 00:14:01 +00:00
|
|
|
git add HEAD &&
|
|
|
|
test_tick &&
|
|
|
|
git stash &&
|
|
|
|
git diff-files --quiet &&
|
|
|
|
git diff-index --cached --quiet HEAD &&
|
|
|
|
test "$(git rev-parse stash^)" = "$(git rev-parse HEAD)" &&
|
2019-02-25 23:16:10 +00:00
|
|
|
git diff stash^..stash >output &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expect output
|
stash: Don't fail if work dir contains file named 'HEAD'
When performing a plain "git stash" (without --patch), git-diff would fail
with "fatal: ambiguous argument 'HEAD': both revision and filename". The
output was piped into git-update-index, masking the failed exit status.
The output is now sent to a temporary file (which is cleaned up by
existing code), and the exit status is checked. The "HEAD" arg to the
git-diff invocation has been disambiguated too, of course.
In patch mode, "git stash -p" would fail harmlessly, leaving the working
dir untouched. Interactive adding is fine, but the resulting tree was
diffed with an ambiguous 'HEAD' argument.
Use >foo (no space) when redirecting output.
In t3904, checks and operations on each file are in the order they'll
appear when interactively staging.
In t3905, fix a bug in "stash save --include-untracked -q is quiet": The
redirected stdout file was considered untracked, and so was removed from
the working directory. Use test path helper functions where appropriate.
Signed-off-by: Jonathon Mah <me@JonathonMah.com>
Acked-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-12-31 00:14:01 +00:00
|
|
|
'
|
|
|
|
|
2013-06-15 13:13:25 +00:00
|
|
|
test_expect_success 'store called with invalid commit' '
|
|
|
|
test_must_fail git stash store foo
|
|
|
|
'
|
|
|
|
|
2023-10-11 20:44:03 +00:00
|
|
|
test_expect_success 'store called with non-stash commit' '
|
|
|
|
test_must_fail git stash store HEAD
|
|
|
|
'
|
|
|
|
|
2013-06-15 13:13:25 +00:00
|
|
|
test_expect_success 'store updates stash ref and reflog' '
|
|
|
|
git stash clear &&
|
|
|
|
git reset --hard &&
|
|
|
|
echo quux >bazzy &&
|
|
|
|
git add bazzy &&
|
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git reset --hard &&
|
2018-08-22 18:13:19 +00:00
|
|
|
test_path_is_missing bazzy &&
|
2013-06-15 13:13:25 +00:00
|
|
|
git stash store -m quuxery $STASH_ID &&
|
2018-05-23 05:25:17 +00:00
|
|
|
test $(git rev-parse stash) = $STASH_ID &&
|
2015-07-27 22:57:08 +00:00
|
|
|
git reflog --format=%H stash| grep $STASH_ID &&
|
2013-06-15 13:13:25 +00:00
|
|
|
git stash pop &&
|
|
|
|
grep quux bazzy
|
|
|
|
'
|
|
|
|
|
2014-01-07 08:22:15 +00:00
|
|
|
test_expect_success 'handle stash specification with spaces' '
|
|
|
|
git stash clear &&
|
|
|
|
echo pig >file &&
|
|
|
|
git stash &&
|
|
|
|
stamp=$(git log -g --format="%cd" -1 refs/stash) &&
|
|
|
|
test_tick &&
|
|
|
|
echo cow >file &&
|
|
|
|
git stash &&
|
|
|
|
git stash apply "stash@{$stamp}" &&
|
|
|
|
grep pig file
|
|
|
|
'
|
|
|
|
|
stash: default listing to working-tree diff
When you list stashes, you can provide arbitrary git-log
options to change the display. However, adding just "-p"
does nothing, because each stash is actually a merge commit.
This implementation detail is easy to forget, leading to
confused users who think "-p" is not working. We can make
this easier by defaulting to "--first-parent -m", which will
show the diff against the working tree. This omits the
index portion of the stash entirely, but it's simple and it
matches what "git stash show" provides.
People who are more clueful about stash's true form can use
"--cc" to override the "-m", and the "--first-parent" will
then do nothing. For diffs, it only affects non-combined
diffs, so "--cc" overrides it. And for the traversal, we are
walking the linear reflog anyway, so we do not even care
about the parents.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-08-06 18:35:25 +00:00
|
|
|
test_expect_success 'setup stash with index and worktree changes' '
|
|
|
|
git stash clear &&
|
|
|
|
git reset --hard &&
|
|
|
|
echo index >file &&
|
|
|
|
git add file &&
|
|
|
|
echo working >file &&
|
|
|
|
git stash
|
|
|
|
'
|
|
|
|
|
2021-05-20 21:47:01 +00:00
|
|
|
test_expect_success 'stash list -p shows simple diff' '
|
2015-04-22 19:30:52 +00:00
|
|
|
cat >expect <<-EOF &&
|
|
|
|
stash@{0}
|
stash: default listing to working-tree diff
When you list stashes, you can provide arbitrary git-log
options to change the display. However, adding just "-p"
does nothing, because each stash is actually a merge commit.
This implementation detail is easy to forget, leading to
confused users who think "-p" is not working. We can make
this easier by defaulting to "--first-parent -m", which will
show the diff against the working tree. This omits the
index portion of the stash entirely, but it's simple and it
matches what "git stash show" provides.
People who are more clueful about stash's true form can use
"--cc" to override the "-m", and the "--first-parent" will
then do nothing. For diffs, it only affects non-combined
diffs, so "--cc" overrides it. And for the traversal, we are
walking the linear reflog anyway, so we do not even care
about the parents.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-08-06 18:35:25 +00:00
|
|
|
|
|
|
|
diff --git a/file b/file
|
|
|
|
index 257cc56..d26b33d 100644
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@ -1 +1 @@
|
|
|
|
-foo
|
|
|
|
+working
|
|
|
|
EOF
|
2015-04-22 19:30:52 +00:00
|
|
|
git stash list --format=%gd -p >actual &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expect actual
|
stash: default listing to working-tree diff
When you list stashes, you can provide arbitrary git-log
options to change the display. However, adding just "-p"
does nothing, because each stash is actually a merge commit.
This implementation detail is easy to forget, leading to
confused users who think "-p" is not working. We can make
this easier by defaulting to "--first-parent -m", which will
show the diff against the working tree. This omits the
index portion of the stash entirely, but it's simple and it
matches what "git stash show" provides.
People who are more clueful about stash's true form can use
"--cc" to override the "-m", and the "--first-parent" will
then do nothing. For diffs, it only affects non-combined
diffs, so "--cc" overrides it. And for the traversal, we are
walking the linear reflog anyway, so we do not even care
about the parents.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-08-06 18:35:25 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash list --cc shows combined diff' '
|
|
|
|
cat >expect <<-\EOF &&
|
2015-04-22 19:30:52 +00:00
|
|
|
stash@{0}
|
stash: default listing to working-tree diff
When you list stashes, you can provide arbitrary git-log
options to change the display. However, adding just "-p"
does nothing, because each stash is actually a merge commit.
This implementation detail is easy to forget, leading to
confused users who think "-p" is not working. We can make
this easier by defaulting to "--first-parent -m", which will
show the diff against the working tree. This omits the
index portion of the stash entirely, but it's simple and it
matches what "git stash show" provides.
People who are more clueful about stash's true form can use
"--cc" to override the "-m", and the "--first-parent" will
then do nothing. For diffs, it only affects non-combined
diffs, so "--cc" overrides it. And for the traversal, we are
walking the linear reflog anyway, so we do not even care
about the parents.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-08-06 18:35:25 +00:00
|
|
|
|
|
|
|
diff --cc file
|
|
|
|
index 257cc56,9015a7a..d26b33d
|
|
|
|
--- a/file
|
|
|
|
+++ b/file
|
|
|
|
@@@ -1,1 -1,1 +1,1 @@@
|
|
|
|
- foo
|
|
|
|
-index
|
|
|
|
++working
|
|
|
|
EOF
|
2015-04-22 19:30:52 +00:00
|
|
|
git stash list --format=%gd -p --cc >actual &&
|
2019-08-26 01:43:41 +00:00
|
|
|
diff_cmp expect actual
|
stash: default listing to working-tree diff
When you list stashes, you can provide arbitrary git-log
options to change the display. However, adding just "-p"
does nothing, because each stash is actually a merge commit.
This implementation detail is easy to forget, leading to
confused users who think "-p" is not working. We can make
this easier by defaulting to "--first-parent -m", which will
show the diff against the working tree. This omits the
index portion of the stash entirely, but it's simple and it
matches what "git stash show" provides.
People who are more clueful about stash's true form can use
"--cc" to override the "-m", and the "--first-parent" will
then do nothing. For diffs, it only affects non-combined
diffs, so "--cc" overrides it. And for the traversal, we are
walking the linear reflog anyway, so we do not even care
about the parents.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-08-06 18:35:25 +00:00
|
|
|
'
|
|
|
|
|
2016-12-06 20:25:21 +00:00
|
|
|
test_expect_success 'stash is not confused by partial renames' '
|
|
|
|
mv file renamed &&
|
|
|
|
git add renamed &&
|
|
|
|
git stash &&
|
|
|
|
git stash apply &&
|
|
|
|
test_path_is_file renamed &&
|
|
|
|
test_path_is_missing file
|
|
|
|
'
|
|
|
|
|
2017-02-19 11:03:08 +00:00
|
|
|
test_expect_success 'push -m shows right message' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git stash push -m "test message" &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "stash@{0}: On main: test message" >expect &&
|
2017-02-19 11:03:08 +00:00
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-11-22 21:20:30 +00:00
|
|
|
test_expect_success 'push -m also works without space' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git stash push -m"unspaced test message" &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "stash@{0}: On main: unspaced test message" >expect &&
|
2017-11-22 21:20:30 +00:00
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'store -m foo shows right message' '
|
|
|
|
git stash clear &&
|
|
|
|
git reset --hard &&
|
|
|
|
echo quux >bazzy &&
|
|
|
|
git add bazzy &&
|
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git stash store -m "store m" $STASH_ID &&
|
|
|
|
echo "stash@{0}: store m" >expect &&
|
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'store -mfoo shows right message' '
|
|
|
|
git stash clear &&
|
|
|
|
git reset --hard &&
|
|
|
|
echo quux >bazzy &&
|
|
|
|
git add bazzy &&
|
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git stash store -m"store mfoo" $STASH_ID &&
|
|
|
|
echo "stash@{0}: store mfoo" >expect &&
|
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'store --message=foo shows right message' '
|
|
|
|
git stash clear &&
|
|
|
|
git reset --hard &&
|
|
|
|
echo quux >bazzy &&
|
|
|
|
git add bazzy &&
|
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git stash store --message="store message=foo" $STASH_ID &&
|
|
|
|
echo "stash@{0}: store message=foo" >expect &&
|
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'store --message foo shows right message' '
|
|
|
|
git stash clear &&
|
|
|
|
git reset --hard &&
|
|
|
|
echo quux >bazzy &&
|
|
|
|
git add bazzy &&
|
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
git stash store --message "store message foo" $STASH_ID &&
|
|
|
|
echo "stash@{0}: store message foo" >expect &&
|
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push -mfoo uses right message' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git stash push -m"test mfoo" &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "stash@{0}: On main: test mfoo" >expect &&
|
2017-11-22 21:20:30 +00:00
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push --message foo is synonym for -mfoo' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git stash push --message "test message foo" &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "stash@{0}: On main: test message foo" >expect &&
|
2017-11-22 21:20:30 +00:00
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push --message=foo is synonym for -mfoo' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git stash push --message="test message=foo" &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "stash@{0}: On main: test message=foo" >expect &&
|
2017-11-22 21:20:30 +00:00
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push -m shows right message' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git stash push -m "test m foo" &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "stash@{0}: On main: test m foo" >expect &&
|
2017-11-22 21:20:30 +00:00
|
|
|
git stash list -1 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-02-19 11:03:09 +00:00
|
|
|
test_expect_success 'create stores correct message' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
STASH_ID=$(git stash create "create test message") &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "On main: create test message" >expect &&
|
2017-02-19 11:03:09 +00:00
|
|
|
git show --pretty=%s -s ${STASH_ID} >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2022-01-24 20:53:42 +00:00
|
|
|
test_expect_success 'create when branch name has /' '
|
|
|
|
test_when_finished "git checkout main" &&
|
|
|
|
git checkout -b some/topic &&
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
STASH_ID=$(git stash create "create test message") &&
|
|
|
|
echo "On some/topic: create test message" >expect &&
|
|
|
|
git show --pretty=%s -s ${STASH_ID} >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-02-19 11:03:09 +00:00
|
|
|
test_expect_success 'create with multiple arguments for the message' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
STASH_ID=$(git stash create test untracked) &&
|
2020-11-18 23:44:26 +00:00
|
|
|
echo "On main: test untracked" >expect &&
|
2017-02-19 11:03:09 +00:00
|
|
|
git show --pretty=%s -s ${STASH_ID} >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-08-19 20:13:26 +00:00
|
|
|
test_expect_success 'create in a detached state' '
|
2020-11-18 23:44:26 +00:00
|
|
|
test_when_finished "git checkout main" &&
|
2017-08-19 20:13:26 +00:00
|
|
|
git checkout HEAD~1 &&
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
STASH_ID=$(git stash create) &&
|
|
|
|
HEAD_ID=$(git rev-parse --short HEAD) &&
|
|
|
|
echo "WIP on (no branch): ${HEAD_ID} initial" >expect &&
|
|
|
|
git show --pretty=%s -s ${STASH_ID} >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-02-28 20:33:38 +00:00
|
|
|
test_expect_success 'stash -- <pathspec> stashes and restores the file' '
|
|
|
|
>foo &&
|
|
|
|
>bar &&
|
|
|
|
git add foo bar &&
|
|
|
|
git stash push -- foo &&
|
|
|
|
test_path_is_file bar &&
|
|
|
|
test_path_is_missing foo &&
|
|
|
|
git stash pop &&
|
|
|
|
test_path_is_file foo &&
|
|
|
|
test_path_is_file bar
|
|
|
|
'
|
|
|
|
|
2017-06-13 11:38:34 +00:00
|
|
|
test_expect_success 'stash -- <pathspec> stashes in subdirectory' '
|
|
|
|
mkdir sub &&
|
|
|
|
>foo &&
|
|
|
|
>bar &&
|
|
|
|
git add foo bar &&
|
|
|
|
(
|
|
|
|
cd sub &&
|
|
|
|
git stash push -- ../foo
|
|
|
|
) &&
|
|
|
|
test_path_is_file bar &&
|
|
|
|
test_path_is_missing foo &&
|
|
|
|
git stash pop &&
|
|
|
|
test_path_is_file foo &&
|
|
|
|
test_path_is_file bar
|
|
|
|
'
|
|
|
|
|
2017-02-28 20:33:38 +00:00
|
|
|
test_expect_success 'stash with multiple pathspec arguments' '
|
|
|
|
>foo &&
|
|
|
|
>bar &&
|
|
|
|
>extra &&
|
|
|
|
git add foo bar extra &&
|
|
|
|
git stash push -- foo bar &&
|
|
|
|
test_path_is_missing bar &&
|
|
|
|
test_path_is_missing foo &&
|
|
|
|
test_path_is_file extra &&
|
|
|
|
git stash pop &&
|
|
|
|
test_path_is_file foo &&
|
|
|
|
test_path_is_file bar &&
|
|
|
|
test_path_is_file extra
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash with file including $IFS character' '
|
|
|
|
>"foo bar" &&
|
|
|
|
>foo &&
|
|
|
|
>bar &&
|
|
|
|
git add foo* &&
|
|
|
|
git stash push -- "foo b*" &&
|
|
|
|
test_path_is_missing "foo bar" &&
|
|
|
|
test_path_is_file foo &&
|
|
|
|
test_path_is_file bar &&
|
|
|
|
git stash pop &&
|
|
|
|
test_path_is_file "foo bar" &&
|
|
|
|
test_path_is_file foo &&
|
|
|
|
test_path_is_file bar
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash with pathspec matching multiple paths' '
|
2023-05-18 20:03:14 +00:00
|
|
|
echo original >file &&
|
|
|
|
echo original >other-file &&
|
|
|
|
git commit -m "two" file other-file &&
|
|
|
|
echo modified >file &&
|
|
|
|
echo modified >other-file &&
|
|
|
|
git stash push -- "*file" &&
|
|
|
|
echo original >expect &&
|
|
|
|
test_cmp expect file &&
|
|
|
|
test_cmp expect other-file &&
|
|
|
|
git stash pop &&
|
|
|
|
echo modified >expect &&
|
|
|
|
test_cmp expect file &&
|
|
|
|
test_cmp expect other-file
|
2017-02-28 20:33:38 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash push -p with pathspec shows no changes only once' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git commit -m "tmp" &&
|
|
|
|
git stash push -p foo >actual &&
|
|
|
|
echo "No local changes to save" >expect &&
|
|
|
|
git reset --hard HEAD~ &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2017-02-28 20:33:38 +00:00
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:12 +00:00
|
|
|
test_expect_success 'push <pathspec>: show no changes when there are none' '
|
2017-02-28 20:33:38 +00:00
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git commit -m "tmp" &&
|
|
|
|
git stash push foo >actual &&
|
|
|
|
echo "No local changes to save" >expect &&
|
|
|
|
git reset --hard HEAD~ &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2017-02-28 20:33:38 +00:00
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:12 +00:00
|
|
|
test_expect_success 'push: <pathspec> not in the repository errors out' '
|
2017-02-28 20:33:38 +00:00
|
|
|
>untracked &&
|
|
|
|
test_must_fail git stash push untracked &&
|
|
|
|
test_path_is_file untracked
|
|
|
|
'
|
|
|
|
|
2019-02-25 23:16:24 +00:00
|
|
|
test_expect_success 'push: -q is quiet with changes' '
|
|
|
|
>foo &&
|
|
|
|
git add foo &&
|
|
|
|
git stash push -q >output 2>&1 &&
|
|
|
|
test_must_be_empty output
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push: -q is quiet with no changes' '
|
|
|
|
git stash push -q >output 2>&1 &&
|
|
|
|
test_must_be_empty output
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push: -q is quiet even if there is no initial commit' '
|
|
|
|
git init foo_dir &&
|
|
|
|
test_when_finished rm -rf foo_dir &&
|
|
|
|
(
|
|
|
|
cd foo_dir &&
|
|
|
|
>bar &&
|
|
|
|
test_must_fail git stash push -q >output 2>&1 &&
|
|
|
|
test_must_be_empty output
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2017-02-28 20:33:38 +00:00
|
|
|
test_expect_success 'untracked files are left in place when -u is not given' '
|
|
|
|
>file &&
|
|
|
|
git add file &&
|
|
|
|
>untracked &&
|
|
|
|
git stash push file &&
|
|
|
|
test_path_is_file untracked
|
|
|
|
'
|
|
|
|
|
2017-02-28 20:33:40 +00:00
|
|
|
test_expect_success 'stash without verb with pathspec' '
|
|
|
|
>"foo bar" &&
|
|
|
|
>foo &&
|
|
|
|
>bar &&
|
|
|
|
git add foo* &&
|
|
|
|
git stash -- "foo b*" &&
|
|
|
|
test_path_is_missing "foo bar" &&
|
|
|
|
test_path_is_file foo &&
|
|
|
|
test_path_is_file bar &&
|
|
|
|
git stash pop &&
|
|
|
|
test_path_is_file "foo bar" &&
|
|
|
|
test_path_is_file foo &&
|
|
|
|
test_path_is_file bar
|
|
|
|
'
|
|
|
|
|
2017-03-21 22:12:19 +00:00
|
|
|
test_expect_success 'stash -k -- <pathspec> leaves unstaged files intact' '
|
|
|
|
git reset &&
|
|
|
|
>foo &&
|
|
|
|
>bar &&
|
|
|
|
git add foo bar &&
|
|
|
|
git commit -m "test" &&
|
|
|
|
echo "foo" >foo &&
|
|
|
|
echo "bar" >bar &&
|
|
|
|
git stash -k -- foo &&
|
|
|
|
test "",bar = $(cat foo),$(cat bar) &&
|
|
|
|
git stash pop &&
|
|
|
|
test foo,bar = $(cat foo),$(cat bar)
|
|
|
|
'
|
|
|
|
|
stash: don't delete untracked files that match pathspec
Currently when 'git stash push -- <pathspec>' is used, untracked files
that match the pathspec will be deleted, even though they do not end up
in a stash anywhere.
This is because the original commit introducing the pathspec feature in
git stash push (df6bba0937 ("stash: teach 'push' (and 'create_stash') to
honor pathspec", 2017-02-28)) used the sequence of 'git reset <pathspec>
&& git ls-files --modified <pathspec> | git checkout-index && git clean
<pathspec>'.
The intention was to emulate what 'git reset --hard -- <pathspec>' would
do. The call to 'git clean' was supposed to clean up the files that
were unstaged by 'git reset'. This would work fine if the pathspec
doesn't match any files that were untracked before 'git stash push --
<pathspec>'. However if <pathspec> matches a file that was untracked
before invoking the 'stash' command, all untracked files matching the
pathspec would inadvertently be deleted as well, even though they
wouldn't end up in the stash, and are therefore lost.
This behaviour was never what was intended, only blobs that also end up
in the stash should be reset to their state in HEAD, previously
untracked files should be left alone.
To achieve this, first match what's in the index and what's in the
working tree by adding all changes to the index, ask diff-index what
changed between HEAD and the current index, and then apply that patch in
reverse to get rid of the changes, which includes removal of added
files and resurrection of removed files.
Reported-by: Reid Price <reid.price@gmail.com>
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-01-06 00:24:20 +00:00
|
|
|
test_expect_success 'stash -- <subdir> leaves untracked files in subdir intact' '
|
|
|
|
git reset &&
|
|
|
|
>subdir/untracked &&
|
|
|
|
>subdir/tracked1 &&
|
|
|
|
>subdir/tracked2 &&
|
|
|
|
git add subdir/tracked* &&
|
|
|
|
git stash -- subdir/ &&
|
|
|
|
test_path_is_missing subdir/tracked1 &&
|
|
|
|
test_path_is_missing subdir/tracked2 &&
|
|
|
|
test_path_is_file subdir/untracked &&
|
|
|
|
git stash pop &&
|
|
|
|
test_path_is_file subdir/tracked1 &&
|
|
|
|
test_path_is_file subdir/tracked2 &&
|
|
|
|
test_path_is_file subdir/untracked
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash -- <subdir> works with binary files' '
|
|
|
|
git reset &&
|
|
|
|
>subdir/untracked &&
|
|
|
|
>subdir/tracked &&
|
|
|
|
cp "$TEST_DIRECTORY"/test-binary-1.png subdir/tracked-binary &&
|
|
|
|
git add subdir/tracked* &&
|
|
|
|
git stash -- subdir/ &&
|
|
|
|
test_path_is_missing subdir/tracked &&
|
|
|
|
test_path_is_missing subdir/tracked-binary &&
|
|
|
|
test_path_is_file subdir/untracked &&
|
|
|
|
git stash pop &&
|
|
|
|
test_path_is_file subdir/tracked &&
|
|
|
|
test_path_is_file subdir/tracked-binary &&
|
|
|
|
test_path_is_file subdir/untracked
|
|
|
|
'
|
|
|
|
|
2019-03-06 22:09:11 +00:00
|
|
|
test_expect_success 'stash with user.name and user.email set works' '
|
|
|
|
test_config user.name "A U Thor" &&
|
|
|
|
test_config user.email "a.u@thor" &&
|
|
|
|
git stash
|
|
|
|
'
|
|
|
|
|
2018-11-18 13:44:07 +00:00
|
|
|
test_expect_success 'stash works when user.name and user.email are not set' '
|
|
|
|
git reset &&
|
|
|
|
>1 &&
|
|
|
|
git add 1 &&
|
|
|
|
echo "$GIT_AUTHOR_NAME <$GIT_AUTHOR_EMAIL>" >expect &&
|
|
|
|
git stash &&
|
|
|
|
git show -s --format="%an <%ae>" refs/stash >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
>2 &&
|
|
|
|
git add 2 &&
|
|
|
|
test_config user.useconfigonly true &&
|
|
|
|
(
|
|
|
|
sane_unset GIT_AUTHOR_NAME &&
|
|
|
|
sane_unset GIT_AUTHOR_EMAIL &&
|
|
|
|
sane_unset GIT_COMMITTER_NAME &&
|
|
|
|
sane_unset GIT_COMMITTER_EMAIL &&
|
|
|
|
test_unconfig user.email &&
|
|
|
|
test_unconfig user.name &&
|
|
|
|
test_must_fail git commit -m "should fail" &&
|
|
|
|
echo "git stash <git@stash>" >expect &&
|
|
|
|
>2 &&
|
|
|
|
git stash &&
|
|
|
|
git show -s --format="%an <%ae>" refs/stash >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2019-07-16 14:23:22 +00:00
|
|
|
test_expect_success 'stash --keep-index with file deleted in index does not resurrect it on disk' '
|
|
|
|
test_commit to-remove to-remove &&
|
|
|
|
git rm to-remove &&
|
|
|
|
git stash --keep-index &&
|
|
|
|
test_path_is_missing to-remove
|
|
|
|
'
|
|
|
|
|
2019-09-11 18:20:27 +00:00
|
|
|
test_expect_success 'stash apply should succeed with unmodified file' '
|
|
|
|
echo base >file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m base &&
|
|
|
|
|
|
|
|
# now stash a modification
|
|
|
|
echo modified >file &&
|
|
|
|
git stash &&
|
|
|
|
|
|
|
|
# make the file stat dirty
|
|
|
|
cp file other &&
|
|
|
|
mv other file &&
|
|
|
|
|
|
|
|
git stash apply
|
|
|
|
'
|
|
|
|
|
2019-10-30 10:49:38 +00:00
|
|
|
test_expect_success 'stash handles skip-worktree entries nicely' '
|
|
|
|
test_commit A &&
|
|
|
|
echo changed >A.t &&
|
|
|
|
git add A.t &&
|
|
|
|
git update-index --skip-worktree A.t &&
|
|
|
|
rm A.t &&
|
|
|
|
git stash &&
|
|
|
|
|
|
|
|
git rev-parse --verify refs/stash:A.t
|
|
|
|
'
|
|
|
|
|
2022-04-05 05:20:16 +00:00
|
|
|
|
|
|
|
BATCH_CONFIGURATION='-c core.fsync=loose-object -c core.fsyncmethod=batch'
|
|
|
|
|
|
|
|
test_expect_success 'stash with core.fsyncmethod=batch' "
|
|
|
|
test_create_unique_files 2 4 files_base_dir &&
|
|
|
|
GIT_TEST_FSYNC=1 git $BATCH_CONFIGURATION stash push -u -- ./files_base_dir/ &&
|
|
|
|
|
|
|
|
# The files were untracked, so use the third parent,
|
|
|
|
# which contains the untracked files
|
|
|
|
git ls-tree -r stash^3 -- ./files_base_dir/ |
|
|
|
|
test_parse_ls_tree_oids >stashed_files_oids &&
|
|
|
|
|
|
|
|
# We created 2 dirs with 4 files each (8 files total) above
|
|
|
|
test_line_count = 8 stashed_files_oids &&
|
|
|
|
git cat-file --batch-check='%(objectname)' <stashed_files_oids >stashed_files_actual &&
|
|
|
|
test_cmp stashed_files_oids stashed_files_actual
|
|
|
|
"
|
|
|
|
|
|
|
|
|
2021-09-10 10:29:55 +00:00
|
|
|
test_expect_success 'git stash succeeds despite directory/file change' '
|
2021-09-10 10:29:54 +00:00
|
|
|
test_create_repo directory_file_switch_v1 &&
|
|
|
|
(
|
|
|
|
cd directory_file_switch_v1 &&
|
|
|
|
test_commit init &&
|
|
|
|
|
|
|
|
test_write_lines this file has some words >filler &&
|
|
|
|
git add filler &&
|
|
|
|
git commit -m filler &&
|
|
|
|
|
|
|
|
git rm filler &&
|
|
|
|
mkdir filler &&
|
|
|
|
echo contents >filler/file &&
|
|
|
|
git stash push
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2021-09-10 10:29:56 +00:00
|
|
|
test_expect_success 'git stash can pop file -> directory saved changes' '
|
2021-09-10 10:29:54 +00:00
|
|
|
test_create_repo directory_file_switch_v2 &&
|
|
|
|
(
|
|
|
|
cd directory_file_switch_v2 &&
|
|
|
|
test_commit init &&
|
|
|
|
|
|
|
|
test_write_lines this file has some words >filler &&
|
|
|
|
git add filler &&
|
|
|
|
git commit -m filler &&
|
|
|
|
|
|
|
|
git rm filler &&
|
|
|
|
mkdir filler &&
|
|
|
|
echo contents >filler/file &&
|
|
|
|
cp filler/file expect &&
|
|
|
|
git stash push --include-untracked &&
|
|
|
|
git stash apply --index &&
|
|
|
|
test_cmp expect filler/file
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2021-09-10 10:29:56 +00:00
|
|
|
test_expect_success 'git stash can pop directory -> file saved changes' '
|
2021-09-10 10:29:54 +00:00
|
|
|
test_create_repo directory_file_switch_v3 &&
|
|
|
|
(
|
|
|
|
cd directory_file_switch_v3 &&
|
|
|
|
test_commit init &&
|
|
|
|
|
|
|
|
mkdir filler &&
|
|
|
|
test_write_lines some words >filler/file1 &&
|
|
|
|
test_write_lines and stuff >filler/file2 &&
|
|
|
|
git add filler &&
|
|
|
|
git commit -m filler &&
|
|
|
|
|
|
|
|
git rm -rf filler &&
|
|
|
|
echo contents >filler &&
|
|
|
|
cp filler expect &&
|
|
|
|
git stash push --include-untracked &&
|
|
|
|
git stash apply --index &&
|
|
|
|
test_cmp expect filler
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2022-01-04 23:04:58 +00:00
|
|
|
test_expect_success 'restore untracked files even when we hit conflicts' '
|
|
|
|
git init restore_untracked_after_conflict &&
|
|
|
|
(
|
|
|
|
cd restore_untracked_after_conflict &&
|
|
|
|
|
|
|
|
echo hi >a &&
|
|
|
|
echo there >b &&
|
|
|
|
git add . &&
|
|
|
|
git commit -m first &&
|
|
|
|
echo hello >a &&
|
|
|
|
echo something >c &&
|
|
|
|
|
|
|
|
git stash push --include-untracked &&
|
|
|
|
|
|
|
|
echo conflict >a &&
|
|
|
|
git add a &&
|
|
|
|
git commit -m second &&
|
|
|
|
|
|
|
|
test_must_fail git stash pop &&
|
|
|
|
|
|
|
|
test_path_is_file c
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2024-02-06 05:34:41 +00:00
|
|
|
test_expect_success 'stash create reports a locked index' '
|
|
|
|
test_when_finished "rm -rf repo" &&
|
|
|
|
git init repo &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
test_commit A A.file &&
|
|
|
|
echo change >A.file &&
|
|
|
|
touch .git/index.lock &&
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
error: could not write index
|
|
|
|
EOF
|
|
|
|
test_must_fail git stash create 2>err &&
|
|
|
|
test_cmp expect err
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash push reports a locked index' '
|
|
|
|
test_when_finished "rm -rf repo" &&
|
|
|
|
git init repo &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
test_commit A A.file &&
|
|
|
|
echo change >A.file &&
|
|
|
|
touch .git/index.lock &&
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
error: could not write index
|
|
|
|
EOF
|
|
|
|
test_must_fail git stash push 2>err &&
|
|
|
|
test_cmp expect err
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'stash apply reports a locked index' '
|
|
|
|
test_when_finished "rm -rf repo" &&
|
|
|
|
git init repo &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
test_commit A A.file &&
|
|
|
|
echo change >A.file &&
|
|
|
|
git stash push &&
|
|
|
|
touch .git/index.lock &&
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
error: could not write index
|
|
|
|
EOF
|
|
|
|
test_must_fail git stash apply 2>err &&
|
|
|
|
test_cmp expect err
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2007-07-02 11:14:49 +00:00
|
|
|
test_done
|