2007-01-14 02:37:32 +00:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
test_description='test describe
|
|
|
|
|
|
|
|
B
|
|
|
|
.--------------o----o----o----x
|
|
|
|
/ / /
|
|
|
|
o----o----o----o----o----. /
|
|
|
|
\ A c /
|
|
|
|
.------------o---o---o
|
2010-04-12 23:25:29 +00:00
|
|
|
D,R e
|
2007-01-14 02:37:32 +00:00
|
|
|
'
|
|
|
|
. ./test-lib.sh
|
|
|
|
|
|
|
|
check_describe () {
|
|
|
|
expect="$1"
|
|
|
|
shift
|
2008-03-04 01:09:38 +00:00
|
|
|
R=$(git describe "$@" 2>err.actual)
|
2008-03-04 01:09:31 +00:00
|
|
|
S=$?
|
2008-03-04 01:09:38 +00:00
|
|
|
cat err.actual >&3
|
2007-01-14 02:37:32 +00:00
|
|
|
test_expect_success "describe $*" '
|
2008-03-04 01:09:31 +00:00
|
|
|
test $S = 0 &&
|
2007-01-14 02:37:32 +00:00
|
|
|
case "$R" in
|
|
|
|
$expect) echo happy ;;
|
|
|
|
*) echo "Oops - $R is not $expect";
|
|
|
|
false ;;
|
|
|
|
esac
|
|
|
|
'
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success setup '
|
|
|
|
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
echo one >file && git add file && git commit -m initial &&
|
2007-07-03 05:52:14 +00:00
|
|
|
one=$(git rev-parse HEAD) &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
2009-10-23 18:42:39 +00:00
|
|
|
git describe --always HEAD &&
|
|
|
|
|
2007-01-14 02:37:32 +00:00
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
echo two >file && git add file && git commit -m second &&
|
2007-07-03 05:52:14 +00:00
|
|
|
two=$(git rev-parse HEAD) &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
echo three >file && git add file && git commit -m third &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
echo A >file && git add file && git commit -m A &&
|
2007-01-14 02:37:32 +00:00
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git tag -a -m A A &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
echo c >file && git add file && git commit -m c &&
|
2007-01-14 02:37:32 +00:00
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git tag c &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
git reset --hard $two &&
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
echo B >side && git add side && git commit -m B &&
|
2007-01-14 02:37:32 +00:00
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git tag -a -m B B &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git merge -m Merged c &&
|
2007-07-03 05:52:14 +00:00
|
|
|
merged=$(git rev-parse HEAD) &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
git reset --hard $two &&
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
echo D >another && git add another && git commit -m D &&
|
2007-01-14 02:37:32 +00:00
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git tag -a -m D D &&
|
2010-04-12 23:25:29 +00:00
|
|
|
test_tick &&
|
|
|
|
git tag -a -m R R &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
test_tick &&
|
|
|
|
echo DD >another && git commit -a -m another &&
|
|
|
|
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git tag e &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
test_tick &&
|
|
|
|
echo DDD >another && git commit -a -m "yet another" &&
|
|
|
|
|
|
|
|
test_tick &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git merge -m Merged $merged &&
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
test_tick &&
|
2007-07-03 05:52:14 +00:00
|
|
|
echo X >file && echo X >side && git add file side &&
|
2008-09-03 08:59:29 +00:00
|
|
|
git commit -m x
|
2007-01-14 02:37:32 +00:00
|
|
|
|
|
|
|
'
|
|
|
|
|
|
|
|
check_describe A-* HEAD
|
|
|
|
check_describe A-* HEAD^
|
2010-04-12 23:25:29 +00:00
|
|
|
check_describe R-* HEAD^^
|
2007-01-14 02:37:32 +00:00
|
|
|
check_describe A-* HEAD^^2
|
|
|
|
check_describe B HEAD^^2^
|
2010-04-12 23:25:29 +00:00
|
|
|
check_describe R-* HEAD^^^
|
2007-01-14 02:37:32 +00:00
|
|
|
|
2008-10-13 14:39:46 +00:00
|
|
|
check_describe c-* --tags HEAD
|
|
|
|
check_describe c-* --tags HEAD^
|
|
|
|
check_describe e-* --tags HEAD^^
|
|
|
|
check_describe c-* --tags HEAD^^2
|
2007-01-14 02:37:32 +00:00
|
|
|
check_describe B --tags HEAD^^2^
|
2009-11-18 13:32:26 +00:00
|
|
|
check_describe e --tags HEAD^^^
|
|
|
|
|
|
|
|
check_describe heads/master --all HEAD
|
|
|
|
check_describe tags/c-* --all HEAD^
|
|
|
|
check_describe tags/e --all HEAD^^^
|
2007-01-14 02:37:32 +00:00
|
|
|
|
2008-02-25 09:43:33 +00:00
|
|
|
check_describe B-0-* --long HEAD^^2^
|
2008-03-04 02:29:51 +00:00
|
|
|
check_describe A-3-* --long HEAD^^2
|
2008-02-25 09:43:33 +00:00
|
|
|
|
2013-05-17 20:56:18 +00:00
|
|
|
check_describe c-7-* --tags
|
|
|
|
check_describe e-3-* --first-parent --tags
|
|
|
|
|
describe --contains: default to HEAD when no commit-ish is given
'git describe --contains' doesn't default to HEAD when no commit is
given, and it doesn't produce any output, not even an error:
~/src/git ((v2.5.0))$ ./git describe --contains
~/src/git ((v2.5.0))$ ./git describe --contains HEAD
v2.5.0^0
Unlike other 'git describe' options, the '--contains' code path is
implemented by calling 'name-rev' with a bunch of options plus all the
commit-ishes that were passed to 'git describe'. If no commit-ish was
present, then 'name-rev' got invoked with none, which then leads to the
behavior illustrated above.
Porcelain commands usually default to HEAD when no commit-ish is given,
and 'git describe' already does so in all other cases, so it should do
so with '--contains' as well.
Pass HEAD to 'name-rev' when no commit-ish is given on the command line
to make '--contains' behave consistently with other 'git describe'
options. While at it, use argv_array_pushv() instead of the loop to
pass commit-ishes to 'git name-rev'.
'git describe's short help already indicates that the commit-ish is
optional, but the synopsis in the man page doesn't, so update it
accordingly as well.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-24 16:15:18 +00:00
|
|
|
test_expect_success 'describe --contains defaults to HEAD without commit-ish' '
|
|
|
|
echo "A^0" >expect &&
|
|
|
|
git checkout A &&
|
|
|
|
test_when_finished "git checkout -" &&
|
|
|
|
git describe --contains >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-12-11 17:24:54 +00:00
|
|
|
check_describe tags/A --all A^0
|
2008-12-26 22:02:01 +00:00
|
|
|
test_expect_success 'no warning was displayed for A' '
|
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 err.actual
|
2008-12-26 22:02:01 +00:00
|
|
|
'
|
|
|
|
|
2008-03-04 01:09:38 +00:00
|
|
|
test_expect_success 'rename tag A to Q locally' '
|
|
|
|
mv .git/refs/tags/A .git/refs/tags/Q
|
|
|
|
'
|
|
|
|
cat - >err.expect <<EOF
|
|
|
|
warning: tag 'A' is really 'Q' here
|
|
|
|
EOF
|
|
|
|
check_describe A-* HEAD
|
2011-04-12 23:33:39 +00:00
|
|
|
test_expect_success 'warning was displayed for Q' '
|
|
|
|
test_i18ncmp err.expect err.actual
|
2008-03-04 01:09:38 +00:00
|
|
|
'
|
|
|
|
test_expect_success 'rename tag Q back to A' '
|
|
|
|
mv .git/refs/tags/Q .git/refs/tags/A
|
|
|
|
'
|
|
|
|
|
2008-03-04 01:09:35 +00:00
|
|
|
test_expect_success 'pack tag refs' 'git pack-refs'
|
|
|
|
check_describe A-* HEAD
|
|
|
|
|
2009-10-21 13:35:22 +00:00
|
|
|
check_describe "A-*[0-9a-f]" --dirty
|
|
|
|
|
|
|
|
test_expect_success 'set-up dirty work tree' '
|
|
|
|
echo >>file
|
|
|
|
'
|
|
|
|
|
|
|
|
check_describe "A-*[0-9a-f]-dirty" --dirty
|
|
|
|
|
|
|
|
check_describe "A-*[0-9a-f].mod" --dirty=.mod
|
|
|
|
|
|
|
|
test_expect_success 'describe --dirty HEAD' '
|
|
|
|
test_must_fail git describe --dirty HEAD
|
|
|
|
'
|
|
|
|
|
2008-06-04 19:06:31 +00:00
|
|
|
test_expect_success 'set-up matching pattern tests' '
|
|
|
|
git tag -a -m test-annotated test-annotated &&
|
|
|
|
echo >>file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -a -m "one more" &&
|
|
|
|
git tag test1-lightweight &&
|
|
|
|
echo >>file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -a -m "yet another" &&
|
|
|
|
git tag test2-lightweight &&
|
|
|
|
echo >>file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -a -m "even more"
|
|
|
|
|
|
|
|
'
|
|
|
|
|
|
|
|
check_describe "test-annotated-*" --match="test-*"
|
|
|
|
|
|
|
|
check_describe "test1-lightweight-*" --tags --match="test1-*"
|
|
|
|
|
|
|
|
check_describe "test2-lightweight-*" --tags --match="test2-*"
|
|
|
|
|
2008-07-03 02:32:45 +00:00
|
|
|
check_describe "test2-lightweight-*" --long --tags --match="test2-*" HEAD^
|
|
|
|
|
2017-09-16 05:53:44 +00:00
|
|
|
check_describe "test2-lightweight-*" --long --tags --match="test1-*" --match="test2-*" HEAD^
|
2017-01-18 23:06:07 +00:00
|
|
|
|
|
|
|
check_describe "test2-lightweight-*" --long --tags --match="test1-*" --no-match --match="test2-*" HEAD^
|
|
|
|
|
2017-09-16 05:53:44 +00:00
|
|
|
check_describe "test1-lightweight-*" --long --tags --match="test1-*" --match="test3-*" HEAD
|
|
|
|
|
|
|
|
check_describe "test1-lightweight-*" --long --tags --match="test3-*" --match="test1-*" HEAD
|
|
|
|
|
2017-09-20 01:10:10 +00:00
|
|
|
test_expect_success 'set-up branches' '
|
|
|
|
git branch branch_A A &&
|
|
|
|
git branch branch_C c &&
|
|
|
|
git update-ref refs/remotes/origin/remote_branch_A "A^{commit}" &&
|
|
|
|
git update-ref refs/remotes/origin/remote_branch_C "c^{commit}" &&
|
|
|
|
git update-ref refs/original/original_branch_A test-annotated~2
|
|
|
|
'
|
|
|
|
|
|
|
|
check_describe "heads/branch_A*" --all --match="branch_*" --exclude="branch_C" HEAD
|
|
|
|
|
|
|
|
check_describe "remotes/origin/remote_branch_A*" --all --match="origin/remote_branch_*" --exclude="origin/remote_branch_C" HEAD
|
|
|
|
|
|
|
|
check_describe "original/original_branch_A*" --all test-annotated~1
|
|
|
|
|
|
|
|
test_expect_success '--match does not work for other types' '
|
|
|
|
test_must_fail git describe --all --match="*original_branch_*" test-annotated~1
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '--exclude does not work for other types' '
|
|
|
|
R=$(git describe --all --exclude="any_pattern_even_not_matching" test-annotated~1) &&
|
|
|
|
case "$R" in
|
|
|
|
*original_branch_A*) echo "fail: Found unknown reference $R with --exclude"
|
|
|
|
false;;
|
|
|
|
*) echo ok: Found some known type;;
|
|
|
|
esac
|
|
|
|
'
|
|
|
|
|
2013-07-18 21:11:35 +00:00
|
|
|
test_expect_success 'name-rev with exact tags' '
|
|
|
|
echo A >expect &&
|
|
|
|
tag_object=$(git rev-parse refs/tags/A) &&
|
|
|
|
git name-rev --tags --name-only $tag_object >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
echo "A^0" >expect &&
|
|
|
|
tagged_commit=$(git rev-parse "refs/tags/A^0") &&
|
|
|
|
git name-rev --tags --name-only $tagged_commit >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-09-07 14:02:21 +00:00
|
|
|
test_expect_success 'name-rev --all' '
|
|
|
|
>expect.unsorted &&
|
|
|
|
for rev in $(git rev-list --all)
|
|
|
|
do
|
|
|
|
git name-rev $rev >>expect.unsorted
|
|
|
|
done &&
|
|
|
|
sort <expect.unsorted >expect &&
|
|
|
|
git name-rev --all >actual.unsorted &&
|
|
|
|
sort <actual.unsorted >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'name-rev --stdin' '
|
|
|
|
>expect.unsorted &&
|
|
|
|
for rev in $(git rev-list --all)
|
|
|
|
do
|
|
|
|
name=$(git name-rev --name-only $rev) &&
|
|
|
|
echo "$rev ($name)" >>expect.unsorted
|
|
|
|
done &&
|
|
|
|
sort <expect.unsorted >expect &&
|
|
|
|
git rev-list --all | git name-rev --stdin >actual.unsorted &&
|
|
|
|
sort <actual.unsorted >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2013-07-18 21:46:51 +00:00
|
|
|
test_expect_success 'describe --contains with the exact tags' '
|
|
|
|
echo "A^0" >expect &&
|
|
|
|
tag_object=$(git rev-parse refs/tags/A) &&
|
|
|
|
git describe --contains $tag_object >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
echo "A^0" >expect &&
|
|
|
|
tagged_commit=$(git rev-parse "refs/tags/A^0") &&
|
|
|
|
git describe --contains $tagged_commit >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-01-18 23:06:07 +00:00
|
|
|
test_expect_success 'describe --contains and --match' '
|
|
|
|
echo "A^0" >expect &&
|
|
|
|
tagged_commit=$(git rev-parse "refs/tags/A^0") &&
|
|
|
|
test_must_fail git describe --contains --match="B" $tagged_commit &&
|
|
|
|
git describe --contains --match="B" --match="A" $tagged_commit >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-01-18 23:06:08 +00:00
|
|
|
test_expect_success 'describe --exclude' '
|
|
|
|
echo "c~1" >expect &&
|
|
|
|
tagged_commit=$(git rev-parse "refs/tags/A^0") &&
|
|
|
|
test_must_fail git describe --contains --match="B" $tagged_commit &&
|
|
|
|
git describe --contains --match="?" --exclude="A" $tagged_commit >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-01-18 23:06:07 +00:00
|
|
|
test_expect_success 'describe --contains and --no-match' '
|
|
|
|
echo "A^0" >expect &&
|
|
|
|
tagged_commit=$(git rev-parse "refs/tags/A^0") &&
|
|
|
|
git describe --contains --match="B" --no-match $tagged_commit >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-03-21 22:57:18 +00:00
|
|
|
test_expect_success 'setup and absorb a submodule' '
|
|
|
|
test_create_repo sub1 &&
|
|
|
|
test_commit -C sub1 initial &&
|
|
|
|
git submodule add ./sub1 &&
|
|
|
|
git submodule absorbgitdirs &&
|
|
|
|
git commit -a -m "add submodule" &&
|
|
|
|
git describe --dirty >expect &&
|
|
|
|
git describe --broken >out &&
|
|
|
|
test_cmp expect out
|
|
|
|
'
|
|
|
|
|
2017-06-25 10:20:41 +00:00
|
|
|
test_expect_success 'describe chokes on severely broken submodules' '
|
2017-03-21 22:57:18 +00:00
|
|
|
mv .git/modules/sub1/ .git/modules/sub_moved &&
|
|
|
|
test_must_fail git describe --dirty
|
|
|
|
'
|
2017-11-02 19:41:42 +00:00
|
|
|
test_expect_success 'describe ignoring a broken submodule' '
|
2017-03-21 22:57:18 +00:00
|
|
|
git describe --broken >out &&
|
2017-09-07 14:02:22 +00:00
|
|
|
test_when_finished "mv .git/modules/sub_moved .git/modules/sub1" &&
|
2017-03-21 22:57:18 +00:00
|
|
|
grep broken out
|
|
|
|
'
|
|
|
|
|
builtin/describe.c: describe a blob
Sometimes users are given a hash of an object and they want to
identify it further (ex.: Use verify-pack to find the largest blobs,
but what are these? or [1])
When describing commits, we try to anchor them to tags or refs, as these
are conceptually on a higher level than the commit. And if there is no ref
or tag that matches exactly, we're out of luck. So we employ a heuristic
to make up a name for the commit. These names are ambiguous, there might
be different tags or refs to anchor to, and there might be different
path in the DAG to travel to arrive at the commit precisely.
When describing a blob, we want to describe the blob from a higher layer
as well, which is a tuple of (commit, deep/path) as the tree objects
involved are rather uninteresting. The same blob can be referenced by
multiple commits, so how we decide which commit to use? This patch
implements a rather naive approach on this: As there are no back pointers
from blobs to commits in which the blob occurs, we'll start walking from
any tips available, listing the blobs in-order of the commit and once we
found the blob, we'll take the first commit that listed the blob. For
example
git describe --tags v0.99:Makefile
conversion-901-g7672db20c2:Makefile
tells us the Makefile as it was in v0.99 was introduced in commit 7672db20.
The walking is performed in reverse order to show the introduction of a
blob rather than its last occurrence.
[1] https://stackoverflow.com/questions/223678/which-commit-has-this-blob
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-11-16 02:00:39 +00:00
|
|
|
test_expect_success 'describe a blob at a directly tagged commit' '
|
|
|
|
echo "make it a unique blob" >file &&
|
|
|
|
git add file && git commit -m "content in file" &&
|
|
|
|
git tag -a -m "latest annotated tag" unique-file &&
|
|
|
|
git describe HEAD:file >actual &&
|
|
|
|
echo "unique-file:file" >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'describe a blob with its first introduction' '
|
|
|
|
git commit --allow-empty -m "empty commit" &&
|
|
|
|
git rm file &&
|
|
|
|
git commit -m "delete blob" &&
|
|
|
|
git revert HEAD &&
|
|
|
|
git commit --allow-empty -m "empty commit" &&
|
|
|
|
git describe HEAD:file >actual &&
|
|
|
|
echo "unique-file:file" >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'describe directly tagged blob' '
|
|
|
|
git tag test-blob unique-file:file &&
|
|
|
|
git describe test-blob >actual &&
|
|
|
|
echo "unique-file:file" >expect &&
|
|
|
|
# suboptimal: we rather want to see "test-blob"
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'describe tag object' '
|
|
|
|
git tag test-blob-1 -a -m msg unique-file:file &&
|
|
|
|
test_must_fail git describe test-blob-1 2>actual &&
|
|
|
|
test_i18ngrep "fatal: test-blob-1 is neither a commit nor blob" actual
|
|
|
|
'
|
|
|
|
|
2017-09-07 14:02:23 +00:00
|
|
|
test_expect_failure ULIMIT_STACK_SIZE 'name-rev works in a deep repo' '
|
|
|
|
i=1 &&
|
|
|
|
while test $i -lt 8000
|
|
|
|
do
|
|
|
|
echo "commit refs/heads/master
|
|
|
|
committer A U Thor <author@example.com> $((1000000000 + $i * 100)) +0200
|
|
|
|
data <<EOF
|
|
|
|
commit #$i
|
|
|
|
EOF"
|
|
|
|
test $i = 1 && echo "from refs/heads/master^0"
|
|
|
|
i=$(($i + 1))
|
|
|
|
done | git fast-import &&
|
|
|
|
git checkout master &&
|
|
|
|
git tag far-far-away HEAD^ &&
|
|
|
|
echo "HEAD~4000 tags/far-far-away~3999" >expect &&
|
|
|
|
git name-rev HEAD~4000 >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
run_with_limited_stack git name-rev HEAD~4000 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success ULIMIT_STACK_SIZE 'describe works in a deep repo' '
|
|
|
|
git tag -f far-far-away HEAD~7999 &&
|
|
|
|
echo "far-far-away" >expect &&
|
|
|
|
git describe --tags --abbrev=0 HEAD~4000 >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
run_with_limited_stack git describe --tags --abbrev=0 HEAD~4000 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-12-11 17:24:54 +00:00
|
|
|
check_describe tags/A --all A
|
|
|
|
check_describe tags/c --all c
|
|
|
|
check_describe heads/branch_A --all --match='branch_*' branch_A
|
|
|
|
|
describe: confirm that blobs actually exist
Prior to 644eb60bd0 (builtin/describe.c: describe a blob,
2017-11-15), we noticed and complained about missing
objects, since they were not valid commits:
$ git describe 0000000000000000000000000000000000000000
fatal: 0000000000000000000000000000000000000000 is not a valid 'commit' object
After that commit, we feed any non-commit to lookup_blob(),
and complain only if it returns NULL. But the lookup_*
functions do not actually look at the on-disk object
database at all. They return an entry from the in-memory
object hash if present (and if it matches the requested
type), and otherwise auto-create a "struct object" of the
requested type.
A missing object would hit that latter case: we create a
bogus blob struct, walk all of history looking for it, and
then exit successfully having produced no output.
One reason nobody may have noticed this is that some related
cases do still work OK:
1. If we ask for a tree by sha1, then the call to
lookup_commit_referecne_gently() would have parsed it,
and we would have its true type in the in-memory object
hash.
2. If we ask for a name that doesn't exist but isn't a
40-hex sha1, then get_oid() would complain before we
even look at the objects at all.
We can fix this by replacing the lookup_blob() call with a
check of the true type via sha1_object_info(). This is not
quite as efficient as we could possibly make this check. We
know in most cases that the object was already parsed in the
earlier commit lookup, so we could call lookup_object(),
which does auto-create, and check the resulting struct's
type (or NULL). However it's not worth the fragility nor
code complexity to save a single object lookup.
The new tests cover this case, as well as that of a
tree-by-sha1 (which does work as described above, but was
not explicitly tested).
Noticed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Acked-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-12 17:23:06 +00:00
|
|
|
test_expect_success 'describe complains about tree object' '
|
|
|
|
test_must_fail git describe HEAD^{tree}
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'describe complains about missing object' '
|
2018-05-13 02:24:13 +00:00
|
|
|
test_must_fail git describe $ZERO_OID
|
describe: confirm that blobs actually exist
Prior to 644eb60bd0 (builtin/describe.c: describe a blob,
2017-11-15), we noticed and complained about missing
objects, since they were not valid commits:
$ git describe 0000000000000000000000000000000000000000
fatal: 0000000000000000000000000000000000000000 is not a valid 'commit' object
After that commit, we feed any non-commit to lookup_blob(),
and complain only if it returns NULL. But the lookup_*
functions do not actually look at the on-disk object
database at all. They return an entry from the in-memory
object hash if present (and if it matches the requested
type), and otherwise auto-create a "struct object" of the
requested type.
A missing object would hit that latter case: we create a
bogus blob struct, walk all of history looking for it, and
then exit successfully having produced no output.
One reason nobody may have noticed this is that some related
cases do still work OK:
1. If we ask for a tree by sha1, then the call to
lookup_commit_referecne_gently() would have parsed it,
and we would have its true type in the in-memory object
hash.
2. If we ask for a name that doesn't exist but isn't a
40-hex sha1, then get_oid() would complain before we
even look at the objects at all.
We can fix this by replacing the lookup_blob() call with a
check of the true type via sha1_object_info(). This is not
quite as efficient as we could possibly make this check. We
know in most cases that the object was already parsed in the
earlier commit lookup, so we could call lookup_object(),
which does auto-create, and check the resulting struct's
type (or NULL). However it's not worth the fragility nor
code complexity to save a single object lookup.
The new tests cover this case, as well as that of a
tree-by-sha1 (which does work as described above, but was
not explicitly tested).
Noticed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Acked-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-12 17:23:06 +00:00
|
|
|
'
|
|
|
|
|
2007-01-14 02:37:32 +00:00
|
|
|
test_done
|