2007-09-23 22:51:40 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Copyright (c) 2007 Lars Hjemli
|
|
|
|
#
|
|
|
|
|
2008-09-03 08:59:33 +00:00
|
|
|
test_description='git merge
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2010-08-17 06:53:56 +00:00
|
|
|
Testing basic merge operations/option parsing.
|
|
|
|
|
|
|
|
! [c0] commit 0
|
|
|
|
! [c1] commit 1
|
|
|
|
! [c2] commit 2
|
|
|
|
! [c3] commit 3
|
|
|
|
! [c4] c4
|
|
|
|
! [c5] c5
|
|
|
|
! [c6] c6
|
2020-11-18 23:44:40 +00:00
|
|
|
* [main] Merge commit 'c1'
|
2010-08-17 06:53:56 +00:00
|
|
|
--------
|
2020-11-18 23:44:40 +00:00
|
|
|
- [main] Merge commit 'c1'
|
2010-08-17 06:53:56 +00:00
|
|
|
+ * [c1] commit 1
|
|
|
|
+ [c6] c6
|
|
|
|
+ [c5] c5
|
|
|
|
++ [c4] c4
|
|
|
|
++++ [c3] commit 3
|
|
|
|
+ [c2] commit 2
|
|
|
|
+++++++* [c0] commit 0
|
|
|
|
'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2020-11-18 23:44:40 +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-09-23 22:51:40 +00:00
|
|
|
. ./test-lib.sh
|
merge: do not create a signed tag merge under --ff-only option
Starting at release v1.7.9, if you ask to merge a signed tag, "git merge"
always creates a merge commit, even when the tag points at a commit that
happens to be a descendant of your current commit.
Unfortunately, this interacts rather badly for people who use --ff-only to
make sure that their branch is free of local developments. It used to be
possible to say:
$ git checkout -b frotz v1.7.9~30
$ git merge --ff-only v1.7.9
and expect that the resulting tip of frotz branch matches v1.7.9^0 (aka
the commit tagged as v1.7.9), but this fails with the updated Git with:
fatal: Not possible to fast-forward, aborting.
because a merge that merges v1.7.9 tag to v1.7.9~30 cannot be created by
fast forwarding.
We could teach users that now they have to do
$ git merge --ff-only v1.7.9^0
but it is far more pleasant for users if we DWIMmed this ourselves.
When an integrator pulls in a topic from a lieutenant via a signed tag,
even when the work done by the lieutenant happens to fast-forward, the
integrator wants to have a merge record, so the integrator will not be
asking for --ff-only when running "git pull" in such a case. Therefore,
this change should not regress the support for the use case v1.7.9 wanted
to add.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-06 00:22:12 +00:00
|
|
|
. "$TEST_DIRECTORY"/lib-gpg.sh
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2020-03-21 09:21:21 +00:00
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 9 >file
|
2020-04-07 14:28:07 +00:00
|
|
|
cp file file.orig
|
2020-03-21 09:21:21 +00:00
|
|
|
test_write_lines '1 X' 2 3 4 5 6 7 8 9 >file.1
|
2020-04-07 14:28:07 +00:00
|
|
|
test_write_lines 1 2 '3 X' 4 5 6 7 8 9 >file.3
|
2020-03-21 09:21:21 +00:00
|
|
|
test_write_lines 1 2 3 4 '5 X' 6 7 8 9 >file.5
|
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 '9 X' >file.9
|
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 '9 Y' >file.9y
|
|
|
|
test_write_lines '1 X' 2 3 4 5 6 7 8 9 >result.1
|
|
|
|
test_write_lines '1 X' 2 3 4 '5 X' 6 7 8 9 >result.1-5
|
2020-04-07 14:28:07 +00:00
|
|
|
test_write_lines '1 X' 2 3 4 5 6 7 8 '9 X' >result.1-9
|
2020-03-21 09:21:21 +00:00
|
|
|
test_write_lines '1 X' 2 3 4 '5 X' 6 7 8 '9 X' >result.1-5-9
|
2020-04-07 14:28:07 +00:00
|
|
|
test_write_lines '1 X' 2 '3 X' 4 '5 X' 6 7 8 '9 X' >result.1-3-5-9
|
2020-03-21 09:21:21 +00:00
|
|
|
test_write_lines 1 2 3 4 5 6 7 8 '9 Z' >result.9z
|
2010-08-17 06:53:56 +00:00
|
|
|
|
2011-05-06 20:58:52 +00:00
|
|
|
create_merge_msgs () {
|
2020-07-30 17:06:42 +00:00
|
|
|
echo "Merge tag 'c2'" >msg.1-5 &&
|
|
|
|
echo "Merge tags 'c2' and 'c3'" >msg.1-5-9 &&
|
2011-05-06 20:58:52 +00:00
|
|
|
{
|
|
|
|
echo "Squashed commit of the following:" &&
|
|
|
|
echo &&
|
|
|
|
git log --no-merges ^HEAD c1
|
|
|
|
} >squash.1 &&
|
|
|
|
{
|
|
|
|
echo "Squashed commit of the following:" &&
|
|
|
|
echo &&
|
|
|
|
git log --no-merges ^HEAD c2
|
|
|
|
} >squash.1-5 &&
|
|
|
|
{
|
|
|
|
echo "Squashed commit of the following:" &&
|
|
|
|
echo &&
|
|
|
|
git log --no-merges ^HEAD c2 c3
|
|
|
|
} >squash.1-5-9 &&
|
|
|
|
{
|
2011-11-05 04:31:28 +00:00
|
|
|
echo "* tag 'c3':" &&
|
2014-05-14 22:12:45 +00:00
|
|
|
echo " commit 3"
|
2011-05-06 20:58:52 +00:00
|
|
|
} >msg.log
|
|
|
|
}
|
2010-08-17 06:53:56 +00:00
|
|
|
|
2011-05-06 20:58:52 +00:00
|
|
|
verify_merge () {
|
|
|
|
test_cmp "$2" "$1" &&
|
|
|
|
git update-index --refresh &&
|
|
|
|
git diff --exit-code &&
|
|
|
|
if test -n "$3"
|
|
|
|
then
|
2014-05-14 22:12:45 +00:00
|
|
|
git show -s --pretty=tformat:%s HEAD >msg.act &&
|
2011-05-06 20:58:52 +00:00
|
|
|
test_cmp "$3" msg.act
|
|
|
|
fi
|
|
|
|
}
|
2010-08-17 06:53:56 +00:00
|
|
|
|
2011-05-06 20:58:52 +00:00
|
|
|
verify_head () {
|
|
|
|
echo "$1" >head.expected &&
|
|
|
|
git rev-parse HEAD >head.actual &&
|
|
|
|
test_cmp head.expected head.actual
|
|
|
|
}
|
2010-08-17 06:53:56 +00:00
|
|
|
|
2011-05-06 20:58:52 +00:00
|
|
|
verify_parents () {
|
2020-03-21 09:21:21 +00:00
|
|
|
test_write_lines "$@" >parents.expected &&
|
2011-05-06 20:58:52 +00:00
|
|
|
>parents.actual &&
|
|
|
|
i=1 &&
|
|
|
|
while test $i -le $#
|
|
|
|
do
|
|
|
|
git rev-parse HEAD^$i >>parents.actual &&
|
|
|
|
i=$(expr $i + 1) ||
|
|
|
|
return 1
|
|
|
|
done &&
|
2011-05-06 21:00:21 +00:00
|
|
|
test_must_fail git rev-parse --verify "HEAD^$i" &&
|
2011-05-06 20:58:52 +00:00
|
|
|
test_cmp parents.expected parents.actual
|
|
|
|
}
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2011-05-06 20:58:52 +00:00
|
|
|
verify_mergeheads () {
|
2020-03-21 09:21:21 +00:00
|
|
|
test_write_lines "$@" >mergehead.expected &&
|
2011-11-07 22:45:10 +00:00
|
|
|
while read sha1 rest
|
|
|
|
do
|
|
|
|
git rev-parse $sha1
|
|
|
|
done <.git/MERGE_HEAD >mergehead.actual &&
|
|
|
|
test_cmp mergehead.expected mergehead.actual
|
2011-05-06 20:58:52 +00:00
|
|
|
}
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2011-05-06 20:58:52 +00:00
|
|
|
verify_no_mergehead () {
|
|
|
|
! test -e .git/MERGE_HEAD
|
|
|
|
}
|
2007-09-23 22:51:40 +00:00
|
|
|
|
|
|
|
test_expect_success 'setup' '
|
|
|
|
git add file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "commit 0" &&
|
|
|
|
git tag c0 &&
|
|
|
|
c0=$(git rev-parse HEAD) &&
|
|
|
|
cp file.1 file &&
|
|
|
|
git add file &&
|
2021-07-23 12:14:29 +00:00
|
|
|
cp file.1 other &&
|
|
|
|
git add other &&
|
2007-09-23 22:51:40 +00:00
|
|
|
test_tick &&
|
|
|
|
git commit -m "commit 1" &&
|
|
|
|
git tag c1 &&
|
|
|
|
c1=$(git rev-parse HEAD) &&
|
|
|
|
git reset --hard "$c0" &&
|
|
|
|
cp file.5 file &&
|
|
|
|
git add file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "commit 2" &&
|
|
|
|
git tag c2 &&
|
|
|
|
c2=$(git rev-parse HEAD) &&
|
|
|
|
git reset --hard "$c0" &&
|
2016-03-21 22:29:40 +00:00
|
|
|
cp file.9y file &&
|
|
|
|
git add file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "commit 7" &&
|
|
|
|
git tag c7 &&
|
|
|
|
git reset --hard "$c0" &&
|
2007-09-23 22:51:40 +00:00
|
|
|
cp file.9 file &&
|
|
|
|
git add file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "commit 3" &&
|
|
|
|
git tag c3 &&
|
2015-03-20 10:07:15 +00:00
|
|
|
c3=$(git rev-parse HEAD) &&
|
2007-09-23 22:51:40 +00:00
|
|
|
git reset --hard "$c0" &&
|
|
|
|
create_merge_msgs
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2008-07-20 12:34:47 +00:00
|
|
|
test_expect_success 'test option parsing' '
|
2008-07-16 08:33:52 +00:00
|
|
|
test_must_fail git merge -$ c1 &&
|
|
|
|
test_must_fail git merge --no-such c1 &&
|
|
|
|
test_must_fail git merge -s foobar c1 &&
|
|
|
|
test_must_fail git merge -s=foobar c1 &&
|
|
|
|
test_must_fail git merge -m &&
|
2016-12-14 08:37:57 +00:00
|
|
|
test_must_fail git merge --abort foobar &&
|
|
|
|
test_must_fail git merge --abort --quiet &&
|
2016-12-14 08:37:55 +00:00
|
|
|
test_must_fail git merge --continue foobar &&
|
|
|
|
test_must_fail git merge --continue --quiet &&
|
2008-07-16 08:33:52 +00:00
|
|
|
test_must_fail git merge
|
2007-09-23 22:51:40 +00:00
|
|
|
'
|
|
|
|
|
2010-10-22 06:49:45 +00:00
|
|
|
test_expect_success 'merge -h with invalid index' '
|
|
|
|
mkdir broken &&
|
|
|
|
(
|
|
|
|
cd broken &&
|
|
|
|
git init &&
|
|
|
|
>.git/index &&
|
|
|
|
test_expect_code 129 git merge -h 2>usage
|
|
|
|
) &&
|
2012-08-27 05:36:55 +00:00
|
|
|
test_i18ngrep "[Uu]sage: git merge" broken/usage
|
2010-10-22 06:49:45 +00:00
|
|
|
'
|
|
|
|
|
2008-07-29 23:17:01 +00:00
|
|
|
test_expect_success 'reject non-strategy with a git-merge-foo name' '
|
|
|
|
test_must_fail git merge -s index c1
|
|
|
|
'
|
|
|
|
|
2007-09-23 22:51:40 +00:00
|
|
|
test_expect_success 'merge c0 with c1' '
|
2010-08-17 06:56:13 +00:00
|
|
|
echo "OBJID HEAD@{0}: merge c1: Fast-forward" >reflog.expected &&
|
|
|
|
|
2007-09-23 22:51:40 +00:00
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge c1 &&
|
|
|
|
verify_merge file result.1 &&
|
2010-08-17 06:56:13 +00:00
|
|
|
verify_head "$c1" &&
|
|
|
|
|
|
|
|
git reflog -1 >reflog.actual &&
|
|
|
|
sed "s/$_x05[0-9a-f]*/OBJID/g" reflog.actual >reflog.fuzzy &&
|
|
|
|
test_cmp reflog.expected reflog.fuzzy
|
2007-09-23 22:51:40 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2009-10-29 22:08:31 +00:00
|
|
|
test_expect_success 'merge c0 with c1 with --ff-only' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge --ff-only c1 &&
|
|
|
|
git merge --ff-only HEAD c0 c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_head "$c1"
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2010-08-17 06:56:46 +00:00
|
|
|
|
|
|
|
test_expect_success 'merge from unborn branch' '
|
2020-11-18 23:44:40 +00:00
|
|
|
git checkout -f main &&
|
2010-08-17 06:56:46 +00:00
|
|
|
test_might_fail git branch -D kid &&
|
|
|
|
|
|
|
|
echo "OBJID HEAD@{0}: initial pull" >reflog.expected &&
|
|
|
|
|
|
|
|
git checkout --orphan kid &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_when_finished "git checkout -f main" &&
|
2010-08-17 06:56:46 +00:00
|
|
|
git rm -fr . &&
|
|
|
|
test_tick &&
|
|
|
|
git merge --ff-only c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_head "$c1" &&
|
|
|
|
|
|
|
|
git reflog -1 >reflog.actual &&
|
|
|
|
sed "s/$_x05[0-9a-f][0-9a-f]/OBJID/g" reflog.actual >reflog.fuzzy &&
|
|
|
|
test_cmp reflog.expected reflog.fuzzy
|
|
|
|
'
|
|
|
|
|
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2009-10-29 22:08:31 +00:00
|
|
|
|
2007-09-23 22:51:40 +00:00
|
|
|
test_expect_success 'merge c1 with c2' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
test_tick &&
|
|
|
|
git merge c2 &&
|
|
|
|
verify_merge file result.1-5 msg.1-5 &&
|
|
|
|
verify_parents $c1 $c2
|
|
|
|
'
|
|
|
|
|
2016-03-21 22:29:40 +00:00
|
|
|
test_expect_success 'merge --squash c3 with c7' '
|
|
|
|
git reset --hard c3 &&
|
|
|
|
test_must_fail git merge --squash c7 &&
|
|
|
|
cat result.9z >file &&
|
|
|
|
git commit --no-edit -a &&
|
|
|
|
|
2019-04-17 10:23:21 +00:00
|
|
|
cat >expect <<-EOF &&
|
|
|
|
Squashed commit of the following:
|
2016-03-21 22:29:40 +00:00
|
|
|
|
2019-04-17 10:23:21 +00:00
|
|
|
$(git show -s c7)
|
2016-03-21 22:29:40 +00:00
|
|
|
|
2019-04-17 10:23:21 +00:00
|
|
|
# Conflicts:
|
|
|
|
# file
|
|
|
|
EOF
|
|
|
|
git cat-file commit HEAD >raw &&
|
t: don't spuriously close and reopen quotes
In the test scripts, the recommended style is, e.g.:
test_expect_success 'name' '
do-something somehow &&
do-some-more testing
'
When using this style, any single quote in the multi-line test section
is actually closing the lone single quotes that surround it.
It can be a non-issue in practice:
test_expect_success 'sed a little' '
sed -e 's/hi/lo/' in >out # "ok": no whitespace in s/hi/lo/
'
Or it can be a bug in the test, e.g., because variable interpolation
happens before the test even begins executing:
v=abc
test_expect_success 'variable interpolation' '
v=def &&
echo '"$v"' # abc
'
Change several such in-test single quotes to use double quotes instead
or, in a few cases, drop them altogether. These were identified using
some crude grepping. We're not fixing any test bugs here, but we're
hopefully making these tests slightly easier to grok and to maintain.
There are legitimate use cases for closing a quote and opening a new
one, e.g., both '\'' and '"'"' can be used to produce a literal single
quote. I'm not touching any of those here.
In t9401, tuck the redirecting ">" to the filename while we're touching
those lines.
Signed-off-by: Martin Ågren <martin.agren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-08-06 20:08:53 +00:00
|
|
|
sed -e "1,/^$/d" raw >actual &&
|
2016-03-21 22:29:40 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2019-04-17 10:23:28 +00:00
|
|
|
test_expect_success 'merge c3 with c7 with commit.cleanup = scissors' '
|
|
|
|
git config commit.cleanup scissors &&
|
|
|
|
git reset --hard c3 &&
|
|
|
|
test_must_fail git merge c7 &&
|
|
|
|
cat result.9z >file &&
|
|
|
|
git commit --no-edit -a &&
|
|
|
|
|
|
|
|
cat >expect <<-\EOF &&
|
2020-07-30 17:06:42 +00:00
|
|
|
Merge tag '"'"'c7'"'"'
|
2019-04-17 10:23:28 +00:00
|
|
|
|
|
|
|
# ------------------------ >8 ------------------------
|
|
|
|
# Do not modify or remove the line above.
|
|
|
|
# Everything below it will be ignored.
|
|
|
|
#
|
|
|
|
# Conflicts:
|
|
|
|
# file
|
|
|
|
EOF
|
|
|
|
git cat-file commit HEAD >raw &&
|
t: don't spuriously close and reopen quotes
In the test scripts, the recommended style is, e.g.:
test_expect_success 'name' '
do-something somehow &&
do-some-more testing
'
When using this style, any single quote in the multi-line test section
is actually closing the lone single quotes that surround it.
It can be a non-issue in practice:
test_expect_success 'sed a little' '
sed -e 's/hi/lo/' in >out # "ok": no whitespace in s/hi/lo/
'
Or it can be a bug in the test, e.g., because variable interpolation
happens before the test even begins executing:
v=abc
test_expect_success 'variable interpolation' '
v=def &&
echo '"$v"' # abc
'
Change several such in-test single quotes to use double quotes instead
or, in a few cases, drop them altogether. These were identified using
some crude grepping. We're not fixing any test bugs here, but we're
hopefully making these tests slightly easier to grok and to maintain.
There are legitimate use cases for closing a quote and opening a new
one, e.g., both '\'' and '"'"' can be used to produce a literal single
quote. I'm not touching any of those here.
In t9401, tuck the redirecting ">" to the filename while we're touching
those lines.
Signed-off-by: Martin Ågren <martin.agren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-08-06 20:08:53 +00:00
|
|
|
sed -e "1,/^$/d" raw >actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2019-04-17 10:23:28 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merge c3 with c7 with --squash commit.cleanup = scissors' '
|
|
|
|
git config commit.cleanup scissors &&
|
|
|
|
git reset --hard c3 &&
|
|
|
|
test_must_fail git merge --squash c7 &&
|
|
|
|
cat result.9z >file &&
|
|
|
|
git commit --no-edit -a &&
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
Squashed commit of the following:
|
|
|
|
|
|
|
|
$(git show -s c7)
|
|
|
|
|
|
|
|
# ------------------------ >8 ------------------------
|
|
|
|
# Do not modify or remove the line above.
|
|
|
|
# Everything below it will be ignored.
|
|
|
|
#
|
|
|
|
# Conflicts:
|
|
|
|
# file
|
|
|
|
EOF
|
|
|
|
git cat-file commit HEAD >raw &&
|
t: don't spuriously close and reopen quotes
In the test scripts, the recommended style is, e.g.:
test_expect_success 'name' '
do-something somehow &&
do-some-more testing
'
When using this style, any single quote in the multi-line test section
is actually closing the lone single quotes that surround it.
It can be a non-issue in practice:
test_expect_success 'sed a little' '
sed -e 's/hi/lo/' in >out # "ok": no whitespace in s/hi/lo/
'
Or it can be a bug in the test, e.g., because variable interpolation
happens before the test even begins executing:
v=abc
test_expect_success 'variable interpolation' '
v=def &&
echo '"$v"' # abc
'
Change several such in-test single quotes to use double quotes instead
or, in a few cases, drop them altogether. These were identified using
some crude grepping. We're not fixing any test bugs here, but we're
hopefully making these tests slightly easier to grok and to maintain.
There are legitimate use cases for closing a quote and opening a new
one, e.g., both '\'' and '"'"' can be used to produce a literal single
quote. I'm not touching any of those here.
In t9401, tuck the redirecting ">" to the filename while we're touching
those lines.
Signed-off-by: Martin Ågren <martin.agren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-08-06 20:08:53 +00:00
|
|
|
sed -e "1,/^$/d" raw >actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2019-04-17 10:23:28 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
|
|
|
test_expect_success 'merge c1 with c2 and c3' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
test_tick &&
|
|
|
|
git merge c2 c3 &&
|
|
|
|
verify_merge file result.1-5-9 msg.1-5-9 &&
|
|
|
|
verify_parents $c1 $c2 $c3
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2011-05-06 19:27:05 +00:00
|
|
|
test_expect_success 'merges with --ff-only' '
|
2009-10-29 22:08:31 +00:00
|
|
|
git reset --hard c1 &&
|
|
|
|
test_tick &&
|
|
|
|
test_must_fail git merge --ff-only c2 &&
|
|
|
|
test_must_fail git merge --ff-only c3 &&
|
2011-05-06 19:27:05 +00:00
|
|
|
test_must_fail git merge --ff-only c2 c3 &&
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge c3 &&
|
|
|
|
verify_head $c3
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merges with merge.ff=only' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
test_tick &&
|
2013-03-24 21:06:12 +00:00
|
|
|
test_config merge.ff "only" &&
|
2011-05-06 19:27:05 +00:00
|
|
|
test_must_fail git merge c2 &&
|
|
|
|
test_must_fail git merge c3 &&
|
|
|
|
test_must_fail git merge c2 c3 &&
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge c3 &&
|
|
|
|
verify_head $c3
|
2009-10-29 22:08:31 +00:00
|
|
|
'
|
|
|
|
|
2007-09-23 22:51:40 +00:00
|
|
|
test_expect_success 'merge c0 with c1 (no-commit)' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge --no-commit c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_head $c1
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
|
|
|
test_expect_success 'merge c1 with c2 (no-commit)' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge --no-commit c2 &&
|
|
|
|
verify_merge file result.1-5 &&
|
|
|
|
verify_head $c1 &&
|
|
|
|
verify_mergeheads $c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
|
|
|
test_expect_success 'merge c1 with c2 and c3 (no-commit)' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge --no-commit c2 c3 &&
|
|
|
|
verify_merge file result.1-5-9 &&
|
|
|
|
verify_head $c1 &&
|
|
|
|
verify_mergeheads $c2 $c3
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
|
|
|
test_expect_success 'merge c0 with c1 (squash)' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge --squash c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_head $c0 &&
|
|
|
|
verify_no_mergehead &&
|
2010-08-17 06:53:56 +00:00
|
|
|
test_cmp squash.1 .git/SQUASH_MSG
|
2007-09-23 22:51:40 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2009-10-29 22:08:31 +00:00
|
|
|
test_expect_success 'merge c0 with c1 (squash, ff-only)' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge --squash --ff-only c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_head $c0 &&
|
|
|
|
verify_no_mergehead &&
|
2010-08-17 06:53:56 +00:00
|
|
|
test_cmp squash.1 .git/SQUASH_MSG
|
2009-10-29 22:08:31 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2009-10-29 22:08:31 +00:00
|
|
|
|
2007-09-23 22:51:40 +00:00
|
|
|
test_expect_success 'merge c1 with c2 (squash)' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge --squash c2 &&
|
|
|
|
verify_merge file result.1-5 &&
|
|
|
|
verify_head $c1 &&
|
|
|
|
verify_no_mergehead &&
|
2010-08-17 06:53:56 +00:00
|
|
|
test_cmp squash.1-5 .git/SQUASH_MSG
|
2007-09-23 22:51:40 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2013-06-19 05:37:24 +00:00
|
|
|
test_expect_success 'unsuccessful merge of c1 with c2 (squash, ff-only)' '
|
2009-10-29 22:08:31 +00:00
|
|
|
git reset --hard c1 &&
|
|
|
|
test_must_fail git merge --squash --ff-only c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2009-10-29 22:08:31 +00:00
|
|
|
|
2007-09-23 22:51:40 +00:00
|
|
|
test_expect_success 'merge c1 with c2 and c3 (squash)' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge --squash c2 c3 &&
|
|
|
|
verify_merge file result.1-5-9 &&
|
|
|
|
verify_head $c1 &&
|
|
|
|
verify_no_mergehead &&
|
2010-08-17 06:53:56 +00:00
|
|
|
test_cmp squash.1-5-9 .git/SQUASH_MSG
|
2007-09-23 22:51:40 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:40 +00:00
|
|
|
|
2007-09-23 22:51:43 +00:00
|
|
|
test_expect_success 'merge c1 with c2 (no-commit in config)' '
|
|
|
|
git reset --hard c1 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--no-commit" &&
|
2007-09-23 22:51:43 +00:00
|
|
|
git merge c2 &&
|
|
|
|
verify_merge file result.1-5 &&
|
|
|
|
verify_head $c1 &&
|
|
|
|
verify_mergeheads $c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:43 +00:00
|
|
|
|
2011-05-05 00:42:51 +00:00
|
|
|
test_expect_success 'merge c1 with c2 (log in config)' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge --log c2 &&
|
|
|
|
git show -s --pretty=tformat:%s%n%b >expect &&
|
|
|
|
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--log" &&
|
2011-05-05 00:42:51 +00:00
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge c2 &&
|
|
|
|
git show -s --pretty=tformat:%s%n%b >actual &&
|
|
|
|
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merge c1 with c2 (log in config gets overridden)' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge c2 &&
|
|
|
|
git show -s --pretty=tformat:%s%n%b >expect &&
|
|
|
|
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--no-log" &&
|
2013-03-24 21:06:12 +00:00
|
|
|
test_config merge.log "true" &&
|
2011-05-05 00:42:51 +00:00
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge c2 &&
|
|
|
|
git show -s --pretty=tformat:%s%n%b >actual &&
|
|
|
|
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2007-09-23 22:51:43 +00:00
|
|
|
test_expect_success 'merge c1 with c2 (squash in config)' '
|
|
|
|
git reset --hard c1 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--squash" &&
|
2007-09-23 22:51:43 +00:00
|
|
|
git merge c2 &&
|
|
|
|
verify_merge file result.1-5 &&
|
|
|
|
verify_head $c1 &&
|
|
|
|
verify_no_mergehead &&
|
2010-08-17 06:53:56 +00:00
|
|
|
test_cmp squash.1-5 .git/SQUASH_MSG
|
2007-09-23 22:51:43 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:43 +00:00
|
|
|
|
2008-04-06 01:23:43 +00:00
|
|
|
test_expect_success 'override config option -n with --summary' '
|
2007-09-23 22:51:43 +00:00
|
|
|
git reset --hard c1 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "-n" &&
|
2007-09-23 22:51:43 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge --summary c2 >diffstat.txt &&
|
|
|
|
verify_merge file result.1-5 msg.1-5 &&
|
|
|
|
verify_parents $c1 $c2 &&
|
2008-03-12 21:32:17 +00:00
|
|
|
if ! grep "^ file | *2 +-$" diffstat.txt
|
2007-09-23 22:51:43 +00:00
|
|
|
then
|
2008-04-06 01:23:43 +00:00
|
|
|
echo "[OOPS] diffstat was not generated with --summary"
|
|
|
|
false
|
|
|
|
fi
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'override config option -n with --stat' '
|
|
|
|
git reset --hard c1 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "-n" &&
|
2008-04-06 01:23:43 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge --stat c2 >diffstat.txt &&
|
|
|
|
verify_merge file result.1-5 msg.1-5 &&
|
|
|
|
verify_parents $c1 $c2 &&
|
|
|
|
if ! grep "^ file | *2 +-$" diffstat.txt
|
|
|
|
then
|
|
|
|
echo "[OOPS] diffstat was not generated with --stat"
|
|
|
|
false
|
2007-09-23 22:51:43 +00:00
|
|
|
fi
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:43 +00:00
|
|
|
|
2008-04-06 01:23:43 +00:00
|
|
|
test_expect_success 'override config option --stat' '
|
2007-09-23 22:51:43 +00:00
|
|
|
git reset --hard c1 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--stat" &&
|
2007-09-23 22:51:43 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge -n c2 >diffstat.txt &&
|
|
|
|
verify_merge file result.1-5 msg.1-5 &&
|
|
|
|
verify_parents $c1 $c2 &&
|
2008-03-12 21:32:17 +00:00
|
|
|
if grep "^ file | *2 +-$" diffstat.txt
|
2007-09-23 22:51:43 +00:00
|
|
|
then
|
|
|
|
echo "[OOPS] diffstat was generated"
|
|
|
|
false
|
|
|
|
fi
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:43 +00:00
|
|
|
|
2007-09-23 22:51:44 +00:00
|
|
|
test_expect_success 'merge c1 with c2 (override --no-commit)' '
|
|
|
|
git reset --hard c1 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--no-commit" &&
|
2007-09-23 22:51:44 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge --commit c2 &&
|
|
|
|
verify_merge file result.1-5 msg.1-5 &&
|
|
|
|
verify_parents $c1 $c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:44 +00:00
|
|
|
|
|
|
|
test_expect_success 'merge c1 with c2 (override --squash)' '
|
|
|
|
git reset --hard c1 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--squash" &&
|
2007-09-23 22:51:44 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge --no-squash c2 &&
|
|
|
|
verify_merge file result.1-5 msg.1-5 &&
|
|
|
|
verify_parents $c1 $c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:44 +00:00
|
|
|
|
2007-09-23 22:51:45 +00:00
|
|
|
test_expect_success 'merge c0 with c1 (no-ff)' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
test_tick &&
|
|
|
|
git merge --no-ff c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_parents $c0 $c1
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:45 +00:00
|
|
|
|
2011-05-06 19:27:05 +00:00
|
|
|
test_expect_success 'merge c0 with c1 (merge.ff=false)' '
|
|
|
|
git reset --hard c0 &&
|
2013-03-24 21:06:12 +00:00
|
|
|
test_config merge.ff "false" &&
|
2011-05-06 19:27:05 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_parents $c0 $c1
|
|
|
|
'
|
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
|
|
|
|
2020-11-18 23:44:40 +00:00
|
|
|
test_expect_success 'combine branch.main.mergeoptions with merge.ff' '
|
2011-05-06 19:27:05 +00:00
|
|
|
git reset --hard c0 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--ff" &&
|
2013-03-24 21:06:12 +00:00
|
|
|
test_config merge.ff "false" &&
|
2011-05-06 19:27:05 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_parents "$c0"
|
|
|
|
'
|
|
|
|
|
2011-05-06 21:59:47 +00:00
|
|
|
test_expect_success 'tolerate unknown values for merge.ff' '
|
|
|
|
git reset --hard c0 &&
|
2013-03-24 21:06:12 +00:00
|
|
|
test_config merge.ff "something-new" &&
|
2011-05-06 21:59:47 +00:00
|
|
|
test_tick &&
|
|
|
|
git merge c1 2>message &&
|
|
|
|
verify_head "$c1" &&
|
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-19 21:57:25 +00:00
|
|
|
test_must_be_empty message
|
2011-05-06 21:59:47 +00:00
|
|
|
'
|
|
|
|
|
git-merge.sh: better handling of combined --squash,--no-ff,--no-commit options
git-merge used to use either the --squash,--no-squash, --no-ff,--ff,
--no-commit,--commit option, whichever came last in the command line.
This lead to some un-intuitive behavior, having
git merge --no-commit --no-ff <branch>
actually commit the merge. Now git-merge respects --no-commit together
with --no-ff, as well as other combinations of the options. However,
this broke a selftest in t/t7600-merge.sh which expected to have --no-ff
completely override the --squash option, so that
git merge --squash --no-ff <branch>
fast-forwards, and makes a merge commit; combining --squash with --no-ff
doesn't really make sense though, and is now refused by git-merge. The
test is adapted to test --no-ff without the preceding --squash, and
another test is added to make sure the --squash --no-ff combination is
refused.
The unexpected behavior was reported by John Goerzen through
http://bing.sdebian.org/468568
Signed-off-by: Gerrit Pape <pape@smarden.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-03 09:22:03 +00:00
|
|
|
test_expect_success 'combining --squash and --no-ff is refused' '
|
2011-05-06 21:59:47 +00:00
|
|
|
git reset --hard c0 &&
|
git-merge.sh: better handling of combined --squash,--no-ff,--no-commit options
git-merge used to use either the --squash,--no-squash, --no-ff,--ff,
--no-commit,--commit option, whichever came last in the command line.
This lead to some un-intuitive behavior, having
git merge --no-commit --no-ff <branch>
actually commit the merge. Now git-merge respects --no-commit together
with --no-ff, as well as other combinations of the options. However,
this broke a selftest in t/t7600-merge.sh which expected to have --no-ff
completely override the --squash option, so that
git merge --squash --no-ff <branch>
fast-forwards, and makes a merge commit; combining --squash with --no-ff
doesn't really make sense though, and is now refused by git-merge. The
test is adapted to test --no-ff without the preceding --squash, and
another test is added to make sure the --squash --no-ff combination is
refused.
The unexpected behavior was reported by John Goerzen through
http://bing.sdebian.org/468568
Signed-off-by: Gerrit Pape <pape@smarden.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-03 09:22:03 +00:00
|
|
|
test_must_fail git merge --squash --no-ff c1 &&
|
|
|
|
test_must_fail git merge --no-ff --squash c1
|
|
|
|
'
|
|
|
|
|
2019-05-24 18:36:17 +00:00
|
|
|
test_expect_success 'combining --squash and --commit is refused' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
test_must_fail git merge --squash --commit c1 &&
|
|
|
|
test_must_fail git merge --commit --squash c1
|
|
|
|
'
|
|
|
|
|
2013-07-02 14:47:57 +00:00
|
|
|
test_expect_success 'option --ff-only overwrites --no-ff' '
|
|
|
|
git merge --no-ff --ff-only c1 &&
|
|
|
|
test_must_fail git merge --no-ff --ff-only c2
|
|
|
|
'
|
|
|
|
|
2013-07-23 17:08:40 +00:00
|
|
|
test_expect_success 'option --no-ff overrides merge.ff=only config' '
|
2013-07-02 14:47:57 +00:00
|
|
|
git reset --hard c0 &&
|
|
|
|
test_config merge.ff only &&
|
|
|
|
git merge --no-ff c1
|
2009-10-29 22:08:31 +00:00
|
|
|
'
|
|
|
|
|
2007-09-23 22:51:45 +00:00
|
|
|
test_expect_success 'merge c0 with c1 (ff overrides no-ff)' '
|
|
|
|
git reset --hard c0 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--no-ff" &&
|
2007-09-23 22:51:45 +00:00
|
|
|
git merge --ff c1 &&
|
|
|
|
verify_merge file result.1 &&
|
|
|
|
verify_head $c1
|
|
|
|
'
|
|
|
|
|
2008-04-06 01:23:46 +00:00
|
|
|
test_expect_success 'merge log message' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge --no-log c2 &&
|
|
|
|
git show -s --pretty=format:%b HEAD >msg.act &&
|
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-19 21:57:25 +00:00
|
|
|
test_must_be_empty msg.act &&
|
2013-03-24 21:06:12 +00:00
|
|
|
|
|
|
|
git reset --hard c0 &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_config branch.main.mergeoptions "--no-ff" &&
|
2013-03-24 21:06:12 +00:00
|
|
|
git merge --no-log c2 &&
|
|
|
|
git show -s --pretty=format:%b HEAD >msg.act &&
|
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-19 21:57:25 +00:00
|
|
|
test_must_be_empty msg.act &&
|
2008-07-10 07:50:59 +00:00
|
|
|
|
2008-04-06 01:23:46 +00:00
|
|
|
git merge --log c3 &&
|
|
|
|
git show -s --pretty=format:%b HEAD >msg.act &&
|
2010-08-17 06:53:56 +00:00
|
|
|
test_cmp msg.log msg.act &&
|
2008-07-10 07:50:59 +00:00
|
|
|
|
|
|
|
git reset --hard HEAD^ &&
|
2013-03-24 21:06:12 +00:00
|
|
|
test_config merge.log "yes" &&
|
2008-07-10 07:50:59 +00:00
|
|
|
git merge c3 &&
|
|
|
|
git show -s --pretty=format:%b HEAD >msg.act &&
|
2010-08-17 06:53:56 +00:00
|
|
|
test_cmp msg.log msg.act
|
2008-04-06 01:23:46 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2007-09-23 22:51:45 +00:00
|
|
|
|
2008-07-13 08:13:55 +00:00
|
|
|
test_expect_success 'merge c1 with c0, c2, c0, and c1' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
test_tick &&
|
|
|
|
git merge c0 c2 c0 c1 &&
|
|
|
|
verify_merge file result.1-5 &&
|
|
|
|
verify_parents $c1 $c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2008-07-13 08:13:55 +00:00
|
|
|
|
2008-07-14 07:09:41 +00:00
|
|
|
test_expect_success 'merge c1 with c0, c2, c0, and c1' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
test_tick &&
|
|
|
|
git merge c0 c2 c0 c1 &&
|
|
|
|
verify_merge file result.1-5 &&
|
|
|
|
verify_parents $c1 $c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2008-07-14 07:09:41 +00:00
|
|
|
|
|
|
|
test_expect_success 'merge c1 with c1 and c2' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
test_tick &&
|
|
|
|
git merge c1 c2 &&
|
|
|
|
verify_merge file result.1-5 &&
|
|
|
|
verify_parents $c1 $c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2008-07-14 07:09:41 +00:00
|
|
|
|
2008-08-20 22:09:28 +00:00
|
|
|
test_expect_success 'merge fast-forward in a dirty tree' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
mv file file1 &&
|
|
|
|
cat file1 >file &&
|
|
|
|
rm -f file1 &&
|
|
|
|
git merge c2
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2008-08-20 22:09:28 +00:00
|
|
|
|
2011-04-14 21:36:14 +00:00
|
|
|
test_expect_success 'in-index merge' '
|
merge: fix numerus bugs around "trivial merge" area
The "trivial merge" codepath wants to optimize itself by making an
internal call to the read-tree machinery, but it does not read the index
before doing so, and the codepath is never exercised. Incidentally, this
failure to read the index upfront means that the safety to refuse doing
anything when the index is unmerged does not kick in, either.
These two problem are fixed by using read_cache_unmerged() that does read
the index before checking if it is unmerged at the beginning of
cmd_merge().
The primary logic of the merge, however, assumes that the process never
reads the index in-core, and the call to write_cache_as_tree() it makes
from write_tree_trivial() will always read from the on-disk index that is
prepared the strategy back-ends. This assumption is now broken by the
above fix. To fix this issue, we now call discard_cache() before calling
write_tree_trivial() when it wants to write the on-disk index as a tree.
When multiple strategies are tried, their results are evaluated by reading
the resulting index and inspecting it. The codepath needs to make a call
to read_cache() for each successful strategy, and for that to work, they
need to discard_cache() the one read by the previous round.
Also the "trivial merge" forgot that the current commit is one of the
parents of the resulting commit.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-23 19:56:57 +00:00
|
|
|
git reset --hard c0 &&
|
2010-08-17 06:53:56 +00:00
|
|
|
git merge --no-ff -s resolve c1 >out &&
|
2011-04-14 21:36:14 +00:00
|
|
|
test_i18ngrep "Wonderful." out &&
|
merge: fix numerus bugs around "trivial merge" area
The "trivial merge" codepath wants to optimize itself by making an
internal call to the read-tree machinery, but it does not read the index
before doing so, and the codepath is never exercised. Incidentally, this
failure to read the index upfront means that the safety to refuse doing
anything when the index is unmerged does not kick in, either.
These two problem are fixed by using read_cache_unmerged() that does read
the index before checking if it is unmerged at the beginning of
cmd_merge().
The primary logic of the merge, however, assumes that the process never
reads the index in-core, and the call to write_cache_as_tree() it makes
from write_tree_trivial() will always read from the on-disk index that is
prepared the strategy back-ends. This assumption is now broken by the
above fix. To fix this issue, we now call discard_cache() before calling
write_tree_trivial() when it wants to write the on-disk index as a tree.
When multiple strategies are tried, their results are evaluated by reading
the resulting index and inspecting it. The codepath needs to make a call
to read_cache() for each successful strategy, and for that to work, they
need to discard_cache() the one read by the previous round.
Also the "trivial merge" forgot that the current commit is one of the
parents of the resulting commit.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-23 19:56:57 +00:00
|
|
|
verify_parents $c0 $c1
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
merge: fix numerus bugs around "trivial merge" area
The "trivial merge" codepath wants to optimize itself by making an
internal call to the read-tree machinery, but it does not read the index
before doing so, and the codepath is never exercised. Incidentally, this
failure to read the index upfront means that the safety to refuse doing
anything when the index is unmerged does not kick in, either.
These two problem are fixed by using read_cache_unmerged() that does read
the index before checking if it is unmerged at the beginning of
cmd_merge().
The primary logic of the merge, however, assumes that the process never
reads the index in-core, and the call to write_cache_as_tree() it makes
from write_tree_trivial() will always read from the on-disk index that is
prepared the strategy back-ends. This assumption is now broken by the
above fix. To fix this issue, we now call discard_cache() before calling
write_tree_trivial() when it wants to write the on-disk index as a tree.
When multiple strategies are tried, their results are evaluated by reading
the resulting index and inspecting it. The codepath needs to make a call
to read_cache() for each successful strategy, and for that to work, they
need to discard_cache() the one read by the previous round.
Also the "trivial merge" forgot that the current commit is one of the
parents of the resulting commit.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-23 19:56:57 +00:00
|
|
|
|
2008-10-03 13:02:31 +00:00
|
|
|
test_expect_success 'refresh the index before merging' '
|
|
|
|
git reset --hard c1 &&
|
2010-04-07 00:08:54 +00:00
|
|
|
cp file file.n && mv -f file.n file &&
|
2008-10-03 13:02:31 +00:00
|
|
|
git merge c3
|
|
|
|
'
|
|
|
|
|
2020-04-07 14:28:07 +00:00
|
|
|
test_expect_success 'merge with --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9 &&
|
|
|
|
git merge --autostash c2 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
git show HEAD:file >merge-result &&
|
|
|
|
test_cmp result.1-5 merge-result &&
|
|
|
|
test_cmp result.1-5-9 file
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merge with merge.autoStash' '
|
|
|
|
test_config merge.autoStash true &&
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9 &&
|
|
|
|
git merge c2 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
git show HEAD:file >merge-result &&
|
|
|
|
test_cmp result.1-5 merge-result &&
|
|
|
|
test_cmp result.1-5-9 file
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fast-forward merge with --autostash' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge-file file file.orig file.5 &&
|
|
|
|
git merge --autostash c1 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
test_cmp result.1-5 file
|
|
|
|
'
|
|
|
|
|
2021-07-23 12:14:29 +00:00
|
|
|
test_expect_success 'failed fast-forward merge with --autostash' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge-file file file.orig file.5 &&
|
|
|
|
cp file.5 other &&
|
2021-09-11 17:08:42 +00:00
|
|
|
test_when_finished "rm other" &&
|
2021-07-23 12:14:29 +00:00
|
|
|
test_must_fail git merge --autostash c1 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
test_cmp file.5 file
|
|
|
|
'
|
|
|
|
|
2020-04-07 14:28:07 +00:00
|
|
|
test_expect_success 'octopus merge with --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.3 &&
|
|
|
|
git merge --autostash c2 c3 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
git show HEAD:file >merge-result &&
|
|
|
|
test_cmp result.1-5-9 merge-result &&
|
|
|
|
test_cmp result.1-3-5-9 file
|
|
|
|
'
|
|
|
|
|
merge: apply autostash if merge strategy fails
Since 'git merge' learned '--autostash' in a03b55530a (merge: teach
--autostash option, 2020-04-07), 'cmd_merge', once it is determined that
we have to create a merge commit, calls 'create_autostash' if
'--autostash' is given.
As explained in a03b55530a, and made more abvious by the tests added in
that commit, the autostash is then applied if the merge succeeds, either
directly or by committing (after conflict resolution or if '--no-commit'
was given), or if the merge is aborted with 'git merge --abort'. In some
other cases, like the user calling 'git reset --merge' or 'git merge
--quit', the autostash is not applied, but saved in the stash list.
However, there exists a scenario that creates an autostash but does not
apply nor save it to the stash list: if the chosen merge strategy
completely fails to handle the merge, i.e. 'try_merge_strategy' returns
2.
Apply the autostash in that case also. An easy way to test that is to
try to merge more than two commits but explicitely ask for the 'recursive'
merge strategy.
Signed-off-by: Philippe Blain <levraiphilippeblain@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-07-23 12:14:30 +00:00
|
|
|
test_expect_success 'failed merge (exit 2) with --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.5 &&
|
|
|
|
test_must_fail git merge -s recursive --autostash c2 c3 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
test_cmp result.1-5 file
|
|
|
|
'
|
|
|
|
|
2020-04-07 14:28:07 +00:00
|
|
|
test_expect_success 'conflicted merge with --autostash, --abort restores stash' '
|
|
|
|
git reset --hard c3 &&
|
|
|
|
cp file.1 file &&
|
|
|
|
test_must_fail git merge --autostash c7 &&
|
|
|
|
git merge --abort 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
test_cmp file.1 file
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'completed merge (git commit) with --no-commit and --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9 &&
|
|
|
|
git diff >expect &&
|
|
|
|
git merge --no-commit --autostash c2 &&
|
|
|
|
git stash show -p MERGE_AUTOSTASH >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
git commit 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
git show HEAD:file >merge-result &&
|
|
|
|
test_cmp result.1-5 merge-result &&
|
|
|
|
test_cmp result.1-5-9 file
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'completed merge (git merge --continue) with --no-commit and --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9 &&
|
|
|
|
git diff >expect &&
|
|
|
|
git merge --no-commit --autostash c2 &&
|
|
|
|
git stash show -p MERGE_AUTOSTASH >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
git merge --continue 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
git show HEAD:file >merge-result &&
|
|
|
|
test_cmp result.1-5 merge-result &&
|
|
|
|
test_cmp result.1-5-9 file
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'aborted merge (merge --abort) with --no-commit and --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9 &&
|
|
|
|
git diff >expect &&
|
|
|
|
git merge --no-commit --autostash c2 &&
|
|
|
|
git stash show -p MERGE_AUTOSTASH >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
git merge --abort 2>err &&
|
|
|
|
test_i18ngrep "Applied autostash." err &&
|
|
|
|
git diff >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'aborted merge (reset --hard) with --no-commit and --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9 &&
|
|
|
|
git diff >expect &&
|
|
|
|
git merge --no-commit --autostash c2 &&
|
|
|
|
git stash show -p MERGE_AUTOSTASH >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
git reset --hard 2>err &&
|
|
|
|
test_i18ngrep "Autostash exists; creating a new stash entry." err &&
|
|
|
|
git diff --exit-code
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'quit merge with --no-commit and --autostash' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9 &&
|
|
|
|
git diff >expect &&
|
|
|
|
git merge --no-commit --autostash c2 &&
|
|
|
|
git stash show -p MERGE_AUTOSTASH >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
git diff HEAD >expect &&
|
|
|
|
git merge --quit 2>err &&
|
|
|
|
test_i18ngrep "Autostash exists; creating a new stash entry." err &&
|
|
|
|
git diff HEAD >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merge with conflicted --autostash changes' '
|
|
|
|
git reset --hard c1 &&
|
|
|
|
git merge-file file file.orig file.9y &&
|
|
|
|
git diff >expect &&
|
|
|
|
test_when_finished "test_might_fail git stash drop" &&
|
|
|
|
git merge --autostash c3 2>err &&
|
|
|
|
test_i18ngrep "Applying autostash resulted in conflicts." err &&
|
|
|
|
git show HEAD:file >merge-result &&
|
|
|
|
test_cmp result.1-9 merge-result &&
|
|
|
|
git stash show -p >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:52:48 +00:00
|
|
|
cat >expected.branch <<\EOF
|
2020-07-30 17:06:42 +00:00
|
|
|
Merge branch 'c5-branch' (early part)
|
2010-08-17 06:52:48 +00:00
|
|
|
EOF
|
|
|
|
cat >expected.tag <<\EOF
|
2020-07-30 17:06:42 +00:00
|
|
|
Merge commit 'c5~1'
|
2008-10-13 20:54:25 +00:00
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'merge early part of c2' '
|
|
|
|
git reset --hard c3 &&
|
2010-08-17 06:53:56 +00:00
|
|
|
echo c4 >c4.c &&
|
2008-10-13 20:54:25 +00:00
|
|
|
git add c4.c &&
|
|
|
|
git commit -m c4 &&
|
|
|
|
git tag c4 &&
|
2010-08-17 06:53:56 +00:00
|
|
|
echo c5 >c5.c &&
|
2008-10-13 20:54:25 +00:00
|
|
|
git add c5.c &&
|
|
|
|
git commit -m c5 &&
|
|
|
|
git tag c5 &&
|
|
|
|
git reset --hard c3 &&
|
2010-08-17 06:53:56 +00:00
|
|
|
echo c6 >c6.c &&
|
2008-10-13 20:54:25 +00:00
|
|
|
git add c6.c &&
|
|
|
|
git commit -m c6 &&
|
|
|
|
git tag c6 &&
|
2010-08-17 06:52:48 +00:00
|
|
|
git branch -f c5-branch c5 &&
|
|
|
|
git merge c5-branch~1 &&
|
2014-05-14 22:12:45 +00:00
|
|
|
git show -s --pretty=tformat:%s HEAD >actual.branch &&
|
2010-08-17 06:52:48 +00:00
|
|
|
git reset --keep HEAD^ &&
|
2008-10-13 20:54:25 +00:00
|
|
|
git merge c5~1 &&
|
2014-05-14 22:12:45 +00:00
|
|
|
git show -s --pretty=tformat:%s HEAD >actual.tag &&
|
2010-08-17 06:52:48 +00:00
|
|
|
test_cmp expected.branch actual.branch &&
|
|
|
|
test_cmp expected.tag actual.tag
|
2008-10-13 20:54:25 +00:00
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
2008-10-03 13:02:31 +00:00
|
|
|
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
test_expect_success 'merge --no-ff --no-commit && commit' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge --no-ff --no-commit c1 &&
|
|
|
|
EDITOR=: git commit &&
|
|
|
|
verify_parents $c0 $c1
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
|
|
|
|
test_expect_success 'amending no-ff merge commit' '
|
|
|
|
EDITOR=: git commit --amend &&
|
|
|
|
verify_parents $c0 $c1
|
|
|
|
'
|
|
|
|
|
2010-08-17 06:54:59 +00:00
|
|
|
test_debug 'git log --graph --decorate --oneline --all'
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
|
2011-10-08 18:39:52 +00:00
|
|
|
cat >editor <<\EOF
|
|
|
|
#!/bin/sh
|
|
|
|
# Add a new message string that was not in the template
|
|
|
|
(
|
|
|
|
echo "Merge work done on the side branch c1"
|
|
|
|
echo
|
2019-04-17 10:23:21 +00:00
|
|
|
cat "$1"
|
2011-10-08 18:39:52 +00:00
|
|
|
) >"$1.tmp" && mv "$1.tmp" "$1"
|
|
|
|
# strip comments and blank lines from end of message
|
2019-04-17 10:23:21 +00:00
|
|
|
sed -e '/^#/d' "$1" | sed -e :a -e '/^\n*$/{$d;N;ba' -e '}' >expected
|
2011-10-08 18:39:52 +00:00
|
|
|
EOF
|
|
|
|
chmod 755 editor
|
|
|
|
|
|
|
|
test_expect_success 'merge --no-ff --edit' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
EDITOR=./editor git merge --no-ff --edit c1 &&
|
|
|
|
verify_parents $c0 $c1 &&
|
|
|
|
git cat-file commit HEAD >raw &&
|
|
|
|
grep "work done on the side branch" raw &&
|
|
|
|
sed "1,/^$/d" >actual raw &&
|
2017-10-06 19:00:06 +00:00
|
|
|
test_cmp expected actual
|
2011-10-08 18:39:52 +00:00
|
|
|
'
|
|
|
|
|
2018-02-14 18:18:55 +00:00
|
|
|
test_expect_success 'merge annotated/signed tag w/o tracking' '
|
|
|
|
test_when_finished "rm -rf dst; git tag -d anno1" &&
|
|
|
|
git tag -a -m "anno c1" anno1 c1 &&
|
|
|
|
git init dst &&
|
|
|
|
git rev-parse c1 >dst/expect &&
|
|
|
|
(
|
|
|
|
# c0 fast-forwards to c1 but because this repository
|
|
|
|
# is not a "downstream" whose refs/tags follows along
|
|
|
|
# tag from the "upstream", this pull defaults to --no-ff
|
|
|
|
cd dst &&
|
|
|
|
git pull .. c0 &&
|
|
|
|
git pull .. anno1 &&
|
|
|
|
git rev-parse HEAD^2 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merge annotated/signed tag w/ tracking' '
|
|
|
|
test_when_finished "rm -rf dst; git tag -d anno1" &&
|
|
|
|
git tag -a -m "anno c1" anno1 c1 &&
|
|
|
|
git init dst &&
|
|
|
|
git rev-parse c1 >dst/expect &&
|
|
|
|
(
|
|
|
|
# c0 fast-forwards to c1 and because this repository
|
|
|
|
# is a "downstream" whose refs/tags follows along
|
|
|
|
# tag from the "upstream", this pull defaults to --ff
|
|
|
|
cd dst &&
|
|
|
|
git remote add origin .. &&
|
|
|
|
git pull origin c0 &&
|
|
|
|
git fetch origin &&
|
|
|
|
git merge anno1 &&
|
|
|
|
git rev-parse HEAD >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
merge: do not create a signed tag merge under --ff-only option
Starting at release v1.7.9, if you ask to merge a signed tag, "git merge"
always creates a merge commit, even when the tag points at a commit that
happens to be a descendant of your current commit.
Unfortunately, this interacts rather badly for people who use --ff-only to
make sure that their branch is free of local developments. It used to be
possible to say:
$ git checkout -b frotz v1.7.9~30
$ git merge --ff-only v1.7.9
and expect that the resulting tip of frotz branch matches v1.7.9^0 (aka
the commit tagged as v1.7.9), but this fails with the updated Git with:
fatal: Not possible to fast-forward, aborting.
because a merge that merges v1.7.9 tag to v1.7.9~30 cannot be created by
fast forwarding.
We could teach users that now they have to do
$ git merge --ff-only v1.7.9^0
but it is far more pleasant for users if we DWIMmed this ourselves.
When an integrator pulls in a topic from a lieutenant via a signed tag,
even when the work done by the lieutenant happens to fast-forward, the
integrator wants to have a merge record, so the integrator will not be
asking for --ff-only when running "git pull" in such a case. Therefore,
this change should not regress the support for the use case v1.7.9 wanted
to add.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-06 00:22:12 +00:00
|
|
|
test_expect_success GPG 'merge --ff-only tag' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git commit --allow-empty -m "A newer commit" &&
|
|
|
|
git tag -s -m "A newer commit" signed &&
|
|
|
|
git reset --hard c0 &&
|
|
|
|
|
|
|
|
git merge --ff-only signed &&
|
|
|
|
git rev-parse signed^0 >expect &&
|
|
|
|
git rev-parse HEAD >actual &&
|
2017-10-06 19:00:06 +00:00
|
|
|
test_cmp expect actual
|
merge: do not create a signed tag merge under --ff-only option
Starting at release v1.7.9, if you ask to merge a signed tag, "git merge"
always creates a merge commit, even when the tag points at a commit that
happens to be a descendant of your current commit.
Unfortunately, this interacts rather badly for people who use --ff-only to
make sure that their branch is free of local developments. It used to be
possible to say:
$ git checkout -b frotz v1.7.9~30
$ git merge --ff-only v1.7.9
and expect that the resulting tip of frotz branch matches v1.7.9^0 (aka
the commit tagged as v1.7.9), but this fails with the updated Git with:
fatal: Not possible to fast-forward, aborting.
because a merge that merges v1.7.9 tag to v1.7.9~30 cannot be created by
fast forwarding.
We could teach users that now they have to do
$ git merge --ff-only v1.7.9^0
but it is far more pleasant for users if we DWIMmed this ourselves.
When an integrator pulls in a topic from a lieutenant via a signed tag,
even when the work done by the lieutenant happens to fast-forward, the
integrator wants to have a merge record, so the integrator will not be
asking for --ff-only when running "git pull" in such a case. Therefore,
this change should not regress the support for the use case v1.7.9 wanted
to add.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-06 00:22:12 +00:00
|
|
|
'
|
|
|
|
|
2012-02-09 21:30:52 +00:00
|
|
|
test_expect_success GPG 'merge --no-edit tag should skip editor' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git commit --allow-empty -m "A newer commit" &&
|
|
|
|
git tag -f -s -m "A newer commit" signed &&
|
|
|
|
git reset --hard c0 &&
|
|
|
|
|
2018-02-14 18:18:55 +00:00
|
|
|
EDITOR=false git merge --no-edit --no-ff signed &&
|
2012-02-09 21:30:52 +00:00
|
|
|
git rev-parse signed^0 >expect &&
|
|
|
|
git rev-parse HEAD^2 >actual &&
|
2017-10-06 19:00:06 +00:00
|
|
|
test_cmp expect actual
|
2012-02-09 21:30:52 +00:00
|
|
|
'
|
|
|
|
|
2015-10-28 22:44:21 +00:00
|
|
|
test_expect_success 'set up mod-256 conflict scenario' '
|
|
|
|
# 256 near-identical stanzas...
|
|
|
|
for i in $(test_seq 1 256); do
|
|
|
|
for j in 1 2 3 4 5; do
|
2021-12-09 05:11:15 +00:00
|
|
|
echo $i-$j || return 1
|
2015-10-28 22:44:21 +00:00
|
|
|
done
|
|
|
|
done >file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m base &&
|
|
|
|
|
2020-11-18 23:44:40 +00:00
|
|
|
# one side changes the first line of each to "main"
|
|
|
|
sed s/-1/-main/ file >tmp &&
|
2015-10-28 22:44:21 +00:00
|
|
|
mv tmp file &&
|
2020-11-18 23:44:40 +00:00
|
|
|
git commit -am main &&
|
2015-10-28 22:44:21 +00:00
|
|
|
|
|
|
|
# and the other to "side"; merging the two will
|
|
|
|
# yield 256 separate conflicts
|
|
|
|
git checkout -b side HEAD^ &&
|
2019-04-17 10:23:21 +00:00
|
|
|
sed s/-1/-side/ file >tmp &&
|
2015-10-28 22:44:21 +00:00
|
|
|
mv tmp file &&
|
|
|
|
git commit -am side
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merge detects mod-256 conflicts (recursive)' '
|
|
|
|
git reset --hard &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_must_fail git merge -s recursive main
|
2015-10-28 22:44:21 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'merge detects mod-256 conflicts (resolve)' '
|
|
|
|
git reset --hard &&
|
2020-11-18 23:44:40 +00:00
|
|
|
test_must_fail git merge -s resolve main
|
2015-10-28 22:44:21 +00:00
|
|
|
'
|
|
|
|
|
2016-03-21 19:01:43 +00:00
|
|
|
test_expect_success 'merge nothing into void' '
|
|
|
|
git init void &&
|
|
|
|
(
|
|
|
|
cd void &&
|
|
|
|
git remote add up .. &&
|
|
|
|
git fetch up &&
|
|
|
|
test_must_fail git merge FETCH_HEAD
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-12-14 08:37:55 +00:00
|
|
|
test_expect_success 'merge can be completed with --continue' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
git merge --no-ff --no-commit c1 &&
|
|
|
|
git merge --continue &&
|
|
|
|
verify_parents $c0 $c1
|
|
|
|
'
|
|
|
|
|
2017-08-23 12:10:45 +00:00
|
|
|
write_script .git/FAKE_EDITOR <<EOF
|
|
|
|
# kill -TERM command added below.
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success EXECKEEPSPID 'killed merge can be completed with --continue' '
|
|
|
|
git reset --hard c0 &&
|
|
|
|
! "$SHELL_PATH" -c '\''
|
2019-04-17 10:23:21 +00:00
|
|
|
echo kill -TERM $$ >>.git/FAKE_EDITOR
|
2017-08-23 12:10:45 +00:00
|
|
|
GIT_EDITOR=.git/FAKE_EDITOR
|
|
|
|
export GIT_EDITOR
|
|
|
|
exec git merge --no-ff --edit c1'\'' &&
|
|
|
|
git merge --continue &&
|
|
|
|
verify_parents $c0 $c1
|
|
|
|
'
|
|
|
|
|
merge: add --quit
This allows to cancel the current merge without resetting worktree/index,
which is what --abort is for. Like other --quit(s), this is often used
when you forgot that you're in the middle of a merge and already
switched away, doing different things. By the time you've realized, you
can't even continue the merge anymore.
This also makes all in-progress commands, am, merge, rebase, revert and
cherry-pick, take all three --abort, --continue and --quit (bisect has a
different UI).
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-18 11:30:43 +00:00
|
|
|
test_expect_success 'merge --quit' '
|
|
|
|
git init merge-quit &&
|
|
|
|
(
|
|
|
|
cd merge-quit &&
|
|
|
|
test_commit base &&
|
|
|
|
echo one >>base.t &&
|
|
|
|
git commit -am one &&
|
|
|
|
git branch one &&
|
|
|
|
git checkout base &&
|
|
|
|
echo two >>base.t &&
|
|
|
|
git commit -am two &&
|
|
|
|
test_must_fail git -c rerere.enabled=true merge one &&
|
|
|
|
test_path_is_file .git/MERGE_HEAD &&
|
|
|
|
test_path_is_file .git/MERGE_MODE &&
|
|
|
|
test_path_is_file .git/MERGE_MSG &&
|
|
|
|
git rerere status >rerere.before &&
|
|
|
|
git merge --quit &&
|
|
|
|
test_path_is_missing .git/MERGE_HEAD &&
|
|
|
|
test_path_is_missing .git/MERGE_MODE &&
|
|
|
|
test_path_is_missing .git/MERGE_MSG &&
|
|
|
|
git rerere status >rerere.after &&
|
|
|
|
test_must_be_empty rerere.after &&
|
|
|
|
! test_cmp rerere.after rerere.before
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
help_unknown_ref(): duplicate collected refnames
When "git merge" sees an unknown refname, we iterate through the refs to
try to suggest some possible alternates. We do so with for_each_ref(),
and in the callback we add some of the refnames we get to a
string_list that is declared with NODUP, directly adding a pointer into
the refname string our callback received.
But the for_each_ref() machinery does not promise that the refname
string will remain valid, and as a result we may print garbage memory.
The code in question dates back to its inception in e56181060e (help:
add help_unknown_ref(), 2013-05-04). But back then, the refname strings
generally did remain stable, at least immediately after the
for_each_ref() call. Later, in d1cf15516f (packed_ref_iterator_begin():
iterate using `mmapped_ref_iterator`, 2017-09-25), we started
consistently re-using a separate buffer for packed refs.
The fix is simple: duplicate the strings we intend to collect. We
already call string_list_clear(), so the memory is correctly freed.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-05-14 12:04:31 +00:00
|
|
|
test_expect_success 'merge suggests matching remote refname' '
|
|
|
|
git commit --allow-empty -m not-local &&
|
|
|
|
git update-ref refs/remotes/origin/not-local HEAD &&
|
|
|
|
git reset --hard HEAD^ &&
|
|
|
|
|
|
|
|
# This is white-box testing hackery; we happen to know
|
|
|
|
# that reading packed refs is more picky about the memory
|
|
|
|
# ownership of strings we pass to for_each_ref() callbacks.
|
|
|
|
git pack-refs --all --prune &&
|
|
|
|
|
|
|
|
test_must_fail git merge not-local 2>stderr &&
|
|
|
|
grep origin/not-local stderr
|
|
|
|
'
|
|
|
|
|
2019-05-14 12:05:05 +00:00
|
|
|
test_expect_success 'suggested names are not ambiguous' '
|
|
|
|
git update-ref refs/heads/origin/not-local HEAD &&
|
|
|
|
test_must_fail git merge not-local 2>stderr &&
|
|
|
|
grep remotes/origin/not-local stderr
|
|
|
|
'
|
|
|
|
|
2007-09-23 22:51:40 +00:00
|
|
|
test_done
|