# features. It is optional if you want to neither execute tests nor use any of

# these optional features.

perl_required = get_option('perl')

perl_required = true

endif

all:: $(DEFAULT_TEST_TARGET)

$(CHAINLINTSUPPRESS) $(MAKE) aggregate-results-and-cleanup

failed:

@failed=$$(cd '$(TEST_RESULTS_DIRECTORY_SQ)' && \

grep -l '^failed [1-9]' *.counts | \

sed -n 's/\.counts$$/.sh/p') && \

test -z "$$failed" || $(MAKE) $$failed

@echo "*** prove (shell & unit tests) ***"

@$(CHAINLINTSUPPRESS) TEST_OPTIONS='$(GIT_TEST_OPTS)' TEST_SHELL_PATH='$(TEST_SHELL_PATH_SQ)' $(PROVE) --exec ./run-test.sh $(GIT_PROVE_OPTS) $(T) $(UNIT_TESTS)

$(MAKE) clean-except-prove-cache

fi; \

done

test-lint-filenames

ifneq ($(GIT_TEST_CHAIN_LINT),0)

test-lint: test-chainlint

endif

return 0;

}

if (argc >= 2 && !strcmp(argv[1], "absolute_path")) {

while (argc > 2) {

puts(absolute_path(argv[2]));

{

test -z "$pfx" || echo "$pfx"

dd if=/dev/zero bs=1048576 count=$cnt 2>/dev/null |

} | ./t/helper/test-tool $sha1 $cnt

)

if test "$expect" = "$actual"

{

test -z "$pfx" || echo "$pfx"

dd if=/dev/zero bs=1048576 count=$cnt 2>/dev/null |

} | sha1sum |

sed -e 's/ .*//'

)

# Also we do not check SHA1 hash generation in this test, which

# is a job for t0000-basic.sh

test_cmp .tmp-1 .tmp-2 && rm -f .tmp-1 .tmp-2

}

'

sanitize_pgp() {

}

install_script broken-smart-http.sh

install_script error-smart-http.sh

install_script error.sh

install_script nph-custom-auth.sh

ln -s "$LIB_HTTPD_MODULE_PATH" "$HTTPD_ROOT_PATH/modules"

SetEnv GIT_EXEC_PATH ${GIT_EXEC_PATH}

SetEnv GIT_HTTP_EXPORT_ALL

</LocationMatch>

SetEnv GIT_EXEC_PATH ${GIT_EXEC_PATH}

SetEnv GIT_HTTP_EXPORT_ALL

</LocationMatch>

ScriptAlias /broken_smart/ broken-smart-http.sh/

ScriptAlias /error_smart/ error-smart-http.sh/

ScriptAlias /error/ error.sh/

ScriptAliasMatch /custom_auth/(.*) nph-custom-auth.sh/$1

<Directory ${GIT_EXEC_PATH}>

Options FollowSymlinks

<Files error.sh>

Options ExecCGI

</Files>

Options ExecCGI

</Files>

<Files ${GIT_EXEC_PATH}/git-http-backend>

# All alphanums translated into -'s which are then compressed and stripped

# from front and back.

name_from_description () {

}

}

broken_c_unquote () {

}

broken_c_unquote_verbose () {

}

stderr_contains () {

generate_random_characters () {

LEN=$1

NAME=$2

}

filter_git () {

)

'

test_config_global filter.protocol.process cat &&

test_config_global filter.protocol.required true &&

rm -rf repo &&

branch) opt='-f HEAD' ;;

esac

test_delayed_checkout_progress test_terminal git checkout $opt

'

test_delayed_checkout_progress ! git checkout $opt

'

test_delayed_checkout_progress ! test_terminal git checkout --quiet $opt

'

test_delayed_checkout_progress ! test_terminal git checkout --no-progress $opt &&

test_delayed_checkout_progress test_terminal git checkout --quiet --progress $opt

'

test_cache_tree

'

test_when_finished "git reset --hard" &&

cat <<-\EOT >foo.c &&

int foo()

test_cache_tree expected.status

'

mkdir -p deep/very-long-subdir &&

echo content >deep/very-long-subdir/file &&

git add deep &&

#

# Implicit return from cmd_<verb> function propagates <code>.

test_expect_success 'normal stream, return code 0' '

test_when_finished "rm trace.normal actual expect" &&

GIT_TRACE2="$(pwd)/trace.normal" test-tool trace2 001return 0 &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 001return 0

test_expect_success 'normal stream, return code 1' '

test_when_finished "rm trace.normal actual expect" &&

test_must_fail env GIT_TRACE2="$(pwd)/trace.normal" test-tool trace2 001return 1 &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 001return 1

test_when_finished "rm -r traces actual expect" &&

mkdir traces &&

GIT_TRACE2="$(pwd)/traces" test-tool trace2 001return 0 &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 001return 0

test_expect_success 'normal stream, exit code 0' '

test_when_finished "rm trace.normal actual expect" &&

GIT_TRACE2="$(pwd)/trace.normal" test-tool trace2 002exit 0 &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 002exit 0

test_expect_success 'normal stream, exit code 1' '

test_when_finished "rm trace.normal actual expect" &&

test_must_fail env GIT_TRACE2="$(pwd)/trace.normal" test-tool trace2 002exit 1 &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 002exit 1

test_expect_success 'normal stream, error event' '

test_when_finished "rm trace.normal actual expect" &&

GIT_TRACE2="$(pwd)/trace.normal" test-tool trace2 003error "hello world" "this is a test" &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 003error '\''hello world'\'' '\''this is a test'\''

test_expect_success 'BUG messages are written to trace2' '

test_when_finished "rm trace.normal actual expect" &&

test_must_fail env GIT_TRACE2="$(pwd)/trace.normal" test-tool trace2 007bug &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 007bug

sed "s/^.*: //" <err >actual &&

test_cmp expect actual &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 008bug

sed "s/^.*: //" <err >actual &&

test_cmp expect actual &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 009bug_BUG

sed "s/^.*: //" <err >actual &&

test_cmp expect actual &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 010bug_BUG

test_config_global trace2.normalBrief 1 &&

test_config_global trace2.normalTarget "$(pwd)/trace.normal" &&

test-tool trace2 001return 0 &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 001return 0

mv "$(pwd)/.gitconfig" "$(pwd)/real.gitconfig" &&

test_config_global include.path "$(pwd)/real.gitconfig" &&

test-tool trace2 001return 0 &&

cat >expect <<-EOF &&

version $V

start _EXE_ trace2 001return 0

. ./test-lib.sh

# Turn off any inherited trace2 settings for this test.

sane_unset GIT_TRACE2 GIT_TRACE2_PERF GIT_TRACE2_EVENT

sane_unset GIT_TRACE2_PERF_BRIEF

test_expect_success 'basic: can write large commit message' '

test_when_finished "rm -rf repo" &&

git init repo &&

git -C repo commit --allow-empty --file=../commit-msg

'

(

cd repo &&

test_commit A &&

cat >expect <<-EOF &&

fatal: update_ref failed for ref ${SQ}refs/heads/logme${SQ}: reftable: transaction failure: entry too large

EOF

' "$@"

}

git cat-file --batch-all-objects --batch >actual.raw &&

extract_batch_output $orig <actual.raw >actual &&

{

grep "^fatal:.*flush is only for --buffer mode.*" err

'

use warnings;

use strict;

use IPC::Open2;

expect="$hello_oid blob $hello_size"

'

'

test_done

grep "too-short tree object" err

'

hex_oid=$(echo foo | git hash-object --stdin -w) &&

bin_oid=$(echo $hex_oid | hex2oct) &&

printf "9100644 \0$bin_oid" >tree-with-malformed-mode &&

grep "malformed mode in tree entry" err

'

hex_oid=$(echo foo | git hash-object --stdin -w) &&

bin_oid=$(echo $hex_oid | hex2oct) &&

printf "100644 \0$bin_oid" >tree-with-empty-filename &&

grep "empty filename in tree entry" err

'

hex_oid=$(echo foo | git hash-object --stdin -w) &&

bin_oid=$(echo $hex_oid | hex2oct) &&

{

'

test_expect_success 'ls-tree output in wrong order given to mktree (1)' '

git mktree >actual &&

test_cmp tree actual

'

test_expect_success 'ls-tree output in wrong order given to mktree (2)' '

git mktree >actual &&

test_cmp tree.withsub actual

'

test_grep ! "fatal: empty filename in tree entry" out

'

test_when_finished "remove_object \$blob" &&

test_when_finished "remove_object \$tree" &&

test_when_finished "remove_object \$commit" &&

test_grep ! "dangling blob" out

'

test_when_finished "remove_object \$blob" &&

test_when_finished "remove_object \$tree" &&

blob=$(echo blob | git hash-object -w --stdin) &&

# Corrupt the checksum on the index and then

# verify that only fsck notices.

cp .git/index .git/index.backup &&

test_when_finished "mv .git/index.backup .git/index" &&

corrupt_index_checksum &&

tabs ," (dq) and spaces

EOF

git ls-files -z >ls-files.z &&

test_cmp expected current

'

tabs ," (dq) and spaces

EOF

git diff-index -z --name-status $t0 >diff-index.z &&

test_cmp expected current

'

tabs ," (dq) and spaces

EOF

git diff-tree -z --name-status $t0 $t1 >diff-tree.z &&

test_cmp expected current

'

. ./test-lib.sh

. "$TEST_DIRECTORY"/lib-diff.sh

test_expect_success setup '

GIT_AUTHOR_DATE="2006-06-26 00:00:00 +0000" &&

---

EOF

git checkout side &&

check_threading expect.no-threading main

'

References: <0>

EOF

check_threading expect.thread --thread main

'

test_config format.thread deep &&

check_threading expect.thread --thread main

'

References: <1>

EOF

check_threading expect.in-reply-to --in-reply-to="<test.message>" \

--thread main

'

References: <0>

EOF

check_threading expect.cover-letter --cover-letter --thread main

'

<0>

EOF

check_threading expect.cl-irt --cover-letter \

--in-reply-to="<test.message>" --thread main

'

check_threading expect.cl-irt --cover-letter \

--in-reply-to="<test.message>" --thread=shallow main

'

<1>

EOF

check_threading expect.deep --thread=deep main

'

<2>

EOF

check_threading expect.deep-irt --thread=deep \

--in-reply-to="<test.message>" main

'

<2>

EOF

check_threading expect.deep-cl --cover-letter --thread=deep main

'

<3>

EOF

check_threading expect.deep-cl-irt --cover-letter \

--in-reply-to="<test.message>" --thread=deep main

'

test_config format.thread true &&

check_threading expect.thread main

'

test_config format.thread deep &&

check_threading expect.deep main

'

test_config format.thread deep &&

check_threading expect.thread --thread main

'

test_config format.thread deep &&

check_threading expect.no-threading --no-thread main

'

check_external_diff 1 empty empty 1 on --quiet

check_external_diff 128 empty error 2 on --quiet

test_expect_success 'force diff with "diff"' '

after=$(git hash-object file) &&

git config --bool diff.suppressBlankEmpty true &&

git diff f > actual &&

test_cmp exp actual &&

git config --bool diff.suppressBlankEmpty false &&

git diff f > actual &&

test_cmp exp actual &&

+1

EOF

test_expect_success 'setup binary file with history' '

test_commit --printf one file "\\0\\n" &&

test_commit --printf --append two file "\\01\\n"

'

grep " rewrite file" diff

'

test_expect_success 'setup textconv' '

echo file diff=foo >.gitattributes &&

git config diff.foo.textconv "\"$(pwd)\""/dump

'

test_expect_success 'rewrite diff respects textconv' '

git diff -B >diff &&

'

test_done

. ./test-lib.sh

# make_tree_entry <mode> <mode> <sha1>

#

# We have to rely on perl here because not all printfs understand

git commit -m "Initial Version" 2>/dev/null &&

git checkout -b binary &&

cat file3 >file4 &&

git add file2 &&

rm -f file2 &&

git update-index --add --remove file1 file2 file3 file4 &&

git commit -m "Second Version" &&

test -z "$(git diff --name-status binary -- file3)"

'

do_reset &&

# this length is calculated to get us very close to

test_expect_success setup '

test_write_lines a b c d e f g h i j k l m n >file1 &&

git add file1 file2 &&

git commit -m initial &&

git tag initial &&

test_write_lines a b c g h i J K L m o n p q >file1 &&

git commit -a -m second &&

git tag second &&

Body test" --author="$LONG <long@example.com>" &&

git format-patch --stdout -1 >patch &&

# bump from, date, and subject down to in-body header

print \"From: x <x\@example.com>\";

print \"Date: Sat, 1 Jan 2000 00:00:00 +0000\";

print \"Subject: x\n\";

git checkout HEAD^ &&

git am msg &&

# Ensure that the author and full message are present

test_might_fail git config --unset rerere.enabled &&

test_must_fail git merge first &&

rr=.git/rr-cache/$sha1 &&

grep "^=======\$" $rr/preimage &&

! test -f $rr/postimage &&

git reset --hard &&

test_must_fail git merge first &&

rr=.git/rr-cache/$sha1 &&

grep ^=======$ $rr/preimage

'

git config rerere.enabled true &&

git reset --hard &&

test_must_fail git merge first &&

rr=.git/rr-cache/$sha1

'

test_expect_success 'rerere clear' '

mv $rr/postimage .git/post-saved &&

git rerere clear &&

! test -d $rr

'

test_cmp expect actual

'

git log --no-walk --pretty="%(trailers:unfold)" >actual &&

{

unfold <trailers &&

test_cmp expect actual

'

git log --no-walk --pretty="%(trailers:only,unfold)" >actual &&

git log --no-walk --pretty="%(trailers:unfold,only)" >reverse &&

test_cmp actual reverse &&

test_cmp expect actual

'

git log --no-walk --pretty="format:%(trailers:key=Signed-Off-by,unfold)" >actual &&

unfold <trailers | grep Signed-off-by >expect &&

test_cmp expect actual

test_cmp expect.out out

}

check_corrupt_graph BDAT clear 00000000 &&

echo "warning: ignoring too-small changed-path chunk" \

"(4 < 12) in commit-graph file" >expect.err &&

test_cmp expect.err err

'

check_corrupt_graph BIDX 12 FFFFFFFF &&

# use grep to avoid depending on exact chunk size

grep "warning: ignoring out-of-range offset (4294967295) for changed-path filter at pos 3 of .git/objects/info/commit-graph" err

'

# replace the index with a single entry, making most

# lookups out-of-bounds

check_corrupt_graph BIDX clear 00000000 &&

test_cmp expect.err err

'

# we do not know any real offsets, but we can pick

# something plausible; we should not get to the point of

# actually reading from the bogus offsets anyway.

. ./test-lib.sh

# the 10knuls.tar file is used to test for an empty git generated tar

# without having to invoke tar because an otherwise valid empty GNU tar

# will be considered broken by {Open,Net}BSD tar

test_expect_success 'setup' '

rm -f .git/index* &&

test-tool genrandom "seed a" 2097152 >a_big &&

test-tool genrandom "seed b" 2097152 >b_big &&

git update-index --add a a_big b b_big c &&

# usage: check_deltas <stderr_from_pack_objects> <cmp_op> <nr_deltas>

# e.g.: check_deltas stderr -gt 0

check_deltas() {

shift &&

if ! test "$deltas" "$@"

then

check_unpack test-3-${packname_3} obj-list "$BATCH_CONFIGURATION"

'

perl -e '\''

defined($_ = -s $_) or die for @ARGV;

exit 1 if $ARGV[0] <= $ARGV[1];

create_new_pack &&

git prune-packed &&

chmod +w ${pack}.pack &&

test_must_fail git cat-file blob $blob_1 > /dev/null &&

test_must_fail git cat-file blob $blob_2 > /dev/null &&

test_must_fail git cat-file blob $blob_3 > /dev/null

create_new_pack &&

git prune-packed &&

chmod +w ${pack}.pack &&

git cat-file blob $blob_1 > /dev/null &&

test_must_fail git cat-file blob $blob_2 > /dev/null &&

test_must_fail git cat-file blob $blob_3 > /dev/null

# mark the commits which did not receive bitmaps as preferred,

# and generate the bitmap again

git update-ref --stdin &&

git -c pack.preferBitmapTips=refs/tags/include repack -adb &&

max_chain() {

git index-pack --verify-stat-only "$1" >output &&

}

# Note that this whole setup is pretty reliant on the current

test_cmp expect.out out

}

# make it big enough that the graph file is plausible,

# otherwise we hit an earlier check

check_corrupt_chunk OIDF clear $(printf "000000%02x" $(test_seq 250)) &&

test_cmp expect.err err

'

check_corrupt_chunk OIDF 1020 "FFFFFFFF" &&

cat >expect.err <<-\EOF &&

error: commit-graph OID lookup chunk is the wrong size

test_cmp expect.err err

'

# Rather than try to corrupt a specific hash, we will just

# wreck them all. But we cannot just set them all to 0xFFFFFFFF or

# similar, as they are used for hi/lo starts in a binary search (so if

test_cmp expect.err err

'

check_corrupt_chunk CDAT clear 00000000 &&

cat >expect.err <<-\EOF &&

error: commit-graph commit data chunk is wrong size

test_cmp expect.err err

'

check_corrupt_chunk EDGE clear &&

cat >expect.err <<-\EOF &&

error: commit-graph extra-edges pointer out of bounds

test_cmp expect.err err

'

check_corrupt_chunk GDA2 clear 00000000 &&

cat >expect.err <<-\EOF &&

error: commit-graph generations chunk is wrong size

corrupt_chunk_file $midx "$@"

}

corrupt_chunk OIDF clear 00000000 &&

test_must_fail git log 2>err &&

cat >expect <<-\EOF &&

test_cmp expect err

'

corrupt_chunk OIDL clear 00000000 &&

test_must_fail git log 2>err &&

cat >expect <<-\EOF &&

test_cmp expect err

'

# There is no NUL to terminate the name here, so the

# chunk is too short.

corrupt_chunk PNAM clear 70656666 &&

test_cmp expect err

'

# A 9-byte PNAM means all of the subsequent chunks

# will no longer be 4-byte aligned, but it is still

# a valid one-pack chunk on its own (it is "foo.pack\0").

test_cmp expect.err err

'

corrupt_chunk OOFF clear 00000000 &&

test_must_fail git log 2>err &&

cat >expect <<-\EOF &&

test_cmp expect err

'

# re-use the objects64 dir here to cheaply get access to a midx

# with large offsets.

git init repo &&

)

'

# We only get a revindex with bitmaps (and likewise only

# load it when they are asked for).

test_config repack.writeBitmaps true &&

test_cmp expect.err err

'

# This is similar to the out-of-bounds fanout test in t5318. The values

# in adjacent entries should be large but not identical (they

# are used as hi/lo starts for a binary search, which would then abort

)

'

git clone --no-hardlinks . corrupt-base-chunk &&

(

cd corrupt-base-chunk &&

comm -13 bitmaps commits >before &&

test_line_count = 1 before &&

rm -fr $midx-$(midx_checksum $objdir).bitmap &&

rm -fr $midx &&

git -C repo-uint32-max commit-graph verify

'

graph=.git/objects/info/commit-graph &&

test_when_finished "rm -rf $graph" &&

git commit-graph write --reachable &&

tag_everything () {

git rev-list --all --no-object-names >in &&

}

test_expect_success 'setup' '

test_cmp expect actual

'

test_config bitmapPseudoMerge.test.pattern "refs/tags/" &&

test_config bitmapPseudoMerge.test.maxMerges 1 &&

test_config bitmapPseudoMerge.test.stableThreshold never &&

test_commit_bulk 16 &&

git rev-list HEAD~16.. >in &&

git update-ref --stdin || return 1

done &&

do

test_pseudo_merge_commits $m >oids &&

grep -f oids refs |

sort -u || return 1

done >remotes &&

'

}

git init shared &&

git -C shared commit --allow-empty -m both &&

git clone -s shared fork &&

'

extract_haves () {

}

test_expect_success 'with core.alternateRefsCommand' '

. ./test-lib.sh

# End state of the repository:

#

# T - tag1 S - tag2

grep "Cannot demote unterminatedheader" act

'

git init --bare badmode.git &&

tree=$(

cd badmode.git &&

. ./test-lib.sh

. "$TEST_DIRECTORY"/lib-bundle.sh

D=$(pwd)

test_expect_success setup '

. ./test-lib.sh

test_expect_success 'setup remote repo' '

git init remote &&

(cd remote &&

# Tweak the push output to make the push option outside the cert

# different, then replay it on a fresh dst, checking that ff is not

# deleted.

prepare_dst &&

git -C dst config receive.certnonceseed sekrit &&

git -C dst config receive.advertisepushoptions 1 &&

git -C "$REPO" config protocol.version 2 &&

git -C client config protocol.version 2 &&

# Craft a situation in which the server sends back an unshallow request

# with an empty packfile. This is done by refetching with a shorter

# depth (to ensure that the packfile is empty), and overwriting the

# shallow line in the response with the unshallow line we want.

test_must_fail env GIT_TEST_SIDEBAND_ALL=0 git -C client \

main:a_branch &&

# Ensure that the resulting repo is consistent, despite our failure to

# fetch.

. ./test-lib.sh

. "$TEST_DIRECTORY"/lib-httpd.sh

test "$HTTP_PROTO" = "HTTP/2" && enable_http2

start_httpd

. ./test-lib.sh

test_lazy_prereq GZIP 'gzip --version'

verify_http_result() {

git -C replay.git index-pack -v --stdin <tmp.pack

'

git init icasefs &&

(

cd icasefs &&

)

'

grep X icasefs/warning &&

grep x icasefs/warning &&

test_grep "the following paths have collided" icasefs/warning

sed 's/\(..\)/'$1'\1/g'

}

replace_packfile () {

}

test_expect_success 'upon cloning, check that all refs point to objects' '

# section header.

test_config -C "$SERVER" protocol.version 2 &&

test_must_fail git -c protocol.version=2 clone \

test_grep "did not send all necessary objects" err &&

'

test_expect_success 'when partial cloning, tolerate server not sending target of tag' '

# Exercise to make sure it works.

git -c protocol.version=2 clone \

! grep "missing object referenced by" err &&

'

SERVER="$HTTPD_DOCUMENT_ROOT_PATH/server" &&

rm -rf "$SERVER" repo &&

test_create_repo "$SERVER" &&

# Clone. The client has deltabase_have but not deltabase_missing.

git -c protocol.version=2 clone --no-checkout \

git -C repo hash-object -w -- "$SERVER/have.txt" &&

# Sanity check to ensure that the client does not have

grep "want $(cat deltabase_missing)" trace &&

! grep "want $(cat deltabase_have)" trace &&

'

# DO NOT add non-httpd-specific tests here, because the last part of this

echo command=ls-refs &&

echo object-format=$(test_oid algo) &&

echo 0001 &&

echo 0000

} |

test-tool pkt-line pack >in &&

# After "ready" in the acknowledgments section, pretend that a FLUSH

# (0000) was sent instead of a DELIM (0001).

test_must_fail git -C http_child -c protocol.version=2 \

test_grep "expected packfile to be sent after .ready." err

'

# After the acknowledgments section, pretend that a DELIM

# (0001) was sent instead of a FLUSH (0000).

test_must_fail env GIT_TRACE_PACKET="$(pwd)/log" git -C http_child \

-c protocol.version=2 \

grep "fetch< .*acknowledgments" log &&

! grep "fetch< .*ready" log &&

test_grep "expected no other sections to be sent after no .ready." err

test_expect_success 'http:// --negotiate-only without wait-for-done support' '

SERVER="server" &&

setup_negotiate_only "$SERVER" "$URI" &&

test_must_fail git -c protocol.version=2 -C client fetch \

--no-tags \

test_expect_success 'config controls ref-in-want advertisement' '

test-tool serve-v2 --advertise-capabilities >out &&

git config uploadpack.allowRefInWant false &&

test-tool serve-v2 --advertise-capabilities >out &&

git config uploadpack.allowRefInWant true &&

test-tool serve-v2 --advertise-capabilities >out &&

'

test_expect_success 'invalid want-ref line' '

test_commit m3 &&

git tag -d m2 m3

) &&

git -C "$LOCAL_PRISTINE" config protocol.version 2

'

# RPCs during a single negotiation.

oid1=$(git -C "$REPO" rev-parse $1) &&

oid2=$(git -C "$REPO" rev-parse $2) &&

}

git -C "$REPO" config uploadpack.allowRefInWant false &&

rm -rf local &&

cp -r "$LOCAL_PRISTINE" local &&

test_grep "fatal: remote error: upload-pack: not our ref" err

'

git -C "$REPO" config uploadpack.allowRefInWant true &&

rm -rf local &&

cp -r "$LOCAL_PRISTINE" local &&

test_cmp expected actual

'

git -C "$REPO" config uploadpack.allowRefInWant false &&

rm -rf local &&

cp -r "$LOCAL_PRISTINE" local &&

test_cmp expected actual

'

git -C "$REPO" config uploadpack.allowRefInWant true &&

rm -rf local &&

cp -r "$LOCAL_PRISTINE" local &&

test_cmp expected actual

'

git -C "$REPO" config uploadpack.allowRefInWant true &&

rm -rf local &&

cp -r "$LOCAL_PRISTINE" local &&

test_must_fail git -C local fetch 2>err &&

test_grep "fatal: remote error: unknown ref refs/heads/rain" err

. ./test-lib.sh

GIT_TEST_MULTI_PACK_INDEX=0

GIT_TEST_MULTI_PACK_INDEX_WRITE_INCREMENTAL=0

first_commit=$(git rev-parse HEAD~3)

'

test_expect_success 'rev-list should fail' '

test_must_fail env GIT_TEST_COMMIT_GRAPH=0 git -c core.commitGraph=false rev-list --all > /dev/null

commit five

'

test_expect_success '--reverse --parents --full-history combines correctly' '

git rev-list --reverse --parents --full-history main -- foo \

> actual &&

test_cmp expected actual

'

test_expect_success '--boundary does too' '

git rev-list --boundary --reverse --parents --full-history \

main ^root -- foo > actual &&

test_cmp expected actual

. ./test-lib.sh

test_expect_success 'setup well-formed objects' '

blob="$(printf "foo" | git hash-object -w --stdin)" &&

tree="$(printf "100644 blob $blob\tfoo" | git mktree)" &&

disk_usage_slow () {

git rev-list --no-object-names "$@" |

git cat-file --batch-check="%(objectsize:disk)" |

}

# check behavior with given rev-list options; note that

test_must_fail git for-each-ref --format="%(raw)" --tcl

'

git for-each-ref --format="\$name= %(raw);

print \"\$name\"" refs/myblobs/blob1 --perl | perl >actual &&

cmp blob1 actual &&

'

test_trailer_option () {

title=$1 option=$2

cat >expect

git for-each-ref --format="%($option)" refs/heads/main >actual &&

test_cmp expect actual &&

git for-each-ref --format="%(contents:$option)" refs/heads/main >actual &&

'

}

'trailers:unfold' <<-EOF

$(unfold <trailers)

EOF

'trailers:only,unfold' <<-EOF

$(grep -v patch.description <trailers | unfold)

EOF

'trailers:unfold,only' <<-EOF

$(grep -v patch.description <trailers | unfold)

'

test_expect_success 'setup large log output' '

git commit --allow-empty -F commit-msg

'

'

test_expect_success 'remove ./ protection from .gitmodules url' '

git commit -am "drop protection"

'

test_must_fail git commit -m foo -a file

'

echo bong-o-bong >file &&

# 2: update, 1:st path, that is all, 7: quit

test_write_lines 2 1 "" 7 |

grep Rubber.Duck output

'

echo 7 | test_must_fail git commit --interactive >out &&

grep "What now" out

'

echo zoo >file &&

test_must_fail git diff --exit-code >diff1 &&

test_write_lines u "*" q |

test_expect_success 'status -z implies porcelain' '

git status --porcelain |

git status -z >output &&

test_cmp expect output

'

test_cmp expect actual

'

test_expect_success 'setup textconv filters' '

echo a diff=foo >.gitattributes &&

git config diff.foo.textconv "\"$(pwd)\""/nul_to_q_textconv

'

TEST_CREATE_REPO_NO_TEMPLATE=1

. ./test-lib.sh

PROG='git annotate'

. "$TEST_DIRECTORY"/annotate-tests.sh

TEST_CREATE_REPO_NO_TEMPLATE=1

. ./test-lib.sh

PROG='git blame -c'

. "$TEST_DIRECTORY"/annotate-tests.sh

expect=$1 && shift &&

echo $sha1 | cut -c 1-$expect >expect &&

git blame "$@" abbrev.t >actual &&

test_cmp expect actual.sha

}

'

cat >helper <<'EOF'

#!/bin/sh

grep -q '^bin: ' "$1" || { echo "E: $1 is not \"binary\" file" 1>&2; exit 1; }

EOF

chmod +x helper

git blame --root -C --$output combined >output

'

generate_expect >expect <<-\EOF &&

5 base

1 modified

test_cmp expect actual

'

generate_expect >expect <<-\EOF &&

11 one

11 two

test_cmp expect actual

'

generate_expect >expect <<-EOF &&

5 NONE

1 $(git rev-parse modified^) one

TEST_CREATE_REPO_NO_TEMPLATE=1

. ./test-lib.sh

PROG='git blame -c'

. "$TEST_DIRECTORY"/annotate-tests.sh

test x"$(sed -n -e 61p < file)" = x61 &&

svn_cmd co "$svnrepo" tmp &&

(cd tmp &&

poke file &&

test x"$(sed -n -e 58p < file)" = x5588 &&

test x"$(sed -n -e 61p < file)" = x6611 &&

test_expect_success 'change file but in unrelated area' "

test x\"\$(sed -n -e 4p < file)\" = x4 &&

test x\"\$(sed -n -e 7p < file)\" = x7 &&

test x\"\$(sed -n -e 4p < file)\" = x4444 &&

test x\"\$(sed -n -e 7p < file)\" = x7777 &&

git commit -m '4 => 4444, 7 => 7777' file &&

(cd result && git show main:foo)

'

git init crazy-paths &&

test_config -C crazy-paths core.protectNTFS false &&

(cd crazy-paths &&

'

test_expect_success 'shell complains of overlong commands' '

test_must_fail git shell 2>err &&

grep "too long" err

'

}

lf_to_nul () {

}

nul_to_q () {

}

q_to_nul () {

}

q_to_cr () {

# Read up to "$1" bytes (or to EOF) from stdin and write them to stdout.

test_copy_bytes () {

}

# run "$@" inside a non-git directory

# Print the destination of symlink(s) provided as arguments. Basically

# the same as the readlink command, but it's not available everywhere.

test_readlink () {

}

# Set mtime to a fixed "magic" timestamp in mid February 2009, before we

# /usr/xpg4/bin/sh and /bin/ksh to bail out. So keep the unsets

# deriving from the command substitution clustered with the other

# ones.

unset XDG_CACHE_HOME

unset XDG_CONFIG_HOME

unset GITPERLLIB

export LSAN_OPTIONS

fi

if test "${GIT_TEST_CHAIN_LINT:-1}" != 0 &&

test "${GIT_TEST_EXT_CHAIN_LINT:-1}" != 0

then

test -z "$NO_GETTEXT" && test_set_prereq GETTEXT

test -n "$SANITIZE_LEAK" && test_set_prereq SANITIZE_LEAK

test -n "$GIT_VALGRIND_ENABLED" && test_set_prereq VALGRIND

if test -z "$GIT_TEST_CHECK_CACHE_TREE"

then