undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

t5500: Modernize test style

Browse Source 
Code outside of the test harness was emitting "Initializing..." from
git-init. Fixup this test to be more modern:

    - test_expect_object_count() and count_objects() are unused

    - use grep directly instead of test "..." = $(grep ...)

    - end the test_expect_success line with a single-quote and put the
      test on a new line

    - put as much code inside the test harness as possible

    - no_strict_count_check is unused and duplicates the test
      "new object count"

    - use && whenever possible to catch errors early

    - use test_tick instead of GIT_AUTHOR_DATE=$sec

    - remove debugging aid log.txt

    - use subshells instead of cd-ing around

Also merge the pull test into one large test.

Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Stephen Boyd 2009-05-25 23:17:14 -07:00 committed by Junio C Hamano
parent d7107ca65f
commit 3902985a58
1 changed files with 146 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

270
t/t5500-fetch-pack.sh
View File

@ -3,9 +3,8 @@
# Copyright (c) 2005 Johannes Schindelin # Copyright (c) 2005 Johannes Schindelin
# #
test_description='Testing multi_ack pack fetching test_description='Testing multi_ack pack fetching'
'
. ./test-lib.sh . ./test-lib.sh
# Test fetch-pack/upload-pack pair. # Test fetch-pack/upload-pack pair.
@ -13,77 +12,60 @@ test_description='Testing multi_ack pack fetching
# Some convenience functions # Some convenience functions
add () { add () {
name=$1 name=$1 &&
text="$@" text="$@" &&
branch=`echo $name | sed -e 's/^\(.\).*$/\1/'` branch=`echo $name | sed -e 's/^\(.\).*$/\1/'` &&
parents="" parents="" &&
shift shift &&
while test $1; do while test $1; do
parents="$parents -p $1" parents="$parents -p $1" &&
shift shift
done done &&
echo "$text" > test.txt echo "$text" > test.txt &&
git update-index --add test.txt git update-index --add test.txt &&
tree=$(git write-tree) tree=$(git write-tree) &&
# make sure timestamps are in correct order # make sure timestamps are in correct order
sec=$(($sec+1)) test_tick &&
commit=$(echo "$text" | GIT_AUTHOR_DATE=$sec \ commit=$(echo "$text" | git commit-tree $tree $parents) &&
git commit-tree $tree $parents 2>>log2.txt) eval "$name=$commit; export $name" &&
eval "$name=$commit; export $name" echo $commit > .git/refs/heads/$branch &&
echo $commit > .git/refs/heads/$branch
eval ${branch}TIP=$commit eval ${branch}TIP=$commit
} }
count_objects () {
ls .git/objects/??/* 2>>log2.txt | wc -l | tr -d " "
}
test_expect_object_count () {
message=$1
count=$2
output="$(count_objects)"
test_expect_success \
"new object count $message" \
"test $count = $output"
}
pull_to_client () { pull_to_client () {
number=$1 number=$1 &&
heads=$2 heads=$2 &&
count=$3 count=$3 &&
no_strict_count_check=$4 test_expect_success "$number pull" '
(
cd client &&
git fetch-pack -k -v .. $heads &&
cd client case "$heads" in
test_expect_success "$number pull" \ *A*)
"git fetch-pack -k -v .. $heads" echo $ATIP > .git/refs/heads/A;;
case "$heads" in *A*) echo $ATIP > .git/refs/heads/A;; esac esac &&
case "$heads" in *B*) echo $BTIP > .git/refs/heads/B;; esac case "$heads" in *B*)
git symbolic-ref HEAD refs/heads/`echo $heads | sed -e 's/^\(.\).*$/\1/'` echo $BTIP > .git/refs/heads/B;;
esac &&
git symbolic-ref HEAD refs/heads/`echo $heads \
| sed -e "s/^\(.\).*$/\1/"` &&
test_expect_success "fsck" 'git fsck --full > fsck.txt 2>&1' git fsck --full &&
test_expect_success 'check downloaded results' \ mv .git/objects/pack/pack-* . &&
'mv .git/objects/pack/pack-* . && p=`ls -1 pack-*.pack` &&
p=`ls -1 pack-*.pack` && git unpack-objects <$p &&
git unpack-objects <$p && git fsck --full &&
git fsck --full'
test_expect_success "new object count after $number pull" \ idx=`echo pack-*.idx` &&
'idx=`echo pack-*.idx` && pack_count=`git show-index <$idx | wc -l` &&
pack_count=`git show-index <$idx | wc -l` && test $pack_count = $count &&
test $pack_count = $count' rm -f pack-*
test -z "$pack_count" && pack_count=0 )
if [ -z "$no_strict_count_check" ]; then '
test_expect_success "minimal count" "test $count = $pack_count"
else
test $count != $pack_count && \
echo "WARNING: $pack_count objects transmitted, only $count of which were needed"
fi
rm -f pack-*
cd ..
} }
# Here begins the actual testing # Here begins the actual testing
@ -94,89 +76,129 @@ pull_to_client () {
# client pulls A20, B1. Then tracks only B. Then pulls A. # client pulls A20, B1. Then tracks only B. Then pulls A.
( test_expect_success 'setup' '
mkdir client && mkdir client &&
cd client && (
git init 2>> log2.txt && cd client &&
git config transfer.unpacklimit 0 git init &&
) git config transfer.unpacklimit 0
) &&
add A1 add A1 &&
prev=1 &&
prev=1; cur=2; while [ $cur -le 10 ]; do cur=2 &&
add A$cur $(eval echo \$A$prev) while [ $cur -le 10 ]; do
prev=$cur add A$cur $(eval echo \$A$prev) &&
cur=$(($cur+1)) prev=$cur &&
done cur=$(($cur+1))
done &&
add B1 $A1 add B1 $A1
echo $ATIP > .git/refs/heads/A &&
echo $ATIP > .git/refs/heads/A echo $BTIP > .git/refs/heads/B &&
echo $BTIP > .git/refs/heads/B git symbolic-ref HEAD refs/heads/B
git symbolic-ref HEAD refs/heads/B '
pull_to_client 1st "B A" $((11*3)) pull_to_client 1st "B A" $((11*3))
add A11 $A10 test_expect_success 'post 1st pull setup' '
add A11 $A10 &&
prev=1; cur=2; while [ $cur -le 65 ]; do prev=1 &&
add B$cur $(eval echo \$B$prev) cur=2 &&
prev=$cur while [ $cur -le 65 ]; do
cur=$(($cur+1)) add B$cur $(eval echo \$B$prev) &&
done prev=$cur &&
cur=$(($cur+1))
done
'
pull_to_client 2nd "B" $((64*3)) pull_to_client 2nd "B" $((64*3))
pull_to_client 3rd "A" $((1*3)) # old fails pull_to_client 3rd "A" $((1*3))
test_expect_success "clone shallow" 'git clone --depth 2 "file://$(pwd)/." shallow' test_expect_success 'clone shallow' '
git clone --depth 2 "file://$(pwd)/." shallow
(cd shallow; git count-objects -v) > count.shallow
test_expect_success "clone shallow object count" \
"test \"in-pack: 18\" = \"$(grep in-pack count.shallow)\""
count_output () {
sed -e '/^in-pack:/d' -e '/^packs:/d' -e '/^size-pack:/d' -e '/: 0$/d' "$1"
}
test_expect_success "clone shallow object count (part 2)" '
test -z "$(count_output count.shallow)"
' '
test_expect_success "fsck in shallow repo" \ test_expect_success 'clone shallow object count' '
"(cd shallow; git fsck --full)" (
cd shallow &&
git count-objects -v
) > count.shallow &&
grep "^in-pack: 18" count.shallow
'
#test_done; exit test_expect_success 'clone shallow object count (part 2)' '
sed -e "/^in-pack:/d" -e "/^packs:/d" -e "/^size-pack:/d" \
-e "/: 0$/d" count.shallow > count_output &&
! test -s count_output
'
add B66 $B65 test_expect_success 'fsck in shallow repo' '
add B67 $B66 (
cd shallow &&
git fsck --full
)
'
test_expect_success "pull in shallow repo" \ test_expect_success 'add two more' '
"(cd shallow; git pull .. B)" add B66 $B65 &&
add B67 $B66
'
(cd shallow; git count-objects -v) > count.shallow test_expect_success 'pull in shallow repo' '
test_expect_success "clone shallow object count" \ (
"test \"count: 6\" = \"$(grep count count.shallow)\"" cd shallow &&
git pull .. B
)
'
add B68 $B67 test_expect_success 'clone shallow object count' '
add B69 $B68 (
cd shallow &&
git count-objects -v
) > count.shallow &&
grep "^count: 6" count.shallow
'
test_expect_success "deepening pull in shallow repo" \ test_expect_success 'add two more (part 2)' '
"(cd shallow; git pull --depth 4 .. B)" add B68 $B67 &&
add B69 $B68
'
(cd shallow; git count-objects -v) > count.shallow test_expect_success 'deepening pull in shallow repo' '
test_expect_success "clone shallow object count" \ (
"test \"count: 12\" = \"$(grep count count.shallow)\"" cd shallow &&
git pull --depth 4 .. B
)
'
test_expect_success "deepening fetch in shallow repo" \ test_expect_success 'clone shallow object count' '
"(cd shallow; git fetch --depth 4 .. A:A)" (
cd shallow &&
git count-objects -v
) > count.shallow &&
grep "^count: 12" count.shallow
'
(cd shallow; git count-objects -v) > count.shallow test_expect_success 'deepening fetch in shallow repo' '
test_expect_success "clone shallow object count" \ (
"test \"count: 18\" = \"$(grep count count.shallow)\"" cd shallow &&
git fetch --depth 4 .. A:A
)
'
test_expect_success "pull in shallow repo with missing merge base" \ test_expect_success 'clone shallow object count' '
"(cd shallow && test_must_fail git pull --depth 4 .. A)" (
cd shallow &&
git count-objects -v
) > count.shallow &&
grep "^count: 18" count.shallow
'
test_expect_success 'pull in shallow repo with missing merge base' '
(
cd shallow &&
test_must_fail git pull --depth 4 .. A
)
'
test_done test_done