[thirdparty/git.git] / t / test-lib.sh

#!/bin/sh
#
# Copyright (c) 2005 Junio C Hamano
#

# if --tee was passed, write the output not only to the terminal, but
# additionally to the file test-results/$BASENAME.out, too.
case "$GIT_TEST_TEE_STARTED, $* " in
done,*)
	# do not redirect again
	;;
*' --tee '*|*' --va'*)
	mkdir -p test-results
	BASE=test-results/$(basename "$0" .sh)
	(GIT_TEST_TEE_STARTED=done ${SHELL-sh} "$0" "$@" 2>&1;
	 echo $? > $BASE.exit) | tee $BASE.out
	test "$(cat $BASE.exit)" = 0
	exit
	;;
esac

# Keep the original TERM for say_color
ORIGINAL_TERM=$TERM

# For repeatability, reset the environment to known value.
LANG=C
LC_ALL=C
PAGER=cat
TZ=UTC
TERM=dumb
export LANG LC_ALL PAGER TERM TZ
EDITOR=:
VISUAL=:
unset GIT_EDITOR
unset AUTHOR_DATE
unset AUTHOR_EMAIL
unset AUTHOR_NAME
unset COMMIT_AUTHOR_EMAIL
unset COMMIT_AUTHOR_NAME
unset EMAIL
unset GIT_ALTERNATE_OBJECT_DIRECTORIES
unset GIT_AUTHOR_DATE
GIT_AUTHOR_EMAIL=author@example.com
GIT_AUTHOR_NAME='A U Thor'
unset GIT_COMMITTER_DATE
GIT_COMMITTER_EMAIL=committer@example.com
GIT_COMMITTER_NAME='C O Mitter'
unset GIT_DIFF_OPTS
unset GIT_DIR
unset GIT_WORK_TREE
unset GIT_EXTERNAL_DIFF
unset GIT_INDEX_FILE
unset GIT_OBJECT_DIRECTORY
unset GIT_CEILING_DIRECTORIES
unset SHA1_FILE_DIRECTORIES
unset SHA1_FILE_DIRECTORY
GIT_MERGE_VERBOSITY=5
export GIT_MERGE_VERBOSITY
export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME
export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME
export EDITOR VISUAL
GIT_TEST_CMP=${GIT_TEST_CMP:-diff -u}

# Protect ourselves from common misconfiguration to export
# CDPATH into the environment
unset CDPATH

case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in
	1|2|true)
		echo "* warning: Some tests will not work if GIT_TRACE" \
			"is set as to trace on STDERR ! *"
		echo "* warning: Please set GIT_TRACE to something" \
			"other than 1, 2 or true ! *"
		;;
esac

# Each test should start with something like this, after copyright notices:
#
# test_description='Description of this test...
# This test checks if command xyzzy does the right thing...
# '
# . ./test-lib.sh
[ "x$ORIGINAL_TERM" != "xdumb" ] && (
		TERM=$ORIGINAL_TERM &&
		export TERM &&
		[ -t 1 ] &&
		tput bold >/dev/null 2>&1 &&
		tput setaf 1 >/dev/null 2>&1 &&
		tput sgr0 >/dev/null 2>&1
	) &&
	color=t

while test "$#" -ne 0
do
	case "$1" in
	-d|--d|--de|--deb|--debu|--debug)
		debug=t; shift ;;
	-i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate)
		immediate=t; shift ;;
	-l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests)
		GIT_TEST_LONG=t; export GIT_TEST_LONG; shift ;;
	-h|--h|--he|--hel|--help)
		help=t; shift ;;
	-v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose)
		verbose=t; shift ;;
	-q|--q|--qu|--qui|--quie|--quiet)
		quiet=t; shift ;;
	--no-color)
		color=; shift ;;
	--no-python)
		# noop now...
		shift ;;
	--va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind)
		valgrind=t; verbose=t; shift ;;
	--tee)
		shift ;; # was handled already
	*)
		break ;;
	esac
done

if test -n "$color"; then
	say_color () {
		(
		TERM=$ORIGINAL_TERM
		export TERM
		case "$1" in
			error) tput bold; tput setaf 1;; # bold red
			skip)  tput bold; tput setaf 2;; # bold green
			pass)  tput setaf 2;;            # green
			info)  tput setaf 3;;            # brown
			*) test -n "$quiet" && return;;
		esac
		shift
		printf "* %s" "$*"
		tput sgr0
		echo
		)
	}
else
	say_color() {
		test -z "$1" && test -n "$quiet" && return
		shift
		echo "* $*"
	}
fi

error () {
	say_color error "error: $*"
	trap - EXIT
	exit 1
}

say () {
	say_color info "$*"
}

test "${test_description}" != "" ||
error "Test script did not set test_description."

if test "$help" = "t"
then
	echo "$test_description"
	exit 0
fi

exec 5>&1
if test "$verbose" = "t"
then
	exec 4>&2 3>&1
else
	exec 4>/dev/null 3>/dev/null
fi

test_failure=0
test_count=0
test_fixed=0
test_broken=0
test_success=0

die () {
	echo >&5 "FATAL: Unexpected exit with code $?"
	exit 1
}

trap 'die' EXIT

# The semantics of the editor variables are that of invoking
# sh -c "$EDITOR \"$@\"" files ...
#
# If our trash directory contains shell metacharacters, they will be
# interpreted if we just set $EDITOR directly, so do a little dance with
# environment variables to work around this.
#
# In particular, quoting isn't enough, as the path may contain the same quote
# that we're using.
test_set_editor () {
	FAKE_EDITOR="$1"
	export FAKE_EDITOR
	VISUAL='"$FAKE_EDITOR"'
	export VISUAL
}

test_tick () {
	if test -z "${test_tick+set}"
	then
		test_tick=1112911993
	else
		test_tick=$(($test_tick + 60))
	fi
	GIT_COMMITTER_DATE="$test_tick -0700"
	GIT_AUTHOR_DATE="$test_tick -0700"
	export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
}

# Call test_commit with the arguments "<message> [<file> [<contents>]]"
#
# This will commit a file with the given contents and the given commit
# message.  It will also add a tag with <message> as name.
#
# Both <file> and <contents> default to <message>.

test_commit () {
	file=${2:-"$1.t"}
	echo "${3-$1}" > "$file" &&
	git add "$file" &&
	test_tick &&
	git commit -m "$1" &&
	git tag "$1"
}

# Call test_merge with the arguments "<message> <commit>", where <commit>
# can be a tag pointing to the commit-to-merge.

test_merge () {
	test_tick &&
	git merge -m "$1" "$2" &&
	git tag "$1"
}

# This function helps systems where core.filemode=false is set.
# Use it instead of plain 'chmod +x' to set or unset the executable bit
# of a file in the working directory and add it to the index.

test_chmod () {
	chmod "$@" &&
	git update-index --add "--chmod=$@"
}

# You are not expected to call test_ok_ and test_failure_ directly, use
# the text_expect_* functions instead.

test_ok_ () {
	test_success=$(($test_success + 1))
	say_color "" "  ok $test_count: $@"
}

test_failure_ () {
	test_failure=$(($test_failure + 1))
	say_color error "FAIL $test_count: $1"
	shift
	echo "$@" | sed -e 's/^/	/'
	test "$immediate" = "" || { trap - EXIT; exit 1; }
}

test_known_broken_ok_ () {
	test_fixed=$(($test_fixed+1))
	say_color "" "  FIXED $test_count: $@"
}

test_known_broken_failure_ () {
	test_broken=$(($test_broken+1))
	say_color skip "  still broken $test_count: $@"
}

test_debug () {
	test "$debug" = "" || eval "$1"
}

test_run_ () {
	eval >&3 2>&4 "$1"
	eval_ret="$?"
	return 0
}

test_skip () {
	test_count=$(($test_count+1))
	to_skip=
	for skp in $GIT_SKIP_TESTS
	do
		case $this_test.$test_count in
		$skp)
			to_skip=t
		esac
	done
	case "$to_skip" in
	t)
		say_color skip >&3 "skipping test: $@"
		say_color skip "skip $test_count: $1"
		: true
		;;
	*)
		false
		;;
	esac
}

test_expect_failure () {
	test "$#" = 2 ||
	error "bug in the test script: not 2 parameters to test-expect-failure"
	if ! test_skip "$@"
	then
		say >&3 "checking known breakage: $2"
		test_run_ "$2"
		if [ "$?" = 0 -a "$eval_ret" = 0 ]
		then
			test_known_broken_ok_ "$1"
		else
		    test_known_broken_failure_ "$1"
		fi
	fi
	echo >&3 ""
}

test_expect_success () {
	test "$#" = 2 ||
	error "bug in the test script: not 2 parameters to test-expect-success"
	if ! test_skip "$@"
	then
		say >&3 "expecting success: $2"
		test_run_ "$2"
		if [ "$?" = 0 -a "$eval_ret" = 0 ]
		then
			test_ok_ "$1"
		else
			test_failure_ "$@"
		fi
	fi
	echo >&3 ""
}

test_expect_code () {
	test "$#" = 3 ||
	error "bug in the test script: not 3 parameters to test-expect-code"
	if ! test_skip "$@"
	then
		say >&3 "expecting exit code $1: $3"
		test_run_ "$3"
		if [ "$?" = 0 -a "$eval_ret" = "$1" ]
		then
			test_ok_ "$2"
		else
			test_failure_ "$@"
		fi
	fi
	echo >&3 ""
}

# test_external runs external test scripts that provide continuous
# test output about their progress, and succeeds/fails on
# zero/non-zero exit code.  It outputs the test output on stdout even
# in non-verbose mode, and announces the external script with "* run
# <n>: ..." before running it.  When providing relative paths, keep in
# mind that all scripts run in "trash directory".
# Usage: test_external description command arguments...
# Example: test_external 'Perl API' perl ../path/to/test.pl
test_external () {
	test "$#" -eq 3 ||
	error >&5 "bug in the test script: not 3 parameters to test_external"
	descr="$1"
	shift
	if ! test_skip "$descr" "$@"
	then
		# Announce the script to reduce confusion about the
		# test output that follows.
		say_color "" " run $test_count: $descr ($*)"
		# Run command; redirect its stderr to &4 as in
		# test_run_, but keep its stdout on our stdout even in
		# non-verbose mode.
		"$@" 2>&4
		if [ "$?" = 0 ]
		then
			test_ok_ "$descr"
		else
			test_failure_ "$descr" "$@"
		fi
	fi
}

# Like test_external, but in addition tests that the command generated
# no output on stderr.
test_external_without_stderr () {
	# The temporary file has no (and must have no) security
	# implications.
	tmp="$TMPDIR"; if [ -z "$tmp" ]; then tmp=/tmp; fi
	stderr="$tmp/git-external-stderr.$$.tmp"
	test_external "$@" 4> "$stderr"
	[ -f "$stderr" ] || error "Internal error: $stderr disappeared."
	descr="no stderr: $1"
	shift
	say >&3 "expecting no stderr from previous command"
	if [ ! -s "$stderr" ]; then
		rm "$stderr"
		test_ok_ "$descr"
	else
		if [ "$verbose" = t ]; then
			output=`echo; echo Stderr is:; cat "$stderr"`
		else
			output=
		fi
		# rm first in case test_failure exits.
		rm "$stderr"
		test_failure_ "$descr" "$@" "$output"
	fi
}

# This is not among top-level (test_expect_success | test_expect_failure)
# but is a prefix that can be used in the test script, like:
#
#	test_expect_success 'complain and die' '
#           do something &&
#           do something else &&
#	    test_must_fail git checkout ../outerspace
#	'
#
# Writing this as "! git checkout ../outerspace" is wrong, because
# the failure could be due to a segv.  We want a controlled failure.

test_must_fail () {
	"$@"
	test $? -gt 0 -a $? -le 129 -o $? -gt 192
}

# test_cmp is a helper function to compare actual and expected output.
# You can use it like:
#
#	test_expect_success 'foo works' '
#		echo expected >expected &&
#		foo >actual &&
#		test_cmp expected actual
#	'
#
# This could be written as either "cmp" or "diff -u", but:
# - cmp's output is not nearly as easy to read as diff -u
# - not all diff versions understand "-u"

test_cmp() {
	$GIT_TEST_CMP "$@"
}

# Most tests can use the created repository, but some may need to create more.
# Usage: test_create_repo <directory>
test_create_repo () {
	test "$#" = 1 ||
	error "bug in the test script: not 1 parameter to test-create-repo"
	owd=`pwd`
	repo="$1"
	mkdir -p "$repo"
	cd "$repo" || error "Cannot setup test environment"
	"$GIT_EXEC_PATH/git" init "--template=$owd/../templates/blt/" >&3 2>&4 ||
	error "cannot run git init -- have you built things yet?"
	mv .git/hooks .git/hooks-disabled
	cd "$owd"
}

test_done () {
	trap - EXIT
	test_results_dir="$TEST_DIRECTORY/test-results"
	mkdir -p "$test_results_dir"
	test_results_path="$test_results_dir/${0%.sh}-$$"

	echo "total $test_count" >> $test_results_path
	echo "success $test_success" >> $test_results_path
	echo "fixed $test_fixed" >> $test_results_path
	echo "broken $test_broken" >> $test_results_path
	echo "failed $test_failure" >> $test_results_path
	echo "" >> $test_results_path

	if test "$test_fixed" != 0
	then
		say_color pass "fixed $test_fixed known breakage(s)"
	fi
	if test "$test_broken" != 0
	then
		say_color error "still have $test_broken known breakage(s)"
		msg="remaining $(($test_count-$test_broken)) test(s)"
	else
		msg="$test_count test(s)"
	fi
	case "$test_failure" in
	0)
		# We could:
		# cd .. && rm -fr 'trash directory'
		# but that means we forbid any tests that use their own
		# subdirectory from calling test_done without coming back
		# to where they started from.
		# The Makefile provided will clean this test area so
		# we will leave things as they are.

		say_color pass "passed all $msg"

		test -d "$remove_trash" &&
		cd "$(dirname "$remove_trash")" &&
		rm -rf "$(basename "$remove_trash")"

		exit 0 ;;

	*)
		say_color error "failed $test_failure among $msg"
		exit 1 ;;

	esac
}

# Test the binaries we have just built.  The tests are kept in
# t/ subdirectory and are run in 'trash directory' subdirectory.
TEST_DIRECTORY=$(pwd)
if test -z "$valgrind"
then
	PATH=$TEST_DIRECTORY/..:$PATH
	GIT_EXEC_PATH=$TEST_DIRECTORY/..
else
	make_symlink () {
		test -h "$2" &&
		test "$1" = "$(readlink "$2")" || {
			# be super paranoid
			if mkdir "$2".lock
			then
				rm -f "$2" &&
				ln -s "$1" "$2" &&
				rm -r "$2".lock
			else
				while test -d "$2".lock
				do
					say "Waiting for lock on $2."
					sleep 1
				done
			fi
		}
	}

	make_valgrind_symlink () {
		# handle only executables
		test -x "$1" || return

		base=$(basename "$1")
		symlink_target=$TEST_DIRECTORY/../$base
		# do not override scripts
		if test -x "$symlink_target" &&
		    test ! -d "$symlink_target" &&
		    test "#!" != "$(head -c 2 < "$symlink_target")"
		then
			symlink_target=../valgrind.sh
		fi
		case "$base" in
		*.sh|*.perl)
			symlink_target=../unprocessed-script
		esac
		# create the link, or replace it if it is out of date
		make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit
	}

	# override all git executables in TEST_DIRECTORY/..
	GIT_VALGRIND=$TEST_DIRECTORY/valgrind
	mkdir -p "$GIT_VALGRIND"/bin
	for file in $TEST_DIRECTORY/../git* $TEST_DIRECTORY/../test-*
	do
		make_valgrind_symlink $file
	done
	OLDIFS=$IFS
	IFS=:
	for path in $PATH
	do
		ls "$path"/git-* 2> /dev/null |
		while read file
		do
			make_valgrind_symlink "$file"
		done
	done
	IFS=$OLDIFS
	PATH=$GIT_VALGRIND/bin:$PATH
	GIT_EXEC_PATH=$GIT_VALGRIND/bin
	export GIT_VALGRIND
fi
GIT_TEMPLATE_DIR=$(pwd)/../templates/blt
unset GIT_CONFIG
GIT_CONFIG_NOSYSTEM=1
GIT_CONFIG_NOGLOBAL=1
export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_CONFIG_NOGLOBAL

GITPERLLIB=$(pwd)/../perl/blib/lib:$(pwd)/../perl/blib/arch/auto/Git
export GITPERLLIB
test -d ../templates/blt || {
	error "You haven't built things yet, have you?"
}

if ! test -x ../test-chmtime; then
	echo >&2 'You need to build test-chmtime:'
	echo >&2 'Run "make test-chmtime" in the source (toplevel) directory'
	exit 1
fi

. ../GIT-BUILD-OPTIONS

# Test repository
test="trash directory.$(basename "$0" .sh)"
test ! -z "$debug" || remove_trash="$TEST_DIRECTORY/$test"
rm -fr "$test" || {
	trap - EXIT
	echo >&5 "FATAL: Cannot prepare test area"
	exit 1
}

test_create_repo "$test"
# Use -P to resolve symlinks in our working directory so that the cwd
# in subprocesses like git equals our $PWD (for pathname comparisons).
cd -P "$test" || exit 1

this_test=${0##*/}
this_test=${this_test%%-*}
for skp in $GIT_SKIP_TESTS
do
	to_skip=
	for skp in $GIT_SKIP_TESTS
	do
		case "$this_test" in
		$skp)
			to_skip=t
		esac
	done
	case "$to_skip" in
	t)
		say_color skip >&3 "skipping test $this_test altogether"
		say_color skip "skip all tests in $this_test"
		test_done
	esac
done

# Fix some commands on Windows
case $(uname -s) in
*MINGW*)
	# Windows has its own (incompatible) sort and find
	sort () {
		/usr/bin/sort "$@"
	}
	find () {
		/usr/bin/find "$@"
	}
	sum () {
		md5sum "$@"
	}
	;;
esac
Commit	Line	Data
e1970ce4 JH	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2005 Junio C Hamano
	4	#
	5
44138559 JS	6	# if --tee was passed, write the output not only to the terminal, but
	7	# additionally to the file test-results/$BASENAME.out, too.
	8	case "$GIT_TEST_TEE_STARTED, $* " in
	9	done,*)
	10	# do not redirect again
	11	;;
3da93652	12	' --tee '\|' --va')
44138559 JS	13	mkdir -p test-results
	14	BASE=test-results/$(basename "$0" .sh)
	15	(GIT_TEST_TEE_STARTED=done ${SHELL-sh} "$0" "$@" 2>&1;
	16	echo $? > $BASE.exit) \| tee $BASE.out
	17	test "$(cat $BASE.exit)" = 0
	18	exit
	19	;;
	20	esac
	21
c2116a17 JH	22	# Keep the original TERM for say_color
	23	ORIGINAL_TERM=$TERM
	24
e1970ce4 JH	25	# For repeatability, reset the environment to known value.
e1970ce4 JH	26	LANG=C
899460f3	27	LC_ALL=C
d9bdd39e	28	PAGER=cat
e1970ce4	29	TZ=UTC
c2116a17 JH	30	TERM=dumb
c2116a17 JH	31	export LANG LC_ALL PAGER TERM TZ
8ff99e74 EW	32	EDITOR=:
8ff99e74 EW	33	VISUAL=:
18508c39	34	unset GIT_EDITOR
e1970ce4 JH	35	unset AUTHOR_DATE
	36	unset AUTHOR_EMAIL
	37	unset AUTHOR_NAME
	38	unset COMMIT_AUTHOR_EMAIL
	39	unset COMMIT_AUTHOR_NAME
28a94f88	40	unset EMAIL
e1970ce4 JH	41	unset GIT_ALTERNATE_OBJECT_DIRECTORIES
e1970ce4 JH	42	unset GIT_AUTHOR_DATE
29e55cd5 JH	43	GIT_AUTHOR_EMAIL=author@example.com
29e55cd5 JH	44	GIT_AUTHOR_NAME='A U Thor'
6677c466	45	unset GIT_COMMITTER_DATE
29e55cd5 JH	46	GIT_COMMITTER_EMAIL=committer@example.com
29e55cd5 JH	47	GIT_COMMITTER_NAME='C O Mitter'
e1970ce4 JH	48	unset GIT_DIFF_OPTS
e1970ce4 JH	49	unset GIT_DIR
892c41b9	50	unset GIT_WORK_TREE
e1970ce4 JH	51	unset GIT_EXTERNAL_DIFF
	52	unset GIT_INDEX_FILE
	53	unset GIT_OBJECT_DIRECTORY
0454dd93	54	unset GIT_CEILING_DIRECTORIES
e1970ce4 JH	55	unset SHA1_FILE_DIRECTORIES
e1970ce4 JH	56	unset SHA1_FILE_DIRECTORY
8d0fc48f SP	57	GIT_MERGE_VERBOSITY=5
8d0fc48f SP	58	export GIT_MERGE_VERBOSITY
29e55cd5 JH	59	export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME
29e55cd5 JH	60	export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME
8ff99e74	61	export EDITOR VISUAL
82ebb0b6	62	GIT_TEST_CMP=${GIT_TEST_CMP:-diff -u}
e1970ce4	63
886a3907 JH	64	# Protect ourselves from common misconfiguration to export
	65	# CDPATH into the environment
	66	unset CDPATH
	67
3d5c0cc9	68	case $(echo $GIT_TRACE \|tr "[A-Z]" "[a-z]") in
6ce4e61f CC	69	1\|2\|true)
	70	echo "* warning: Some tests will not work if GIT_TRACE" \
	71	"is set as to trace on STDERR ! *"
	72	echo "* warning: Please set GIT_TRACE to something" \
	73	"other than 1, 2 or true ! *"
	74	;;
	75	esac
	76
e1970ce4 JH	77	# Each test should start with something like this, after copyright notices:
	78	#
	79	# test_description='Description of this test...
	80	# This test checks if command xyzzy does the right thing...
	81	# '
	82	# . ./test-lib.sh
c2116a17 JH	83	[ "x$ORIGINAL_TERM" != "xdumb" ] && (
	84	TERM=$ORIGINAL_TERM &&
	85	export TERM &&
	86	[ -t 1 ] &&
	87	tput bold >/dev/null 2>&1 &&
	88	tput setaf 1 >/dev/null 2>&1 &&
	89	tput sgr0 >/dev/null 2>&1
	90	) &&
55db1df0	91	color=t
e1970ce4	92
e1970ce4 JH	93	while test "$#" -ne 0
	94	do
	95	case "$1" in
	96	-d\|--d\|--de\|--deb\|--debu\|--debug)
	97	debug=t; shift ;;
886856ab JH	98	-i\|--i\|--im\|--imm\|--imme\|--immed\|--immedi\|--immedia\|--immediat\|--immediate)
886856ab JH	99	immediate=t; shift ;;
5e2c08c6	100	-l\|--l\|--lo\|--lon\|--long\|--long-\|--long-t\|--long-te\|--long-tes\|--long-test\|--long-tests)
91e80b98	101	GIT_TEST_LONG=t; export GIT_TEST_LONG; shift ;;
e1970ce4	102	-h\|--h\|--he\|--hel\|--help)
570f3226	103	help=t; shift ;;
e1970ce4 JH	104	-v\|--v\|--ve\|--ver\|--verb\|--verbo\|--verbos\|--verbose)
e1970ce4 JH	105	verbose=t; shift ;;
1ece1274 PH	106	-q\|--q\|--qu\|--qui\|--quie\|--quiet)
1ece1274 PH	107	quiet=t; shift ;;
55db1df0	108	--no-color)
faa4bc35	109	color=; shift ;;
abb7c7b3	110	--no-python)
7cdbff14 JH	111	# noop now...
7cdbff14 JH	112	shift ;;
4e1be63c	113	--va\|--val\|--valg\|--valgr\|--valgri\|--valgrin\|--valgrind)
3da93652	114	valgrind=t; verbose=t; shift ;;
44138559 JS	115	--tee)
44138559 JS	116	shift ;; # was handled already
e1970ce4 JH	117	*)
	118	break ;;
	119	esac
	120	done
	121
55db1df0 PH	122	if test -n "$color"; then
55db1df0 PH	123	say_color () {
c2116a17 JH	124	(
	125	TERM=$ORIGINAL_TERM
	126	export TERM
55db1df0 PH	127	case "$1" in
	128	error) tput bold; tput setaf 1;; # bold red
	129	skip) tput bold; tput setaf 2;; # bold green
	130	pass) tput setaf 2;; # green
	131	info) tput setaf 3;; # brown
1ece1274	132	*) test -n "$quiet" && return;;
55db1df0 PH	133	esac
55db1df0 PH	134	shift
72d404de	135	printf "* %s" "$*"
55db1df0	136	tput sgr0
b8eecafd	137	echo
c2116a17	138	)
55db1df0 PH	139	}
	140	else
	141	say_color() {
1ece1274	142	test -z "$1" && test -n "$quiet" && return
55db1df0 PH	143	shift
	144	echo "* $*"
	145	}
	146	fi
	147
	148	error () {
	149	say_color error "error: $*"
35641310	150	trap - EXIT
55db1df0 PH	151	exit 1
	152	}
	153
	154	say () {
	155	say_color info "$*"
	156	}
	157
570f3226 MB	158	test "${test_description}" != "" \|\|
	159	error "Test script did not set test_description."
	160
	161	if test "$help" = "t"
	162	then
	163	echo "$test_description"
	164	exit 0
	165	fi
	166
4d9d62fa	167	exec 5>&1
e1970ce4 JH	168	if test "$verbose" = "t"
	169	then
	170	exec 4>&2 3>&1
	171	else
	172	exec 4>/dev/null 3>/dev/null
	173	fi
	174
	175	test_failure=0
	176	test_count=0
41ac414e JH	177	test_fixed=0
41ac414e JH	178	test_broken=0
2d84e9fb	179	test_success=0
e1970ce4	180
faa4bc35 CB	181	die () {
	182	echo >&5 "FATAL: Unexpected exit with code $?"
	183	exit 1
	184	}
	185
35641310	186	trap 'die' EXIT
41184273	187
02b35660 BD	188	# The semantics of the editor variables are that of invoking
	189	# sh -c "$EDITOR \"$@\"" files ...
	190	#
	191	# If our trash directory contains shell metacharacters, they will be
	192	# interpreted if we just set $EDITOR directly, so do a little dance with
	193	# environment variables to work around this.
	194	#
	195	# In particular, quoting isn't enough, as the path may contain the same quote
7b7b4516	196	# that we're using.
02b35660 BD	197	test_set_editor () {
	198	FAKE_EDITOR="$1"
	199	export FAKE_EDITOR
	200	VISUAL='"$FAKE_EDITOR"'
	201	export VISUAL
	202	}
	203
04509738 JH	204	test_tick () {
	205	if test -z "${test_tick+set}"
	206	then
21afc41c	207	test_tick=1112911993
04509738 JH	208	else
	209	test_tick=$(($test_tick + 60))
	210	fi
21afc41c JH	211	GIT_COMMITTER_DATE="$test_tick -0700"
21afc41c JH	212	GIT_AUTHOR_DATE="$test_tick -0700"
04509738 JH	213	export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
04509738 JH	214	}
e1970ce4	215
00884968 JS	216	# Call test_commit with the arguments "<message> [<file> [<contents>]]"
	217	#
	218	# This will commit a file with the given contents and the given commit
	219	# message. It will also add a tag with <message> as name.
	220	#
	221	# Both <file> and <contents> default to <message>.
	222
	223	test_commit () {
e656fc97	224	file=${2:-"$1.t"}
00884968 JS	225	echo "${3-$1}" > "$file" &&
	226	git add "$file" &&
	227	test_tick &&
	228	git commit -m "$1" &&
	229	git tag "$1"
	230	}
	231
	232	# Call test_merge with the arguments "<message> <commit>", where <commit>
	233	# can be a tag pointing to the commit-to-merge.
	234
	235	test_merge () {
	236	test_tick &&
	237	git merge -m "$1" "$2" &&
	238	git tag "$1"
	239	}
	240
1f553918 JS	241	# This function helps systems where core.filemode=false is set.
	242	# Use it instead of plain 'chmod +x' to set or unset the executable bit
	243	# of a file in the working directory and add it to the index.
	244
	245	test_chmod () {
	246	chmod "$@" &&
	247	git update-index --add "--chmod=$@"
	248	}
	249
886856ab JH	250	# You are not expected to call test_ok_ and test_failure_ directly, use
	251	# the text_expect_* functions instead.
	252
	253	test_ok_ () {
d5d9de1b	254	test_success=$(($test_success + 1))
55db1df0	255	say_color "" " ok $test_count: $@"
e1970ce4 JH	256	}
e1970ce4 JH	257
886856ab	258	test_failure_ () {
d5d9de1b	259	test_failure=$(($test_failure + 1))
55db1df0	260	say_color error "FAIL $test_count: $1"
bf0dd8a8 JH	261	shift
bf0dd8a8 JH	262	echo "$@" \| sed -e 's/^/ /'
35641310	263	test "$immediate" = "" \|\| { trap - EXIT; exit 1; }
886856ab JH	264	}
886856ab JH	265
41ac414e	266	test_known_broken_ok_ () {
41ac414e JH	267	test_fixed=$(($test_fixed+1))
	268	say_color "" " FIXED $test_count: $@"
	269	}
	270
	271	test_known_broken_failure_ () {
41ac414e JH	272	test_broken=$(($test_broken+1))
	273	say_color skip " still broken $test_count: $@"
	274	}
886856ab JH	275
886856ab JH	276	test_debug () {
8e832ebc	277	test "$debug" = "" \|\| eval "$1"
e1970ce4 JH	278	}
e1970ce4 JH	279
4d9d62fa	280	test_run_ () {
4d9d62fa PR	281	eval >&3 2>&4 "$1"
4d9d62fa PR	282	eval_ret="$?"
4d9d62fa PR	283	return 0
	284	}
	285
04ece593	286	test_skip () {
8586f98b	287	test_count=$(($test_count+1))
04ece593 JH	288	to_skip=
	289	for skp in $GIT_SKIP_TESTS
	290	do
8586f98b	291	case $this_test.$test_count in
04ece593 JH	292	$skp)
	293	to_skip=t
	294	esac
	295	done
	296	case "$to_skip" in
	297	t)
55db1df0	298	say_color skip >&3 "skipping test: $@"
55db1df0	299	say_color skip "skip $test_count: $1"
04ece593 JH	300	: true
	301	;;
	302	*)
	303	false
	304	;;
	305	esac
	306	}
	307
e1970ce4	308	test_expect_failure () {
8e832ebc	309	test "$#" = 2 \|\|
e1970ce4	310	error "bug in the test script: not 2 parameters to test-expect-failure"
04ece593	311	if ! test_skip "$@"
e1970ce4	312	then
41ac414e	313	say >&3 "checking known breakage: $2"
04ece593	314	test_run_ "$2"
41ac414e	315	if [ "$?" = 0 -a "$eval_ret" = 0 ]
04ece593	316	then
41ac414e	317	test_known_broken_ok_ "$1"
04ece593	318	else
41ac414e	319	test_known_broken_failure_ "$1"
04ece593	320	fi
e1970ce4	321	fi
7a0cf2d0	322	echo >&3 ""
e1970ce4 JH	323	}
	324
	325	test_expect_success () {
8e832ebc	326	test "$#" = 2 \|\|
e1970ce4	327	error "bug in the test script: not 2 parameters to test-expect-success"
04ece593	328	if ! test_skip "$@"
e1970ce4	329	then
04ece593 JH	330	say >&3 "expecting success: $2"
	331	test_run_ "$2"
	332	if [ "$?" = 0 -a "$eval_ret" = 0 ]
	333	then
	334	test_ok_ "$1"
	335	else
	336	test_failure_ "$@"
	337	fi
e1970ce4	338	fi
7a0cf2d0	339	echo >&3 ""
e1970ce4 JH	340	}
e1970ce4 JH	341
d3bfdb75 FK	342	test_expect_code () {
	343	test "$#" = 3 \|\|
	344	error "bug in the test script: not 3 parameters to test-expect-code"
04ece593	345	if ! test_skip "$@"
d3bfdb75	346	then
04ece593 JH	347	say >&3 "expecting exit code $1: $3"
	348	test_run_ "$3"
	349	if [ "$?" = 0 -a "$eval_ret" = "$1" ]
	350	then
	351	test_ok_ "$2"
	352	else
	353	test_failure_ "$@"
	354	fi
d3bfdb75	355	fi
7a0cf2d0	356	echo >&3 ""
d3bfdb75 FK	357	}
d3bfdb75 FK	358
fb32c410 LW	359	# test_external runs external test scripts that provide continuous
	360	# test output about their progress, and succeeds/fails on
	361	# zero/non-zero exit code. It outputs the test output on stdout even
	362	# in non-verbose mode, and announces the external script with "* run
	363	# <n>: ..." before running it. When providing relative paths, keep in
	364	# mind that all scripts run in "trash directory".
	365	# Usage: test_external description command arguments...
	366	# Example: test_external 'Perl API' perl ../path/to/test.pl
	367	test_external () {
	368	test "$#" -eq 3 \|\|
	369	error >&5 "bug in the test script: not 3 parameters to test_external"
	370	descr="$1"
	371	shift
	372	if ! test_skip "$descr" "$@"
	373	then
	374	# Announce the script to reduce confusion about the
	375	# test output that follows.
8586f98b	376	say_color "" " run $test_count: $descr ($*)"
fb32c410 LW	377	# Run command; redirect its stderr to &4 as in
	378	# test_run_, but keep its stdout on our stdout even in
	379	# non-verbose mode.
	380	"$@" 2>&4
	381	if [ "$?" = 0 ]
	382	then
	383	test_ok_ "$descr"
	384	else
	385	test_failure_ "$descr" "$@"
	386	fi
	387	fi
	388	}
	389
	390	# Like test_external, but in addition tests that the command generated
	391	# no output on stderr.
	392	test_external_without_stderr () {
	393	# The temporary file has no (and must have no) security
	394	# implications.
	395	tmp="$TMPDIR"; if [ -z "$tmp" ]; then tmp=/tmp; fi
	396	stderr="$tmp/git-external-stderr.$$.tmp"
	397	test_external "$@" 4> "$stderr"
	398	[ -f "$stderr" ] \|\| error "Internal error: $stderr disappeared."
	399	descr="no stderr: $1"
	400	shift
	401	say >&3 "expecting no stderr from previous command"
	402	if [ ! -s "$stderr" ]; then
	403	rm "$stderr"
	404	test_ok_ "$descr"
	405	else
	406	if [ "$verbose" = t ]; then
	407	output=`echo; echo Stderr is:; cat "$stderr"`
	408	else
	409	output=
	410	fi
	411	# rm first in case test_failure exits.
	412	rm "$stderr"
	413	test_failure_ "$descr" "$@" "$output"
	414	fi
	415	}
	416
74359821 JH	417	# This is not among top-level (test_expect_success \| test_expect_failure)
	418	# but is a prefix that can be used in the test script, like:
	419	#
	420	# test_expect_success 'complain and die' '
	421	# do something &&
	422	# do something else &&
	423	# test_must_fail git checkout ../outerspace
	424	# '
	425	#
	426	# Writing this as "! git checkout ../outerspace" is wrong, because
	427	# the failure could be due to a segv. We want a controlled failure.
	428
	429	test_must_fail () {
	430	"$@"
5a269730	431	test $? -gt 0 -a $? -le 129 -o $? -gt 192
74359821 JH	432	}
74359821 JH	433
82ebb0b6 JK	434	# test_cmp is a helper function to compare actual and expected output.
	435	# You can use it like:
	436	#
	437	# test_expect_success 'foo works' '
	438	# echo expected >expected &&
	439	# foo >actual &&
	440	# test_cmp expected actual
	441	# '
	442	#
	443	# This could be written as either "cmp" or "diff -u", but:
	444	# - cmp's output is not nearly as easy to read as diff -u
	445	# - not all diff versions understand "-u"
	446
	447	test_cmp() {
	448	$GIT_TEST_CMP "$@"
	449	}
	450
0509eb21	451	# Most tests can use the created repository, but some may need to create more.
eedf8f97 CW	452	# Usage: test_create_repo <directory>
	453	test_create_repo () {
	454	test "$#" = 1 \|\|
	455	error "bug in the test script: not 1 parameter to test-create-repo"
	456	owd=`pwd`
	457	repo="$1"
bfdbee98	458	mkdir -p "$repo"
eedf8f97	459	cd "$repo" \|\| error "Cannot setup test environment"
a6d63b74	460	"$GIT_EXEC_PATH/git" init "--template=$owd/../templates/blt/" >&3 2>&4 \|\|
5c94f87e	461	error "cannot run git init -- have you built things yet?"
eedf8f97 CW	462	mv .git/hooks .git/hooks-disabled
	463	cd "$owd"
	464	}
a6080a0a	465
e1970ce4	466	test_done () {
35641310	467	trap - EXIT
2d84e9fb SR	468	test_results_dir="$TEST_DIRECTORY/test-results"
2d84e9fb SR	469	mkdir -p "$test_results_dir"
bba2a7b2	470	test_results_path="$test_results_dir/${0%.sh}-$$"
2d84e9fb SR	471
	472	echo "total $test_count" >> $test_results_path
	473	echo "success $test_success" >> $test_results_path
	474	echo "fixed $test_fixed" >> $test_results_path
	475	echo "broken $test_broken" >> $test_results_path
	476	echo "failed $test_failure" >> $test_results_path
	477	echo "" >> $test_results_path
41ac414e JH	478
	479	if test "$test_fixed" != 0
	480	then
	481	say_color pass "fixed $test_fixed known breakage(s)"
	482	fi
	483	if test "$test_broken" != 0
	484	then
	485	say_color error "still have $test_broken known breakage(s)"
11d54b8b JH	486	msg="remaining $(($test_count-$test_broken)) test(s)"
	487	else
	488	msg="$test_count test(s)"
41ac414e	489	fi
e1970ce4	490	case "$test_failure" in
10b94e28	491	0)
e1970ce4	492	# We could:
9231e3a9	493	# cd .. && rm -fr 'trash directory'
e1970ce4 JH	494	# but that means we forbid any tests that use their own
	495	# subdirectory from calling test_done without coming back
	496	# to where they started from.
	497	# The Makefile provided will clean this test area so
	498	# we will leave things as they are.
	499
11d54b8b	500	say_color pass "passed all $msg"
abc5d372 JS	501
	502	test -d "$remove_trash" &&
	503	cd "$(dirname "$remove_trash")" &&
	504	rm -rf "$(basename "$remove_trash")"
	505
e1970ce4 JH	506	exit 0 ;;
	507
	508	*)
11d54b8b	509	say_color error "failed $test_failure among $msg"
e1970ce4 JH	510	exit 1 ;;
	511
	512	esac
	513	}
	514
	515	# Test the binaries we have just built. The tests are kept in
9adefee5	516	# t/ subdirectory and are run in 'trash directory' subdirectory.
2d84e9fb	517	TEST_DIRECTORY=$(pwd)
4e1be63c JS	518	if test -z "$valgrind"
	519	then
	520	PATH=$TEST_DIRECTORY/..:$PATH
	521	GIT_EXEC_PATH=$TEST_DIRECTORY/..
	522	else
	523	make_symlink () {
	524	test -h "$2" &&
	525	test "$1" = "$(readlink "$2")" \|\| {
	526	# be super paranoid
	527	if mkdir "$2".lock
	528	then
	529	rm -f "$2" &&
	530	ln -s "$1" "$2" &&
	531	rm -r "$2".lock
	532	else
	533	while test -d "$2".lock
	534	do
	535	say "Waiting for lock on $2."
	536	sleep 1
	537	done
	538	fi
	539	}
	540	}
	541
	542	make_valgrind_symlink () {
	543	# handle only executables
	544	test -x "$1" \|\| return
	545
	546	base=$(basename "$1")
	547	symlink_target=$TEST_DIRECTORY/../$base
	548	# do not override scripts
	549	if test -x "$symlink_target" &&
	550	test ! -d "$symlink_target" &&
	551	test "#!" != "$(head -c 2 < "$symlink_target")"
	552	then
	553	symlink_target=../valgrind.sh
	554	fi
efd92ffd JS	555	case "$base" in
	556	.sh\|.perl)
	557	symlink_target=../unprocessed-script
	558	esac
4e1be63c JS	559	# create the link, or replace it if it is out of date
	560	make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" \|\| exit
	561	}
	562
	563	# override all git executables in TEST_DIRECTORY/..
	564	GIT_VALGRIND=$TEST_DIRECTORY/valgrind
	565	mkdir -p "$GIT_VALGRIND"/bin
	566	for file in $TEST_DIRECTORY/../git* $TEST_DIRECTORY/../test-*
	567	do
	568	make_valgrind_symlink $file
	569	done
efd92ffd JS	570	OLDIFS=$IFS
	571	IFS=:
	572	for path in $PATH
	573	do
	574	ls "$path"/git-* 2> /dev/null \|
	575	while read file
	576	do
	577	make_valgrind_symlink "$file"
	578	done
	579	done
	580	IFS=$OLDIFS
4e1be63c JS	581	PATH=$GIT_VALGRIND/bin:$PATH
	582	GIT_EXEC_PATH=$GIT_VALGRIND/bin
	583	export GIT_VALGRIND
4e1be63c	584	fi
8683a45d	585	GIT_TEMPLATE_DIR=$(pwd)/../templates/blt
8bfa6bd6	586	unset GIT_CONFIG
8bfa6bd6 JK	587	GIT_CONFIG_NOSYSTEM=1
	588	GIT_CONFIG_NOGLOBAL=1
	589	export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_CONFIG_NOGLOBAL
49ccb087	590
6fcca938 PB	591	GITPERLLIB=$(pwd)/../perl/blib/lib:$(pwd)/../perl/blib/arch/auto/Git
6fcca938 PB	592	export GITPERLLIB
eea42069 JH	593	test -d ../templates/blt \|\| {
	594	error "You haven't built things yet, have you?"
	595	}
e1970ce4	596
56cf9806 EW	597	if ! test -x ../test-chmtime; then
	598	echo >&2 'You need to build test-chmtime:'
	599	echo >&2 'Run "make test-chmtime" in the source (toplevel) directory'
	600	exit 1
	601	fi
	602
7cf7f54a JK	603	. ../GIT-BUILD-OPTIONS
7cf7f54a JK	604
e1970ce4	605	# Test repository
abc5d372	606	test="trash directory.$(basename "$0" .sh)"
5a4a088a	607	test ! -z "$debug" \|\| remove_trash="$TEST_DIRECTORY/$test"
8d14ac94	608	rm -fr "$test" \|\| {
35641310	609	trap - EXIT
8d14ac94 JH	610	echo >&5 "FATAL: Cannot prepare test area"
	611	exit 1
	612	}
	613
4a7aaccd	614	test_create_repo "$test"
1bd9c648 LW	615	# Use -P to resolve symlinks in our working directory so that the cwd
	616	# in subprocesses like git equals our $PWD (for pathname comparisons).
	617	cd -P "$test" \|\| exit 1
04ece593	618
d5d9de1b JS	619	this_test=${0##*/}
d5d9de1b JS	620	this_test=${this_test%%-*}
04ece593 JH	621	for skp in $GIT_SKIP_TESTS
	622	do
	623	to_skip=
	624	for skp in $GIT_SKIP_TESTS
	625	do
	626	case "$this_test" in
	627	$skp)
	628	to_skip=t
	629	esac
	630	done
	631	case "$to_skip" in
	632	t)
55db1df0 PH	633	say_color skip >&3 "skipping test $this_test altogether"
55db1df0 PH	634	say_color skip "skip all tests in $this_test"
04ece593 JH	635	test_done
	636	esac
	637	done
f17e9fbb JS	638
	639	# Fix some commands on Windows
	640	case $(uname -s) in
	641	MINGW)
	642	# Windows has its own (incompatible) sort and find
	643	sort () {
	644	/usr/bin/sort "$@"
	645	}
	646	find () {
	647	/usr/bin/find "$@"
	648	}
5397ea31 JS	649	sum () {
	650	md5sum "$@"
	651	}
f17e9fbb JS	652	;;
f17e9fbb JS	653	esac