# Test framework for git. See t/README for usage.

#

# Copyright (c) 2005 Junio C Hamano

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program. If not, see http://www.gnu.org/licenses/ .

# Test the binaries we have just built. The tests are kept in

# t/ subdirectory and are run in 'trash directory' subdirectory.

if test -z "$TEST_DIRECTORY"

then

# ensure that TEST_DIRECTORY is an absolute path so that it

# is valid even if the current working directory is changed

TEST_DIRECTORY=$(pwd)

else

# The TEST_DIRECTORY will always be the path to the "t"

# directory in the git.git checkout. This is overridden by

# e.g. t/lib-subtest.sh, but only because its $(pwd) is

# different. Those tests still set "$TEST_DIRECTORY" to the

# same path.

#

# See use of "$GIT_BUILD_DIR" and "$TEST_DIRECTORY" below for

# hard assumptions about "$GIT_BUILD_DIR/t" existing and being

# the "$TEST_DIRECTORY", and e.g. "$TEST_DIRECTORY/helper"

# needing to exist.

TEST_DIRECTORY=$(cd "$TEST_DIRECTORY" && pwd) || exit 1

fi

if test -z "$TEST_OUTPUT_DIRECTORY"

then

# Similarly, override this to store the test-results subdir

# elsewhere

TEST_OUTPUT_DIRECTORY=$TEST_DIRECTORY

fi

GIT_BUILD_DIR="${TEST_DIRECTORY%/t}"

if test "$TEST_DIRECTORY" = "$GIT_BUILD_DIR"

then

echo "PANIC: Running in a $TEST_DIRECTORY that doesn't end in '/t'?" >&2

exit 1

fi

if test -f "$GIT_BUILD_DIR/GIT-BUILD-DIR"

then

GIT_BUILD_DIR="$(cat "$GIT_BUILD_DIR/GIT-BUILD-DIR")" || exit 1

# On Windows, we must convert Windows paths lest they contain a colon

case "$(uname -s)" in

*MINGW*)

GIT_BUILD_DIR="$(cygpath -au "$GIT_BUILD_DIR")"

;;

esac

fi

# Prepend a string to a VAR using an arbitrary ":" delimiter, not

# adding the delimiter if VAR or VALUE is empty. I.e. a generalized:

#

# VAR=$1${VAR:+${1:+$2}$VAR}

#

# Usage (using ":" as the $2 delimiter):

#

# prepend_var VAR : VALUE

prepend_var () {

eval "$1=\"$3\${$1:+${3:+$2}\$$1}\""

}

# If [AL]SAN is in effect we want to abort so that we notice

# problems. The GIT_SAN_OPTIONS variable can be used to set common

# defaults shared between [AL]SAN_OPTIONS.

prepend_var GIT_SAN_OPTIONS : abort_on_error=1

prepend_var GIT_SAN_OPTIONS : strip_path_prefix="$GIT_BUILD_DIR/"

# If we were built with ASAN, it may complain about leaks

# of program-lifetime variables. Disable it by default to lower

# the noise level. This needs to happen at the start of the script,

# before we even do our "did we build git yet" check (since we don't

# want that one to complain to stderr).

prepend_var ASAN_OPTIONS : $GIT_SAN_OPTIONS

prepend_var ASAN_OPTIONS : detect_leaks=0

export ASAN_OPTIONS

prepend_var LSAN_OPTIONS : $GIT_SAN_OPTIONS

prepend_var LSAN_OPTIONS : fast_unwind_on_malloc=0

export LSAN_OPTIONS

prepend_var UBSAN_OPTIONS : $GIT_SAN_OPTIONS

export UBSAN_OPTIONS

if test ! -f "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS

then

echo >&2 'error: GIT-BUILD-OPTIONS missing (has Git been built?).'

exit 1

fi

. "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS

export PERL_PATH SHELL_PATH

# In t0000, we need to override test directories of nested testcases. In case

# the developer has TEST_OUTPUT_DIRECTORY part of his build options, then we'd

# reset this value to instead contain what the developer has specified. We thus

# have this knob to allow overriding the directory.

if test -n "${TEST_OUTPUT_DIRECTORY_OVERRIDE}"

then

TEST_OUTPUT_DIRECTORY="${TEST_OUTPUT_DIRECTORY_OVERRIDE}"

fi

# Disallow the use of abbreviated options in the test suite by default

if test -z "${GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS}"

then

GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS=true

export GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS

fi

# Explicitly set the default branch name for testing, to avoid the

# transitory "git init" warning under --verbose.

: ${GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME:=master}

export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME

################################################################

# It appears that people try to run tests without building...

"${GIT_TEST_INSTALLED:-$GIT_BUILD_DIR}/git$X" >/dev/null

if test $? != 1

then

if test -n "$GIT_TEST_INSTALLED"

then

echo >&2 "error: there is no working Git at '$GIT_TEST_INSTALLED'"

else

echo >&2 'error: you do not seem to have built git yet.'

fi

exit 1

fi

store_arg_to=

opt_required_arg=

# $1: option string

# $2: name of the var where the arg will be stored

mark_option_requires_arg () {

if test -n "$opt_required_arg"

then

echo "error: options that require args cannot be bundled" \

"together: '$opt_required_arg' and '$1'" >&2

exit 1

fi

opt_required_arg=$1

store_arg_to=$2

}

# These functions can be overridden e.g. to output JUnit XML

start_test_output () { :; }

start_test_case_output () { :; }

finalize_test_case_output () { :; }

finalize_test_output () { :; }

parse_option () {

local opt="$1"

case "$opt" in

-d|--d|--de|--deb|--debu|--debug)

debug=t ;;

-i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate)

immediate=t ;;

-l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests)

GIT_TEST_LONG=t; export GIT_TEST_LONG ;;

-r)

mark_option_requires_arg "$opt" run_list

;;

--run=*)

run_list=${opt#--*=} ;;

-h|--h|--he|--hel|--help)

help=t ;;

-v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose)

verbose=t ;;

--verbose-only=*)

verbose_only=${opt#--*=}

;;

-q|--q|--qu|--qui|--quie|--quiet)

# Ignore --quiet under a TAP::Harness. Saying how many tests

# passed without the ok/not ok details is always an error.

test -z "$HARNESS_ACTIVE" && quiet=t ;;

--with-dashes)

with_dashes=t ;;

--no-bin-wrappers)

no_bin_wrappers=t ;;

--no-color)

color= ;;

--va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind)

valgrind=memcheck

tee=t

;;

--valgrind=*)

valgrind=${opt#--*=}

tee=t

;;

--valgrind-only=*)

valgrind_only=${opt#--*=}

tee=t

;;

--tee)

tee=t ;;

--root=*)

root=${opt#--*=} ;;

--chain-lint)

GIT_TEST_CHAIN_LINT=1 ;;

--no-chain-lint)

GIT_TEST_CHAIN_LINT=0 ;;

-x)

trace=t ;;

-V|--verbose-log)

verbose_log=t

tee=t

;;

--write-junit-xml)

. "$TEST_DIRECTORY/test-lib-junit.sh"

;;

--github-workflow-markup)

. "$TEST_DIRECTORY/test-lib-github-workflow-markup.sh"

;;

--stress)

stress=t ;;

--stress=*)

echo "error: --stress does not accept an argument: '$opt'" >&2

echo "did you mean --stress-jobs=${opt#*=} or --stress-limit=${opt#*=}?" >&2

exit 1

;;

--stress-jobs=*)

stress=t;

stress_jobs=${opt#--*=}

case "$stress_jobs" in

*[!0-9]*|0*|"")

echo "error: --stress-jobs=<N> requires the number of jobs to run" >&2

exit 1

;;

*) # Good.

;;

esac

;;

--stress-limit=*)

stress=t;

stress_limit=${opt#--*=}

case "$stress_limit" in

*[!0-9]*|0*|"")

echo "error: --stress-limit=<N> requires the number of repetitions" >&2

exit 1

;;

*) # Good.

;;

esac

;;

--invert-exit-code)

invert_exit_code=t

;;

*)

echo "error: unknown test option '$opt'" >&2; exit 1 ;;

esac

}

# Parse options while taking care to leave $@ intact, so we will still

# have all the original command line options when executing the test

# script again for '--tee' and '--verbose-log' later.

for opt

do

if test -n "$store_arg_to"

then

eval $store_arg_to=\$opt

store_arg_to=

opt_required_arg=

continue

fi

case "$opt" in

--*|-?)

parse_option "$opt" ;;

-?*)

# bundled short options must be fed separately to parse_option

opt=${opt#-}

while test -n "$opt"

do

extra=${opt#?}

this=${opt%$extra}

opt=$extra

parse_option "-$this"

done

;;

*)

echo "error: unknown test option '$opt'" >&2; exit 1 ;;

esac

done

if test -n "$store_arg_to"

then

echo "error: $opt_required_arg requires an argument" >&2

exit 1

fi

if test -n "$valgrind_only"

then

test -z "$valgrind" && valgrind=memcheck

test -z "$verbose" && verbose_only="$valgrind_only"

elif test -n "$valgrind"

then

test -z "$verbose_log" && verbose=t

fi

if test -n "$stress"

then

verbose=t

trace=t

immediate=t

fi

TEST_STRESS_JOB_SFX="${GIT_TEST_STRESS_JOB_NR:+.stress-$GIT_TEST_STRESS_JOB_NR}"

TEST_NAME="$(basename "$0" .sh)"

TEST_NUMBER="${TEST_NAME%%-*}"

TEST_NUMBER="${TEST_NUMBER#t}"

TEST_RESULTS_DIR="$TEST_OUTPUT_DIRECTORY/test-results"

TEST_RESULTS_BASE="$TEST_RESULTS_DIR/$TEST_NAME$TEST_STRESS_JOB_SFX"

TEST_RESULTS_SAN_FILE_PFX=trace

TEST_RESULTS_SAN_DIR_SFX=leak

TEST_RESULTS_SAN_FILE=

TEST_RESULTS_SAN_DIR="$TEST_RESULTS_DIR/$TEST_NAME.$TEST_RESULTS_SAN_DIR_SFX"

TEST_RESULTS_SAN_DIR_NR_LEAKS_STARTUP=

TRASH_DIRECTORY="trash directory.$TEST_NAME$TEST_STRESS_JOB_SFX"

test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY"

case "$TRASH_DIRECTORY" in

/*) ;; # absolute path is good

*) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;;

esac

# Utility functions using $TEST_RESULTS_* variables

nr_san_dir_leaks_ () {

# stderr piped to /dev/null because the directory may have

# been "rmdir"'d already.

find "$TEST_RESULTS_SAN_DIR" \

-type f \

-name "$TEST_RESULTS_SAN_FILE_PFX.*" 2>/dev/null |

xargs grep -lv "Unable to get registers from thread" |

wc -l

}

# If --stress was passed, run this test repeatedly in several parallel loops.

if test "$GIT_TEST_STRESS_STARTED" = "done"

then

: # Don't stress test again.

elif test -n "$stress"

then

if test -n "$stress_jobs"

then

job_count=$stress_jobs

elif test -n "$GIT_TEST_STRESS_LOAD"

then

job_count="$GIT_TEST_STRESS_LOAD"

elif job_count=$(getconf _NPROCESSORS_ONLN 2>/dev/null) &&

test -n "$job_count"

then

job_count=$((2 * $job_count))

else

job_count=8

fi

mkdir -p "$TEST_RESULTS_DIR"

stressfail="$TEST_RESULTS_BASE.stress-failed"

rm -f "$stressfail"

stress_exit=0

trap '

kill $job_pids 2>/dev/null

wait

stress_exit=1

' TERM INT HUP

job_pids=

job_nr=0

while test $job_nr -lt "$job_count"

do

(

GIT_TEST_STRESS_STARTED=done

GIT_TEST_STRESS_JOB_NR=$job_nr

export GIT_TEST_STRESS_STARTED GIT_TEST_STRESS_JOB_NR

trap '

kill $test_pid 2>/dev/null

wait

exit 1

' TERM INT

cnt=1

while ! test -e "$stressfail" &&

{ test -z "$stress_limit" ||

test $cnt -le $stress_limit ; }

do

$TEST_SHELL_PATH "$0" "$@" >"$TEST_RESULTS_BASE.stress-$job_nr.out" 2>&1 &

test_pid=$!

if wait $test_pid

then

printf "OK %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt

else

echo $GIT_TEST_STRESS_JOB_NR >>"$stressfail"

printf "FAIL %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt

fi

cnt=$(($cnt + 1))

done

) &

job_pids="$job_pids $!"

job_nr=$(($job_nr + 1))

done

wait

if test -f "$stressfail"

then

stress_exit=1

echo "Log(s) of failed test run(s):"

for failed_job_nr in $(sort -n "$stressfail")

do

echo "Contents of '$TEST_RESULTS_BASE.stress-$failed_job_nr.out':"

cat "$TEST_RESULTS_BASE.stress-$failed_job_nr.out"

done

rm -rf "$TRASH_DIRECTORY.stress-failed"

# Move the last one.

mv "$TRASH_DIRECTORY.stress-$failed_job_nr" "$TRASH_DIRECTORY.stress-failed"

fi

exit $stress_exit

fi

# if --tee was passed, write the output not only to the terminal, but

# additionally to the file test-results/$BASENAME.out, too.

if test "$GIT_TEST_TEE_STARTED" = "done"

then

: # do not redirect again

elif test -n "$tee"

then

mkdir -p "$TEST_RESULTS_DIR"

# Make this filename available to the sub-process in case it is using

# --verbose-log.

GIT_TEST_TEE_OUTPUT_FILE=$TEST_RESULTS_BASE.out

export GIT_TEST_TEE_OUTPUT_FILE

# Truncate before calling "tee -a" to get rid of the results

# from any previous runs.

>"$GIT_TEST_TEE_OUTPUT_FILE"

(GIT_TEST_TEE_STARTED=done ${TEST_SHELL_PATH} "$0" "$@" 2>&1;

echo $? >"$TEST_RESULTS_BASE.exit") | tee -a "$GIT_TEST_TEE_OUTPUT_FILE"

test "$(cat "$TEST_RESULTS_BASE.exit")" = 0

exit

fi

if test -n "$trace" && test -n "$test_untraceable"

then

# '-x' tracing requested, but this test script can't be reliably

# traced, unless it is run with a Bash version supporting

# BASH_XTRACEFD (introduced in Bash v4.1).

#

# Perform this version check _after_ the test script was

# potentially re-executed with $TEST_SHELL_PATH for '--tee' or

# '--verbose-log', so the right shell is checked and the

# warning is issued only once.

if test -n "$BASH_VERSION" && eval '

test ${BASH_VERSINFO[0]} -gt 4 || {

test ${BASH_VERSINFO[0]} -eq 4 &&

test ${BASH_VERSINFO[1]} -ge 1

}

'

then

: Executed by a Bash version supporting BASH_XTRACEFD. Good.

else

echo >&2 "warning: ignoring -x; '$0' is untraceable without BASH_XTRACEFD"

trace=

fi

fi

if test -n "$trace" && test -z "$verbose_log"

then

verbose=t

fi

# Since bash 5.0, checkwinsize is enabled by default which does

# update the COLUMNS variable every time a non-builtin command

# completes, even for non-interactive shells.

# Disable that since we are aiming for repeatability.

test -n "$BASH_VERSION" && shopt -u checkwinsize 2>/dev/null

# For repeatability, reset the environment to known value.

# TERM is sanitized below, after saving color control sequences.

LANG=C

LC_ALL=C

PAGER=cat

TZ=UTC

COLUMNS=80

export LANG LC_ALL PAGER TZ COLUMNS

EDITOR=:

# A call to "unset" with no arguments causes at least Solaris 10

# /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 VISUAL EMAIL LANGUAGE $("$PERL_PATH" -e '

my @env = keys %ENV;

my $ok = join("|", qw(

TRACE

DEBUG

TEST

.*_TEST

PROVE

VALGRIND

UNZIP

PERF_

CURL_VERBOSE

TRACE_CURL

));

my @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env);

print join("\n", @vars);

')

unset XDG_CACHE_HOME

unset XDG_CONFIG_HOME

unset GITPERLLIB

unset GIT_TRACE2_PARENT_NAME

unset GIT_TRACE2_PARENT_SID

TEST_AUTHOR_LOCALNAME=author

TEST_AUTHOR_DOMAIN=example.com

GIT_AUTHOR_EMAIL=${TEST_AUTHOR_LOCALNAME}@${TEST_AUTHOR_DOMAIN}

GIT_AUTHOR_NAME='A U Thor'

GIT_AUTHOR_DATE='1112354055 +0200'

TEST_COMMITTER_LOCALNAME=committer

TEST_COMMITTER_DOMAIN=example.com

GIT_COMMITTER_EMAIL=${TEST_COMMITTER_LOCALNAME}@${TEST_COMMITTER_DOMAIN}

GIT_COMMITTER_NAME='C O Mitter'

GIT_COMMITTER_DATE='1112354055 +0200'

GIT_MERGE_VERBOSITY=5

GIT_MERGE_AUTOEDIT=no

export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT

export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME

export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME

export GIT_COMMITTER_DATE GIT_AUTHOR_DATE

export EDITOR

GIT_DEFAULT_HASH="${GIT_TEST_DEFAULT_HASH:-sha1}"

export GIT_DEFAULT_HASH

GIT_TEST_MERGE_ALGORITHM="${GIT_TEST_MERGE_ALGORITHM:-ort}"

export GIT_TEST_MERGE_ALGORITHM

# Tests using GIT_TRACE typically don't want <timestamp> <file>:<line> output

GIT_TRACE_BARE=1

export GIT_TRACE_BARE

# Some tests scan the GIT_TRACE2_EVENT feed for events, but the

# default depth is 2, which frequently causes issues when the

# events are wrapped in new regions. Set it to a sufficiently

# large depth to avoid custom changes in the test suite.

GIT_TRACE2_EVENT_NESTING=100

export GIT_TRACE2_EVENT_NESTING

# Use specific version of the index file format

if test -n "${GIT_TEST_INDEX_VERSION:+isset}"

then

GIT_INDEX_VERSION="$GIT_TEST_INDEX_VERSION"

export GIT_INDEX_VERSION

fi

if test -n "$GIT_TEST_PERL_FATAL_WARNINGS"

then

GIT_PERL_FATAL_WARNINGS=1

export GIT_PERL_FATAL_WARNINGS

fi

case $GIT_TEST_FSYNC in

'')

GIT_TEST_FSYNC=0

export GIT_TEST_FSYNC

;;

esac

# Add libc MALLOC and MALLOC_PERTURB test only if we are not executing

# the test with valgrind and have not compiled with conflict SANITIZE

# options.

if test -n "$valgrind" ||

test -n "$SANITIZE_ADDRESS" ||

test -n "$SANITIZE_LEAK" ||

test -n "$TEST_NO_MALLOC_CHECK"

then

setup_malloc_check () {

: nothing

}

teardown_malloc_check () {

: nothing

}

else

_USE_GLIBC_TUNABLES=

if _GLIBC_VERSION=$(getconf GNU_LIBC_VERSION 2>/dev/null) &&

_GLIBC_VERSION=${_GLIBC_VERSION#"glibc "} &&

expr 2.34 \<= "$_GLIBC_VERSION" >/dev/null

then

_USE_GLIBC_TUNABLES=YesPlease

fi

setup_malloc_check () {

local g

local t

MALLOC_CHECK_=3 MALLOC_PERTURB_=165

export MALLOC_CHECK_ MALLOC_PERTURB_

if test -n "$_USE_GLIBC_TUNABLES"

then

g=

LD_PRELOAD="libc_malloc_debug.so.0"

for t in \

glibc.malloc.check=1 \

glibc.malloc.perturb=165

do

g="${g#:}:$t"

done

GLIBC_TUNABLES=$g

export LD_PRELOAD GLIBC_TUNABLES

fi

}

teardown_malloc_check () {

unset MALLOC_CHECK_ MALLOC_PERTURB_

unset LD_PRELOAD GLIBC_TUNABLES

}

fi

# Protect ourselves from common misconfiguration to export

# CDPATH into the environment

unset CDPATH

unset GREP_OPTIONS

unset UNZIP

case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in

1|2|true)

GIT_TRACE=4

;;

esac

# Line feed

LF='

'

# Single quote

SQ=\'

# UTF-8 ZERO WIDTH NON-JOINER, which HFS+ ignores

# when case-folding filenames

u200c=$(printf '\342\200\214')

export _x05 _x35 LF u200c EMPTY_TREE EMPTY_BLOB ZERO_OID OID_REGEX

test "x$TERM" != "xdumb" && (

test -t 1 &&

tput bold >/dev/null 2>&1 &&

tput setaf 1 >/dev/null 2>&1 &&

tput sgr0 >/dev/null 2>&1

) &&

color=t

if test -n "$color"

then

# Save the color control sequences now rather than run tput

# each time say_color() is called. This is done for two

# reasons:

# * TERM will be changed to dumb

# * HOME will be changed to a temporary directory and tput

# might need to read ~/.terminfo from the original HOME

# directory to get the control sequences

# Note: This approach assumes the control sequences don't end

# in a newline for any terminal of interest (command

# substitutions strip trailing newlines). Given that most

# (all?) terminals in common use are related to ECMA-48, this

# shouldn't be a problem.

say_color_error=$(tput bold; tput setaf 1) # bold red

say_color_skip=$(tput setaf 4) # blue

say_color_warn=$(tput setaf 3) # brown/yellow

say_color_pass=$(tput setaf 2) # green

say_color_info=$(tput setaf 6) # cyan

say_color_reset=$(tput sgr0)

say_color_="" # no formatting for normal text

say_color () {

test -z "$1" && test -n "$quiet" && return

eval "say_color_color=\$say_color_$1"

shift

printf "%s\\n" "$say_color_color$*$say_color_reset"

}

else

say_color() {

test -z "$1" && test -n "$quiet" && return

shift

printf "%s\n" "$*"

}

fi

USER_TERM="$TERM"

TERM=dumb

export TERM USER_TERM

# What is written by tests to stdout and stderr is sent to different places

# depending on the test mode (e.g. /dev/null in non-verbose mode, piped to tee

# with --tee option, etc.). We save the original stdin to FD #6 and stdout and

# stderr to #5 and #7, so that the test framework can use them (e.g. for

# printing errors within the test framework) independently of the test mode.

exec 5>&1

exec 6<&0

exec 7>&2

_error_exit () {

finalize_test_output

GIT_EXIT_OK=t

exit 1

}

error () {

say_color error "error: $*"

_error_exit

}

BUG () {

error >&7 "bug in the test script: $*"

}

BAIL_OUT () {

test $# -ne 1 && BUG "1 param"

# Do not change "Bail out! " string. It's part of TAP syntax:

# https://testanything.org/tap-specification.html

local bail_out="Bail out! "

local message="$1"

say_color >&5 error $bail_out "$message"

_error_exit

}

say () {

say_color info "$*"

}

if test -n "$HARNESS_ACTIVE"

then

if test "$verbose" = t || test -n "$verbose_only"

then

BAIL_OUT 'verbose mode forbidden under TAP harness; try --verbose-log'

fi

fi

test "${test_description}" != "" ||

error "Test script did not set test_description."

if test "$help" = "t"

then

printf '%s\n' "$test_description"

exit 0

fi

if test "$verbose_log" = "t"

then

exec 3>>"$GIT_TEST_TEE_OUTPUT_FILE" 4>&3

elif test "$verbose" = "t"

then

exec 4>&2 3>&1

else

exec 4>/dev/null 3>/dev/null

fi

# Send any "-x" output directly to stderr to avoid polluting tests

# which capture stderr. We can do this unconditionally since it

# has no effect if tracing isn't turned on.

#

# Note that this sets up the trace fd as soon as we assign the variable, so it

# must come after the creation of descriptor 4 above. Likewise, we must never

# unset this, as it has the side effect of closing descriptor 4, which we

# use to show verbose tests to the user.

#

# Note also that we don't need or want to export it. The tracing is local to

# this shell, and we would not want to influence any shells we exec.

BASH_XTRACEFD=4

test_failure=0

test_count=0

test_fixed=0

test_broken=0

test_success=0

test_missing_prereq=

test_external_has_tap=0

die () {

code=$?

# This is responsible for running the atexit commands even when a

# test script run with '--immediate' fails, or when the user hits

# ctrl-C, i.e. when 'test_done' is not invoked at all.

test_atexit_handler || code=$?

if test -n "$GIT_EXIT_OK"

then

exit $code

else

echo >&5 "FATAL: Unexpected exit with code $code"

exit 1

fi

}

GIT_EXIT_OK=

trap 'die' EXIT

# Disable '-x' tracing, because with some shells, notably dash, it

# prevents running the cleanup commands when a test script run with

# '--verbose-log -x' is interrupted.

trap '{ code=$?; set +x; } 2>/dev/null; exit $code' INT TERM HUP

# The user-facing functions are loaded from a separate file so that

# test_perf subshells can have them too

. "$TEST_DIRECTORY/test-lib-functions.sh"

# You are not expected to call test_ok_ and test_failure_ directly, use

# the test_expect_* functions instead.

test_ok_ () {

test_success=$(($test_success + 1))

say_color "" "ok $test_count - $@"

finalize_test_case_output ok "$@"

}

_invert_exit_code_failure_end_blurb () {

say_color warn "# faked up failures as TODO & now exiting with 0 due to --invert-exit-code"

}

test_failure_ () {

failure_label=$1

test_failure=$(($test_failure + 1))

local pfx=""

if test -n "$invert_exit_code" # && test -n "$HARNESS_ACTIVE"

then

pfx="# TODO induced breakage (--invert-exit-code):"

fi

say_color error "not ok $test_count - ${pfx:+$pfx }$1"

shift

printf '%s\n' "$*" | sed -e 's/^/# /'

if test -n "$immediate"

then

say_color error "1..$test_count"

if test -n "$invert_exit_code"

then

finalize_test_output

_invert_exit_code_failure_end_blurb

GIT_EXIT_OK=t

exit 0

fi

_error_exit

fi

finalize_test_case_output failure "$failure_label" "$@"

}

test_known_broken_ok_ () {

test_fixed=$(($test_fixed+1))

say_color error "ok $test_count - $1 # TODO known breakage vanished"

finalize_test_case_output fixed "$1"

}

test_known_broken_failure_ () {

test_broken=$(($test_broken+1))

say_color warn "not ok $test_count - $1 # TODO known breakage"

finalize_test_case_output broken "$1"

}

test_debug () {

test "$debug" = "" || eval "$1"

}

match_pattern_list () {

arg="$1"

shift

test -z "$*" && return 1

# We need to use "$*" to get field-splitting, but we want to

# disable globbing, since we are matching against an arbitrary

# $arg, not what's in the filesystem. Using "set -f" accomplishes

# that, but we must do it in a subshell to avoid impacting the

# rest of the script. The exit value of the subshell becomes

# the function's return value.

(

set -f

for pattern_ in $*

do

case "$arg" in

$pattern_)

exit 0

;;

esac

done

exit 1

)

}

match_test_selector_list () {

operation="$1"

shift

title="$1"

shift

arg="$1"

shift

test -z "$1" && return 0

# Commas are accepted as separators.

OLDIFS=$IFS

IFS=','

set -- $1

IFS=$OLDIFS

# If the first selector is negative we include by default.

include=

case "$1" in

!*) include=t ;;

esac

for selector

do

orig_selector=$selector

positive=t

case "$selector" in

!*)

positive=

selector=${selector##?}

;;

esac

test -z "$selector" && continue

case "$selector" in

*-*)

if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null

then

echo "error: $operation: invalid non-numeric in range" \

"start: '$orig_selector'" >&2

exit 1

fi

if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null

then

echo "error: $operation: invalid non-numeric in range" \

"end: '$orig_selector'" >&2

exit 1

fi

;;

*)

if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null

then

case "$title" in *${selector}*)

include=$positive

;;

esac

continue

fi

esac

# Short cut for "obvious" cases

test -z "$include" && test -z "$positive" && continue

test -n "$include" && test -n "$positive" && continue

case "$selector" in

-*)

if test $arg -le ${selector#-}

then

include=$positive

fi

;;

*-)

if test $arg -ge ${selector%-}

then

include=$positive

fi

;;

*-*)

if test ${selector%%-*} -le $arg \

&& test $arg -le ${selector#*-}

then

include=$positive

fi

;;

*)

if test $arg -eq $selector

then

include=$positive

fi

;;

esac

done

test -n "$include"

}

maybe_teardown_verbose () {

test -z "$verbose_only" && return

exec 4>/dev/null 3>/dev/null

verbose=

}

last_verbose=t

maybe_setup_verbose () {

test -z "$verbose_only" && return

if match_pattern_list $test_count "$verbose_only"