1# Test framework for git. See t/README for usage. 2# 3# Copyright (c) 2005 Junio C Hamano 4# 5# This program is free software: you can redistribute it and/or modify 6# it under the terms of the GNU General Public License as published by 7# the Free Software Foundation, either version 2 of the License, or 8# (at your option) any later version. 9# 10# This program is distributed in the hope that it will be useful, 11# but WITHOUT ANY WARRANTY; without even the implied warranty of 12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13# GNU General Public License for more details. 14# 15# You should have received a copy of the GNU General Public License 16# along with this program. If not, see http://www.gnu.org/licenses/ . 17 18# Test the binaries we have just built. The tests are kept in 19# t/ subdirectory and are run in 'trash directory' subdirectory. 20if test -z "$TEST_DIRECTORY" 21then 22 # We allow tests to override this, in case they want to run tests 23 # outside of t/, e.g. for running tests on the test library 24 # itself. 25 TEST_DIRECTORY=$(pwd) 26else 27 # ensure that TEST_DIRECTORY is an absolute path so that it 28 # is valid even if the current working directory is changed 29 TEST_DIRECTORY=$(cd "$TEST_DIRECTORY" && pwd) || exit 1 30fi 31if test -z "$TEST_OUTPUT_DIRECTORY" 32then 33 # Similarly, override this to store the test-results subdir 34 # elsewhere 35 TEST_OUTPUT_DIRECTORY=$TEST_DIRECTORY 36fi 37GIT_BUILD_DIR="$TEST_DIRECTORY"/.. 38 39# If we were built with ASAN, it may complain about leaks 40# of program-lifetime variables. Disable it by default to lower 41# the noise level. This needs to happen at the start of the script, 42# before we even do our "did we build git yet" check (since we don't 43# want that one to complain to stderr). 44: ${ASAN_OPTIONS=detect_leaks=0:abort_on_error=1} 45export ASAN_OPTIONS 46 47# If LSAN is in effect we _do_ want leak checking, but we still 48# want to abort so that we notice the problems. 49: ${LSAN_OPTIONS=abort_on_error=1} 50export LSAN_OPTIONS 51 52if test ! -f "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS 53then 54 echo >&2 'error: GIT-BUILD-OPTIONS missing (has Git been built?).' 55 exit 1 56fi 57. "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS 58export PERL_PATH SHELL_PATH 59 60# In t0000, we need to override test directories of nested testcases. In case 61# the developer has TEST_OUTPUT_DIRECTORY part of his build options, then we'd 62# reset this value to instead contain what the developer has specified. We thus 63# have this knob to allow overriding the directory. 64if test -n "${TEST_OUTPUT_DIRECTORY_OVERRIDE}" 65then 66 TEST_OUTPUT_DIRECTORY="${TEST_OUTPUT_DIRECTORY_OVERRIDE}" 67fi 68 69# Disallow the use of abbreviated options in the test suite by default 70if test -z "${GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS}" 71then 72 GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS=true 73 export GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS 74fi 75 76# Explicitly set the default branch name for testing, to avoid the 77# transitory "git init" warning under --verbose. 78: ${GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME:=master} 79export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 80 81################################################################ 82# It appears that people try to run tests without building... 83"${GIT_TEST_INSTALLED:-$GIT_BUILD_DIR}/git$X" >/dev/null 84if test $? != 1 85then 86 if test -n "$GIT_TEST_INSTALLED" 87 then 88 echo >&2 "error: there is no working Git at '$GIT_TEST_INSTALLED'" 89 else 90 echo >&2 'error: you do not seem to have built git yet.' 91 fi 92 exit 1 93fi 94 95store_arg_to= 96opt_required_arg= 97# $1: option string 98# $2: name of the var where the arg will be stored 99mark_option_requires_arg () { 100 if test -n "$opt_required_arg" 101 then 102 echo "error: options that require args cannot be bundled" \ 103 "together: '$opt_required_arg' and '$1'" >&2 104 exit 1 105 fi 106 opt_required_arg=$1 107 store_arg_to=$2 108} 109 110parse_option () { 111 local opt="$1" 112 113 case "$opt" in 114 -d|--d|--de|--deb|--debu|--debug) 115 debug=t ;; 116 -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate) 117 immediate=t ;; 118 -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests) 119 GIT_TEST_LONG=t; export GIT_TEST_LONG ;; 120 -r) 121 mark_option_requires_arg "$opt" run_list 122 ;; 123 --run=*) 124 run_list=${opt#--*=} ;; 125 -h|--h|--he|--hel|--help) 126 help=t ;; 127 -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose) 128 verbose=t ;; 129 --verbose-only=*) 130 verbose_only=${opt#--*=} 131 ;; 132 -q|--q|--qu|--qui|--quie|--quiet) 133 # Ignore --quiet under a TAP::Harness. Saying how many tests 134 # passed without the ok/not ok details is always an error. 135 test -z "$HARNESS_ACTIVE" && quiet=t ;; 136 --with-dashes) 137 with_dashes=t ;; 138 --no-bin-wrappers) 139 no_bin_wrappers=t ;; 140 --no-color) 141 color= ;; 142 --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind) 143 valgrind=memcheck 144 tee=t 145 ;; 146 --valgrind=*) 147 valgrind=${opt#--*=} 148 tee=t 149 ;; 150 --valgrind-only=*) 151 valgrind_only=${opt#--*=} 152 tee=t 153 ;; 154 --tee) 155 tee=t ;; 156 --root=*) 157 root=${opt#--*=} ;; 158 --chain-lint) 159 GIT_TEST_CHAIN_LINT=1 ;; 160 --no-chain-lint) 161 GIT_TEST_CHAIN_LINT=0 ;; 162 -x) 163 trace=t ;; 164 -V|--verbose-log) 165 verbose_log=t 166 tee=t 167 ;; 168 --write-junit-xml) 169 write_junit_xml=t 170 ;; 171 --stress) 172 stress=t ;; 173 --stress=*) 174 echo "error: --stress does not accept an argument: '$opt'" >&2 175 echo "did you mean --stress-jobs=${opt#*=} or --stress-limit=${opt#*=}?" >&2 176 exit 1 177 ;; 178 --stress-jobs=*) 179 stress=t; 180 stress_jobs=${opt#--*=} 181 case "$stress_jobs" in 182 *[!0-9]*|0*|"") 183 echo "error: --stress-jobs=<N> requires the number of jobs to run" >&2 184 exit 1 185 ;; 186 *) # Good. 187 ;; 188 esac 189 ;; 190 --stress-limit=*) 191 stress=t; 192 stress_limit=${opt#--*=} 193 case "$stress_limit" in 194 *[!0-9]*|0*|"") 195 echo "error: --stress-limit=<N> requires the number of repetitions" >&2 196 exit 1 197 ;; 198 *) # Good. 199 ;; 200 esac 201 ;; 202 *) 203 echo "error: unknown test option '$opt'" >&2; exit 1 ;; 204 esac 205} 206 207# Parse options while taking care to leave $@ intact, so we will still 208# have all the original command line options when executing the test 209# script again for '--tee' and '--verbose-log' later. 210for opt 211do 212 if test -n "$store_arg_to" 213 then 214 eval $store_arg_to=\$opt 215 store_arg_to= 216 opt_required_arg= 217 continue 218 fi 219 220 case "$opt" in 221 --*|-?) 222 parse_option "$opt" ;; 223 -?*) 224 # bundled short options must be fed separately to parse_option 225 opt=${opt#-} 226 while test -n "$opt" 227 do 228 extra=${opt#?} 229 this=${opt%$extra} 230 opt=$extra 231 parse_option "-$this" 232 done 233 ;; 234 *) 235 echo "error: unknown test option '$opt'" >&2; exit 1 ;; 236 esac 237done 238if test -n "$store_arg_to" 239then 240 echo "error: $opt_required_arg requires an argument" >&2 241 exit 1 242fi 243 244if test -n "$valgrind_only" 245then 246 test -z "$valgrind" && valgrind=memcheck 247 test -z "$verbose" && verbose_only="$valgrind_only" 248elif test -n "$valgrind" 249then 250 test -z "$verbose_log" && verbose=t 251fi 252 253if test -n "$stress" 254then 255 verbose=t 256 trace=t 257 immediate=t 258fi 259 260TEST_STRESS_JOB_SFX="${GIT_TEST_STRESS_JOB_NR:+.stress-$GIT_TEST_STRESS_JOB_NR}" 261TEST_NAME="$(basename "$0" .sh)" 262TEST_NUMBER="${TEST_NAME%%-*}" 263TEST_NUMBER="${TEST_NUMBER#t}" 264TEST_RESULTS_DIR="$TEST_OUTPUT_DIRECTORY/test-results" 265TEST_RESULTS_BASE="$TEST_RESULTS_DIR/$TEST_NAME$TEST_STRESS_JOB_SFX" 266TRASH_DIRECTORY="trash directory.$TEST_NAME$TEST_STRESS_JOB_SFX" 267test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY" 268case "$TRASH_DIRECTORY" in 269/*) ;; # absolute path is good 270 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;; 271esac 272 273# If --stress was passed, run this test repeatedly in several parallel loops. 274if test "$GIT_TEST_STRESS_STARTED" = "done" 275then 276 : # Don't stress test again. 277elif test -n "$stress" 278then 279 if test -n "$stress_jobs" 280 then 281 job_count=$stress_jobs 282 elif test -n "$GIT_TEST_STRESS_LOAD" 283 then 284 job_count="$GIT_TEST_STRESS_LOAD" 285 elif job_count=$(getconf _NPROCESSORS_ONLN 2>/dev/null) && 286 test -n "$job_count" 287 then 288 job_count=$((2 * $job_count)) 289 else 290 job_count=8 291 fi 292 293 mkdir -p "$TEST_RESULTS_DIR" 294 stressfail="$TEST_RESULTS_BASE.stress-failed" 295 rm -f "$stressfail" 296 297 stress_exit=0 298 trap ' 299 kill $job_pids 2>/dev/null 300 wait 301 stress_exit=1 302 ' TERM INT HUP 303 304 job_pids= 305 job_nr=0 306 while test $job_nr -lt "$job_count" 307 do 308 ( 309 GIT_TEST_STRESS_STARTED=done 310 GIT_TEST_STRESS_JOB_NR=$job_nr 311 export GIT_TEST_STRESS_STARTED GIT_TEST_STRESS_JOB_NR 312 313 trap ' 314 kill $test_pid 2>/dev/null 315 wait 316 exit 1 317 ' TERM INT 318 319 cnt=1 320 while ! test -e "$stressfail" && 321 { test -z "$stress_limit" || 322 test $cnt -le $stress_limit ; } 323 do 324 $TEST_SHELL_PATH "$0" "$@" >"$TEST_RESULTS_BASE.stress-$job_nr.out" 2>&1 & 325 test_pid=$! 326 327 if wait $test_pid 328 then 329 printf "OK %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt 330 else 331 echo $GIT_TEST_STRESS_JOB_NR >>"$stressfail" 332 printf "FAIL %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt 333 fi 334 cnt=$(($cnt + 1)) 335 done 336 ) & 337 job_pids="$job_pids $!" 338 job_nr=$(($job_nr + 1)) 339 done 340 341 wait 342 343 if test -f "$stressfail" 344 then 345 stress_exit=1 346 echo "Log(s) of failed test run(s):" 347 for failed_job_nr in $(sort -n "$stressfail") 348 do 349 echo "Contents of '$TEST_RESULTS_BASE.stress-$failed_job_nr.out':" 350 cat "$TEST_RESULTS_BASE.stress-$failed_job_nr.out" 351 done 352 rm -rf "$TRASH_DIRECTORY.stress-failed" 353 # Move the last one. 354 mv "$TRASH_DIRECTORY.stress-$failed_job_nr" "$TRASH_DIRECTORY.stress-failed" 355 fi 356 357 exit $stress_exit 358fi 359 360# if --tee was passed, write the output not only to the terminal, but 361# additionally to the file test-results/$BASENAME.out, too. 362if test "$GIT_TEST_TEE_STARTED" = "done" 363then 364 : # do not redirect again 365elif test -n "$tee" 366then 367 mkdir -p "$TEST_RESULTS_DIR" 368 369 # Make this filename available to the sub-process in case it is using 370 # --verbose-log. 371 GIT_TEST_TEE_OUTPUT_FILE=$TEST_RESULTS_BASE.out 372 export GIT_TEST_TEE_OUTPUT_FILE 373 374 # Truncate before calling "tee -a" to get rid of the results 375 # from any previous runs. 376 >"$GIT_TEST_TEE_OUTPUT_FILE" 377 378 (GIT_TEST_TEE_STARTED=done ${TEST_SHELL_PATH} "$0" "$@" 2>&1; 379 echo $? >"$TEST_RESULTS_BASE.exit") | tee -a "$GIT_TEST_TEE_OUTPUT_FILE" 380 test "$(cat "$TEST_RESULTS_BASE.exit")" = 0 381 exit 382fi 383 384if test -n "$trace" && test -n "$test_untraceable" 385then 386 # '-x' tracing requested, but this test script can't be reliably 387 # traced, unless it is run with a Bash version supporting 388 # BASH_XTRACEFD (introduced in Bash v4.1). 389 # 390 # Perform this version check _after_ the test script was 391 # potentially re-executed with $TEST_SHELL_PATH for '--tee' or 392 # '--verbose-log', so the right shell is checked and the 393 # warning is issued only once. 394 if test -n "$BASH_VERSION" && eval ' 395 test ${BASH_VERSINFO[0]} -gt 4 || { 396 test ${BASH_VERSINFO[0]} -eq 4 && 397 test ${BASH_VERSINFO[1]} -ge 1 398 } 399 ' 400 then 401 : Executed by a Bash version supporting BASH_XTRACEFD. Good. 402 else 403 echo >&2 "warning: ignoring -x; '$0' is untraceable without BASH_XTRACEFD" 404 trace= 405 fi 406fi 407if test -n "$trace" && test -z "$verbose_log" 408then 409 verbose=t 410fi 411 412# Since bash 5.0, checkwinsize is enabled by default which does 413# update the COLUMNS variable every time a non-builtin command 414# completes, even for non-interactive shells. 415# Disable that since we are aiming for repeatability. 416test -n "$BASH_VERSION" && shopt -u checkwinsize 2>/dev/null 417 418# For repeatability, reset the environment to known value. 419# TERM is sanitized below, after saving color control sequences. 420LANG=C 421LC_ALL=C 422PAGER=cat 423TZ=UTC 424COLUMNS=80 425export LANG LC_ALL PAGER TZ COLUMNS 426EDITOR=: 427 428# A call to "unset" with no arguments causes at least Solaris 10 429# /usr/xpg4/bin/sh and /bin/ksh to bail out. So keep the unsets 430# deriving from the command substitution clustered with the other 431# ones. 432unset VISUAL EMAIL LANGUAGE $("$PERL_PATH" -e ' 433 my @env = keys %ENV; 434 my $ok = join("|", qw( 435 TRACE 436 DEBUG 437 TEST 438 .*_TEST 439 PROVE 440 VALGRIND 441 UNZIP 442 PERF_ 443 CURL_VERBOSE 444 TRACE_CURL 445 )); 446 my @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env); 447 print join("\n", @vars); 448') 449unset XDG_CACHE_HOME 450unset XDG_CONFIG_HOME 451unset GITPERLLIB 452TEST_AUTHOR_LOCALNAME=author 453TEST_AUTHOR_DOMAIN=example.com 454GIT_AUTHOR_EMAIL=${TEST_AUTHOR_LOCALNAME}@${TEST_AUTHOR_DOMAIN} 455GIT_AUTHOR_NAME='A U Thor' 456GIT_AUTHOR_DATE='1112354055 +0200' 457TEST_COMMITTER_LOCALNAME=committer 458TEST_COMMITTER_DOMAIN=example.com 459GIT_COMMITTER_EMAIL=${TEST_COMMITTER_LOCALNAME}@${TEST_COMMITTER_DOMAIN} 460GIT_COMMITTER_NAME='C O Mitter' 461GIT_COMMITTER_DATE='1112354055 +0200' 462GIT_MERGE_VERBOSITY=5 463GIT_MERGE_AUTOEDIT=no 464export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT 465export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME 466export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME 467export GIT_COMMITTER_DATE GIT_AUTHOR_DATE 468export EDITOR 469 470GIT_DEFAULT_HASH="${GIT_TEST_DEFAULT_HASH:-sha1}" 471export GIT_DEFAULT_HASH 472GIT_TEST_MERGE_ALGORITHM="${GIT_TEST_MERGE_ALGORITHM:-ort}" 473export GIT_TEST_MERGE_ALGORITHM 474 475# Tests using GIT_TRACE typically don't want <timestamp> <file>:<line> output 476GIT_TRACE_BARE=1 477export GIT_TRACE_BARE 478 479# Use specific version of the index file format 480if test -n "${GIT_TEST_INDEX_VERSION:+isset}" 481then 482 GIT_INDEX_VERSION="$GIT_TEST_INDEX_VERSION" 483 export GIT_INDEX_VERSION 484fi 485 486if test -n "$GIT_TEST_PERL_FATAL_WARNINGS" 487then 488 GIT_PERL_FATAL_WARNINGS=1 489 export GIT_PERL_FATAL_WARNINGS 490fi 491 492# Add libc MALLOC and MALLOC_PERTURB test 493# only if we are not executing the test with valgrind 494if test -n "$valgrind" || 495 test -n "$TEST_NO_MALLOC_CHECK" 496then 497 setup_malloc_check () { 498 : nothing 499 } 500 teardown_malloc_check () { 501 : nothing 502 } 503else 504 setup_malloc_check () { 505 MALLOC_CHECK_=3 MALLOC_PERTURB_=165 506 export MALLOC_CHECK_ MALLOC_PERTURB_ 507 } 508 teardown_malloc_check () { 509 unset MALLOC_CHECK_ MALLOC_PERTURB_ 510 } 511fi 512 513# Protect ourselves from common misconfiguration to export 514# CDPATH into the environment 515unset CDPATH 516 517unset GREP_OPTIONS 518unset UNZIP 519 520case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in 5211|2|true) 522 GIT_TRACE=4 523 ;; 524esac 525 526# Line feed 527LF=' 528' 529 530# Single quote 531SQ=\' 532 533# UTF-8 ZERO WIDTH NON-JOINER, which HFS+ ignores 534# when case-folding filenames 535u200c=$(printf '\342\200\214') 536 537export _x05 _x35 LF u200c EMPTY_TREE EMPTY_BLOB ZERO_OID OID_REGEX 538 539# Each test should start with something like this, after copyright notices: 540# 541# test_description='Description of this test... 542# This test checks if command xyzzy does the right thing... 543# ' 544# . ./test-lib.sh 545test "x$TERM" != "xdumb" && ( 546 test -t 1 && 547 tput bold >/dev/null 2>&1 && 548 tput setaf 1 >/dev/null 2>&1 && 549 tput sgr0 >/dev/null 2>&1 550 ) && 551 color=t 552 553if test -n "$color" 554then 555 # Save the color control sequences now rather than run tput 556 # each time say_color() is called. This is done for two 557 # reasons: 558 # * TERM will be changed to dumb 559 # * HOME will be changed to a temporary directory and tput 560 # might need to read ~/.terminfo from the original HOME 561 # directory to get the control sequences 562 # Note: This approach assumes the control sequences don't end 563 # in a newline for any terminal of interest (command 564 # substitutions strip trailing newlines). Given that most 565 # (all?) terminals in common use are related to ECMA-48, this 566 # shouldn't be a problem. 567 say_color_error=$(tput bold; tput setaf 1) # bold red 568 say_color_skip=$(tput setaf 4) # blue 569 say_color_warn=$(tput setaf 3) # brown/yellow 570 say_color_pass=$(tput setaf 2) # green 571 say_color_info=$(tput setaf 6) # cyan 572 say_color_reset=$(tput sgr0) 573 say_color_="" # no formatting for normal text 574 say_color () { 575 test -z "$1" && test -n "$quiet" && return 576 eval "say_color_color=\$say_color_$1" 577 shift 578 printf "%s\\n" "$say_color_color$*$say_color_reset" 579 } 580else 581 say_color() { 582 test -z "$1" && test -n "$quiet" && return 583 shift 584 printf "%s\n" "$*" 585 } 586fi 587 588USER_TERM="$TERM" 589TERM=dumb 590export TERM USER_TERM 591 592_error_exit () { 593 finalize_junit_xml 594 GIT_EXIT_OK=t 595 exit 1 596} 597 598error () { 599 say_color error "error: $*" 600 _error_exit 601} 602 603BUG () { 604 error >&7 "bug in the test script: $*" 605} 606 607BAIL_OUT () { 608 test $# -ne 1 && BUG "1 param" 609 610 # Do not change "Bail out! " string. It's part of TAP syntax: 611 # https://testanything.org/tap-specification.html 612 local bail_out="Bail out! " 613 local message="$1" 614 615 say_color error $bail_out "$message" 616 _error_exit 617} 618 619say () { 620 say_color info "$*" 621} 622 623if test -n "$HARNESS_ACTIVE" 624then 625 if test "$verbose" = t || test -n "$verbose_only" 626 then 627 BAIL_OUT 'verbose mode forbidden under TAP harness; try --verbose-log' 628 fi 629fi 630 631test "${test_description}" != "" || 632error "Test script did not set test_description." 633 634if test "$help" = "t" 635then 636 printf '%s\n' "$test_description" 637 exit 0 638fi 639 640exec 5>&1 641exec 6<&0 642exec 7>&2 643if test "$verbose_log" = "t" 644then 645 exec 3>>"$GIT_TEST_TEE_OUTPUT_FILE" 4>&3 646elif test "$verbose" = "t" 647then 648 exec 4>&2 3>&1 649else 650 exec 4>/dev/null 3>/dev/null 651fi 652 653# Send any "-x" output directly to stderr to avoid polluting tests 654# which capture stderr. We can do this unconditionally since it 655# has no effect if tracing isn't turned on. 656# 657# Note that this sets up the trace fd as soon as we assign the variable, so it 658# must come after the creation of descriptor 4 above. Likewise, we must never 659# unset this, as it has the side effect of closing descriptor 4, which we 660# use to show verbose tests to the user. 661# 662# Note also that we don't need or want to export it. The tracing is local to 663# this shell, and we would not want to influence any shells we exec. 664BASH_XTRACEFD=4 665 666test_failure=0 667test_count=0 668test_fixed=0 669test_broken=0 670test_success=0 671 672test_external_has_tap=0 673 674die () { 675 code=$? 676 # This is responsible for running the atexit commands even when a 677 # test script run with '--immediate' fails, or when the user hits 678 # ctrl-C, i.e. when 'test_done' is not invoked at all. 679 test_atexit_handler || code=$? 680 if test -n "$GIT_EXIT_OK" 681 then 682 exit $code 683 else 684 echo >&5 "FATAL: Unexpected exit with code $code" 685 exit 1 686 fi 687} 688 689GIT_EXIT_OK= 690trap 'die' EXIT 691# Disable '-x' tracing, because with some shells, notably dash, it 692# prevents running the cleanup commands when a test script run with 693# '--verbose-log -x' is interrupted. 694trap '{ code=$?; set +x; } 2>/dev/null; exit $code' INT TERM HUP 695 696# The user-facing functions are loaded from a separate file so that 697# test_perf subshells can have them too 698. "$TEST_DIRECTORY/test-lib-functions.sh" 699 700# You are not expected to call test_ok_ and test_failure_ directly, use 701# the test_expect_* functions instead. 702 703test_ok_ () { 704 if test -n "$write_junit_xml" 705 then 706 write_junit_xml_testcase "$*" 707 fi 708 test_success=$(($test_success + 1)) 709 say_color "" "ok $test_count - $@" 710} 711 712test_failure_ () { 713 if test -n "$write_junit_xml" 714 then 715 junit_insert="<failure message=\"not ok $test_count -" 716 junit_insert="$junit_insert $(xml_attr_encode "$1")\">" 717 junit_insert="$junit_insert $(xml_attr_encode \ 718 "$(if test -n "$GIT_TEST_TEE_OUTPUT_FILE" 719 then 720 test-tool path-utils skip-n-bytes \ 721 "$GIT_TEST_TEE_OUTPUT_FILE" $GIT_TEST_TEE_OFFSET 722 else 723 printf '%s\n' "$@" | sed 1d 724 fi)")" 725 junit_insert="$junit_insert</failure>" 726 if test -n "$GIT_TEST_TEE_OUTPUT_FILE" 727 then 728 junit_insert="$junit_insert<system-err>$(xml_attr_encode \ 729 "$(cat "$GIT_TEST_TEE_OUTPUT_FILE")")</system-err>" 730 fi 731 write_junit_xml_testcase "$1" " $junit_insert" 732 fi 733 test_failure=$(($test_failure + 1)) 734 say_color error "not ok $test_count - $1" 735 shift 736 printf '%s\n' "$*" | sed -e 's/^/# /' 737 test "$immediate" = "" || _error_exit 738} 739 740test_known_broken_ok_ () { 741 if test -n "$write_junit_xml" 742 then 743 write_junit_xml_testcase "$* (breakage fixed)" 744 fi 745 test_fixed=$(($test_fixed+1)) 746 say_color error "ok $test_count - $@ # TODO known breakage vanished" 747} 748 749test_known_broken_failure_ () { 750 if test -n "$write_junit_xml" 751 then 752 write_junit_xml_testcase "$* (known breakage)" 753 fi 754 test_broken=$(($test_broken+1)) 755 say_color warn "not ok $test_count - $@ # TODO known breakage" 756} 757 758test_debug () { 759 test "$debug" = "" || eval "$1" 760} 761 762match_pattern_list () { 763 arg="$1" 764 shift 765 test -z "$*" && return 1 766 # We need to use "$*" to get field-splitting, but we want to 767 # disable globbing, since we are matching against an arbitrary 768 # $arg, not what's in the filesystem. Using "set -f" accomplishes 769 # that, but we must do it in a subshell to avoid impacting the 770 # rest of the script. The exit value of the subshell becomes 771 # the function's return value. 772 ( 773 set -f 774 for pattern_ in $* 775 do 776 case "$arg" in 777 $pattern_) 778 exit 0 779 ;; 780 esac 781 done 782 exit 1 783 ) 784} 785 786match_test_selector_list () { 787 operation="$1" 788 shift 789 title="$1" 790 shift 791 arg="$1" 792 shift 793 test -z "$1" && return 0 794 795 # Commas are accepted as separators. 796 OLDIFS=$IFS 797 IFS=',' 798 set -- $1 799 IFS=$OLDIFS 800 801 # If the first selector is negative we include by default. 802 include= 803 case "$1" in 804 !*) include=t ;; 805 esac 806 807 for selector 808 do 809 orig_selector=$selector 810 811 positive=t 812 case "$selector" in 813 !*) 814 positive= 815 selector=${selector##?} 816 ;; 817 esac 818 819 test -z "$selector" && continue 820 821 case "$selector" in 822 *-*) 823 if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null 824 then 825 echo "error: $operation: invalid non-numeric in range" \ 826 "start: '$orig_selector'" >&2 827 exit 1 828 fi 829 if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null 830 then 831 echo "error: $operation: invalid non-numeric in range" \ 832 "end: '$orig_selector'" >&2 833 exit 1 834 fi 835 ;; 836 *) 837 if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null 838 then 839 case "$title" in *${selector}*) 840 include=$positive 841 ;; 842 esac 843 continue 844 fi 845 esac 846 847 # Short cut for "obvious" cases 848 test -z "$include" && test -z "$positive" && continue 849 test -n "$include" && test -n "$positive" && continue 850 851 case "$selector" in 852 -*) 853 if test $arg -le ${selector#-} 854 then 855 include=$positive 856 fi 857 ;; 858 *-) 859 if test $arg -ge ${selector%-} 860 then 861 include=$positive 862 fi 863 ;; 864 *-*) 865 if test ${selector%%-*} -le $arg \ 866 && test $arg -le ${selector#*-} 867 then 868 include=$positive 869 fi 870 ;; 871 *) 872 if test $arg -eq $selector 873 then 874 include=$positive 875 fi 876 ;; 877 esac 878 done 879 880 test -n "$include" 881} 882 883maybe_teardown_verbose () { 884 test -z "$verbose_only" && return 885 exec 4>/dev/null 3>/dev/null 886 verbose= 887} 888 889last_verbose=t 890maybe_setup_verbose () { 891 test -z "$verbose_only" && return 892 if match_pattern_list $test_count "$verbose_only" 893 then 894 exec 4>&2 3>&1 895 # Emit a delimiting blank line when going from 896 # non-verbose to verbose. Within verbose mode the 897 # delimiter is printed by test_expect_*. The choice 898 # of the initial $last_verbose is such that before 899 # test 1, we do not print it. 900 test -z "$last_verbose" && echo >&3 "" 901 verbose=t 902 else 903 exec 4>/dev/null 3>/dev/null 904 verbose= 905 fi 906 last_verbose=$verbose 907} 908 909maybe_teardown_valgrind () { 910 test -z "$GIT_VALGRIND" && return 911 GIT_VALGRIND_ENABLED= 912} 913 914maybe_setup_valgrind () { 915 test -z "$GIT_VALGRIND" && return 916 if test -z "$valgrind_only" 917 then 918 GIT_VALGRIND_ENABLED=t 919 return 920 fi 921 GIT_VALGRIND_ENABLED= 922 if match_pattern_list $test_count "$valgrind_only" 923 then 924 GIT_VALGRIND_ENABLED=t 925 fi 926} 927 928trace_level_=0 929want_trace () { 930 test "$trace" = t && { 931 test "$verbose" = t || test "$verbose_log" = t 932 } 933} 934 935# This is a separate function because some tests use 936# "return" to end a test_expect_success block early 937# (and we want to make sure we run any cleanup like 938# "set +x"). 939test_eval_inner_ () { 940 # Do not add anything extra (including LF) after '$*' 941 eval " 942 want_trace && trace_level_=$(($trace_level_+1)) && set -x 943 $*" 944} 945 946test_eval_ () { 947 # If "-x" tracing is in effect, then we want to avoid polluting stderr 948 # with non-test commands. But once in "set -x" mode, we cannot prevent 949 # the shell from printing the "set +x" to turn it off (nor the saving 950 # of $? before that). But we can make sure that the output goes to 951 # /dev/null. 952 # 953 # There are a few subtleties here: 954 # 955 # - we have to redirect descriptor 4 in addition to 2, to cover 956 # BASH_XTRACEFD 957 # 958 # - the actual eval has to come before the redirection block (since 959 # it needs to see descriptor 4 to set up its stderr) 960 # 961 # - likewise, any error message we print must be outside the block to 962 # access descriptor 4 963 # 964 # - checking $? has to come immediately after the eval, but it must 965 # be _inside_ the block to avoid polluting the "set -x" output 966 # 967 968 test_eval_inner_ "$@" </dev/null >&3 2>&4 969 { 970 test_eval_ret_=$? 971 if want_trace 972 then 973 test 1 = $trace_level_ && set +x 974 trace_level_=$(($trace_level_-1)) 975 fi 976 } 2>/dev/null 4>&2 977 978 if test "$test_eval_ret_" != 0 && want_trace 979 then 980 say_color error >&4 "error: last command exited with \$?=$test_eval_ret_" 981 fi 982 return $test_eval_ret_ 983} 984 985test_run_ () { 986 test_cleanup=: 987 expecting_failure=$2 988 989 if test "${GIT_TEST_CHAIN_LINT:-1}" != 0; then 990 # turn off tracing for this test-eval, as it simply creates 991 # confusing noise in the "-x" output 992 trace_tmp=$trace 993 trace= 994 # 117 is magic because it is unlikely to match the exit 995 # code of other programs 996 if test "OK-117" != "$(test_eval_ "(exit 117) && $1${LF}${LF}echo OK-\$?" 3>&1)" || 997 { 998 test "${GIT_TEST_CHAIN_LINT_HARDER:-${GIT_TEST_CHAIN_LINT_HARDER_DEFAULT:-1}}" != 0 && 999 $(printf '%s\n' "$1" | sed -f "$GIT_BUILD_DIR/t/chainlint.sed" | grep -q '?![A-Z][A-Z]*?!') 1000 } 1001 then 1002 BUG "broken &&-chain or run-away HERE-DOC: $1" 1003 fi 1004 trace=$trace_tmp 1005 fi 1006 1007 setup_malloc_check 1008 test_eval_ "$1" 1009 eval_ret=$? 1010 teardown_malloc_check 1011 1012 if test -z "$immediate" || test $eval_ret = 0 || 1013 test -n "$expecting_failure" && test "$test_cleanup" != ":" 1014 then 1015 setup_malloc_check 1016 test_eval_ "$test_cleanup" 1017 teardown_malloc_check 1018 fi 1019 if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE" 1020 then 1021 echo "" 1022 fi 1023 return "$eval_ret" 1024} 1025 1026test_start_ () { 1027 test_count=$(($test_count+1)) 1028 maybe_setup_verbose 1029 maybe_setup_valgrind 1030 if test -n "$write_junit_xml" 1031 then 1032 junit_start=$(test-tool date getnanos) 1033 fi 1034} 1035 1036test_finish_ () { 1037 echo >&3 "" 1038 maybe_teardown_valgrind 1039 maybe_teardown_verbose 1040 if test -n "$GIT_TEST_TEE_OFFSET" 1041 then 1042 GIT_TEST_TEE_OFFSET=$(test-tool path-utils file-size \ 1043 "$GIT_TEST_TEE_OUTPUT_FILE") 1044 fi 1045} 1046 1047test_skip () { 1048 to_skip= 1049 skipped_reason= 1050 if match_pattern_list $this_test.$test_count "$GIT_SKIP_TESTS" 1051 then 1052 to_skip=t 1053 skipped_reason="GIT_SKIP_TESTS" 1054 fi 1055 if test -z "$to_skip" && test -n "$run_list" && 1056 ! match_test_selector_list '--run' "$1" $test_count "$run_list" 1057 then 1058 to_skip=t 1059 skipped_reason="--run" 1060 fi 1061 if test -z "$to_skip" && test -n "$test_prereq" && 1062 ! test_have_prereq "$test_prereq" 1063 then 1064 to_skip=t 1065 1066 of_prereq= 1067 if test "$missing_prereq" != "$test_prereq" 1068 then 1069 of_prereq=" of $test_prereq" 1070 fi 1071 skipped_reason="missing $missing_prereq${of_prereq}" 1072 fi 1073 1074 case "$to_skip" in 1075 t) 1076 if test -n "$write_junit_xml" 1077 then 1078 message="$(xml_attr_encode "$skipped_reason")" 1079 write_junit_xml_testcase "$1" \ 1080 " <skipped message=\"$message\" />" 1081 fi 1082 1083 say_color skip "ok $test_count # skip $1 ($skipped_reason)" 1084 : true 1085 ;; 1086 *) 1087 false 1088 ;; 1089 esac 1090} 1091 1092# stub; perf-lib overrides it 1093test_at_end_hook_ () { 1094 : 1095} 1096 1097write_junit_xml () { 1098 case "$1" in 1099 --truncate) 1100 >"$junit_xml_path" 1101 junit_have_testcase= 1102 shift 1103 ;; 1104 esac 1105 printf '%s\n' "$@" >>"$junit_xml_path" 1106} 1107 1108xml_attr_encode () { 1109 printf '%s\n' "$@" | test-tool xml-encode 1110} 1111 1112write_junit_xml_testcase () { 1113 junit_attrs="name=\"$(xml_attr_encode "$this_test.$test_count $1")\"" 1114 shift 1115 junit_attrs="$junit_attrs classname=\"$this_test\"" 1116 junit_attrs="$junit_attrs time=\"$(test-tool \ 1117 date getnanos $junit_start)\"" 1118 write_junit_xml "$(printf '%s\n' \ 1119 " <testcase $junit_attrs>" "$@" " </testcase>")" 1120 junit_have_testcase=t 1121} 1122 1123finalize_junit_xml () { 1124 if test -n "$write_junit_xml" && test -n "$junit_xml_path" 1125 then 1126 test -n "$junit_have_testcase" || { 1127 junit_start=$(test-tool date getnanos) 1128 write_junit_xml_testcase "all tests skipped" 1129 } 1130 1131 # adjust the overall time 1132 junit_time=$(test-tool date getnanos $junit_suite_start) 1133 sed -e "s/\(<testsuite.*\) time=\"[^\"]*\"/\1/" \ 1134 -e "s/<testsuite [^>]*/& time=\"$junit_time\"/" \ 1135 -e '/^ *<\/testsuite/d' \ 1136 <"$junit_xml_path" >"$junit_xml_path.new" 1137 mv "$junit_xml_path.new" "$junit_xml_path" 1138 1139 write_junit_xml " </testsuite>" "</testsuites>" 1140 write_junit_xml= 1141 fi 1142} 1143 1144test_atexit_cleanup=: 1145test_atexit_handler () { 1146 # In a succeeding test script 'test_atexit_handler' is invoked 1147 # twice: first from 'test_done', then from 'die' in the trap on 1148 # EXIT. 1149 # This condition and resetting 'test_atexit_cleanup' below makes 1150 # sure that the registered cleanup commands are run only once. 1151 test : != "$test_atexit_cleanup" || return 0 1152 1153 setup_malloc_check 1154 test_eval_ "$test_atexit_cleanup" 1155 test_atexit_cleanup=: 1156 teardown_malloc_check 1157} 1158 1159test_done () { 1160 GIT_EXIT_OK=t 1161 1162 # Run the atexit commands _before_ the trash directory is 1163 # removed, so the commands can access pidfiles and socket files. 1164 test_atexit_handler 1165 1166 finalize_junit_xml 1167 1168 if test -z "$HARNESS_ACTIVE" 1169 then 1170 mkdir -p "$TEST_RESULTS_DIR" 1171 1172 cat >"$TEST_RESULTS_BASE.counts" <<-EOF 1173 total $test_count 1174 success $test_success 1175 fixed $test_fixed 1176 broken $test_broken 1177 failed $test_failure 1178 1179 EOF 1180 fi 1181 1182 if test "$test_fixed" != 0 1183 then 1184 say_color error "# $test_fixed known breakage(s) vanished; please update test(s)" 1185 fi 1186 if test "$test_broken" != 0 1187 then 1188 say_color warn "# still have $test_broken known breakage(s)" 1189 fi 1190 if test "$test_broken" != 0 || test "$test_fixed" != 0 1191 then 1192 test_remaining=$(( $test_count - $test_broken - $test_fixed )) 1193 msg="remaining $test_remaining test(s)" 1194 else 1195 test_remaining=$test_count 1196 msg="$test_count test(s)" 1197 fi 1198 case "$test_failure" in 1199 0) 1200 if test $test_external_has_tap -eq 0 1201 then 1202 if test $test_remaining -gt 0 1203 then 1204 say_color pass "# passed all $msg" 1205 fi 1206 1207 # Maybe print SKIP message 1208 test -z "$skip_all" || skip_all="# SKIP $skip_all" 1209 case "$test_count" in 1210 0) 1211 say "1..$test_count${skip_all:+ $skip_all}" 1212 ;; 1213 *) 1214 test -z "$skip_all" || 1215 say_color warn "$skip_all" 1216 say "1..$test_count" 1217 ;; 1218 esac 1219 fi 1220 1221 if test -z "$debug" && test -n "$remove_trash" 1222 then 1223 test -d "$TRASH_DIRECTORY" || 1224 error "Tests passed but trash directory already removed before test cleanup; aborting" 1225 1226 cd "$TRASH_DIRECTORY/.." && 1227 rm -fr "$TRASH_DIRECTORY" || { 1228 # try again in a bit 1229 sleep 5; 1230 rm -fr "$TRASH_DIRECTORY" 1231 } || 1232 error "Tests passed but test cleanup failed; aborting" 1233 fi 1234 test_at_end_hook_ 1235 1236 exit 0 ;; 1237 1238 *) 1239 if test $test_external_has_tap -eq 0 1240 then 1241 say_color error "# failed $test_failure among $msg" 1242 say "1..$test_count" 1243 fi 1244 1245 exit 1 ;; 1246 1247 esac 1248} 1249 1250if test -n "$valgrind" 1251then 1252 make_symlink () { 1253 test -h "$2" && 1254 test "$1" = "$(readlink "$2")" || { 1255 # be super paranoid 1256 if mkdir "$2".lock 1257 then 1258 rm -f "$2" && 1259 ln -s "$1" "$2" && 1260 rm -r "$2".lock 1261 else 1262 while test -d "$2".lock 1263 do 1264 say "Waiting for lock on $2." 1265 sleep 1 1266 done 1267 fi 1268 } 1269 } 1270 1271 make_valgrind_symlink () { 1272 # handle only executables, unless they are shell libraries that 1273 # need to be in the exec-path. 1274 test -x "$1" || 1275 test "# " = "$(test_copy_bytes 2 <"$1")" || 1276 return; 1277 1278 base=$(basename "$1") 1279 case "$base" in 1280 test-*) 1281 symlink_target="$GIT_BUILD_DIR/t/helper/$base" 1282 ;; 1283 *) 1284 symlink_target="$GIT_BUILD_DIR/$base" 1285 ;; 1286 esac 1287 # do not override scripts 1288 if test -x "$symlink_target" && 1289 test ! -d "$symlink_target" && 1290 test "#!" != "$(test_copy_bytes 2 <"$symlink_target")" 1291 then 1292 symlink_target=../valgrind.sh 1293 fi 1294 case "$base" in 1295 *.sh|*.perl) 1296 symlink_target=../unprocessed-script 1297 esac 1298 # create the link, or replace it if it is out of date 1299 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit 1300 } 1301 1302 # override all git executables in TEST_DIRECTORY/.. 1303 GIT_VALGRIND=$TEST_DIRECTORY/valgrind 1304 mkdir -p "$GIT_VALGRIND"/bin 1305 for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/t/helper/test-* 1306 do 1307 make_valgrind_symlink $file 1308 done 1309 # special-case the mergetools loadables 1310 make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools" 1311 OLDIFS=$IFS 1312 IFS=: 1313 for path in $PATH 1314 do 1315 ls "$path"/git-* 2> /dev/null | 1316 while read file 1317 do 1318 make_valgrind_symlink "$file" 1319 done 1320 done 1321 IFS=$OLDIFS 1322 PATH=$GIT_VALGRIND/bin:$PATH 1323 GIT_EXEC_PATH=$GIT_VALGRIND/bin 1324 export GIT_VALGRIND 1325 GIT_VALGRIND_MODE="$valgrind" 1326 export GIT_VALGRIND_MODE 1327 GIT_VALGRIND_ENABLED=t 1328 test -n "$valgrind_only" && GIT_VALGRIND_ENABLED= 1329 export GIT_VALGRIND_ENABLED 1330elif test -n "$GIT_TEST_INSTALLED" 1331then 1332 GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path) || 1333 error "Cannot run git from $GIT_TEST_INSTALLED." 1334 PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR/t/helper:$PATH 1335 GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH} 1336else # normal case, use ../bin-wrappers only unless $with_dashes: 1337 if test -n "$no_bin_wrappers" 1338 then 1339 with_dashes=t 1340 else 1341 git_bin_dir="$GIT_BUILD_DIR/bin-wrappers" 1342 if ! test -x "$git_bin_dir/git" 1343 then 1344 if test -z "$with_dashes" 1345 then 1346 say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH" 1347 fi 1348 with_dashes=t 1349 fi 1350 PATH="$git_bin_dir:$PATH" 1351 fi 1352 GIT_EXEC_PATH=$GIT_BUILD_DIR 1353 if test -n "$with_dashes" 1354 then 1355 PATH="$GIT_BUILD_DIR:$GIT_BUILD_DIR/t/helper:$PATH" 1356 fi 1357fi 1358GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt 1359GIT_CONFIG_NOSYSTEM=1 1360GIT_ATTR_NOSYSTEM=1 1361GIT_CEILING_DIRECTORIES="$TRASH_DIRECTORY/.." 1362export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM GIT_CEILING_DIRECTORIES 1363 1364if test -z "$GIT_TEST_CMP" 1365then 1366 if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT" 1367 then 1368 GIT_TEST_CMP="$DIFF -c" 1369 else 1370 GIT_TEST_CMP="$DIFF -u" 1371 fi 1372fi 1373 1374GITPERLLIB="$GIT_BUILD_DIR"/perl/build/lib 1375export GITPERLLIB 1376test -d "$GIT_BUILD_DIR"/templates/blt || { 1377 error "You haven't built things yet, have you?" 1378} 1379 1380if ! test -x "$GIT_BUILD_DIR"/t/helper/test-tool$X 1381then 1382 echo >&2 'You need to build test-tool:' 1383 echo >&2 'Run "make t/helper/test-tool" in the source (toplevel) directory' 1384 exit 1 1385fi 1386 1387# Are we running this test at all? 1388remove_trash= 1389this_test=${0##*/} 1390this_test=${this_test%%-*} 1391if match_pattern_list "$this_test" "$GIT_SKIP_TESTS" 1392then 1393 say_color info >&3 "skipping test $this_test altogether" 1394 skip_all="skip all tests in $this_test" 1395 test_done 1396fi 1397 1398# skip non-whitelisted tests when compiled with SANITIZE=leak 1399if test -n "$SANITIZE_LEAK" 1400then 1401 if test_bool_env GIT_TEST_PASSING_SANITIZE_LEAK false 1402 then 1403 # We need to see it in "git env--helper" (via 1404 # test_bool_env) 1405 export TEST_PASSES_SANITIZE_LEAK 1406 1407 if ! test_bool_env TEST_PASSES_SANITIZE_LEAK false 1408 then 1409 skip_all="skipping $this_test under GIT_TEST_PASSING_SANITIZE_LEAK=true" 1410 test_done 1411 fi 1412 fi 1413elif test_bool_env GIT_TEST_PASSING_SANITIZE_LEAK false 1414then 1415 BAIL_OUT "GIT_TEST_PASSING_SANITIZE_LEAK=true has no effect except when compiled with SANITIZE=leak" 1416fi 1417 1418# Last-minute variable setup 1419USER_HOME="$HOME" 1420HOME="$TRASH_DIRECTORY" 1421GNUPGHOME="$HOME/gnupg-home-not-used" 1422export HOME GNUPGHOME USER_HOME 1423 1424# "rm -rf" existing trash directory, even if a previous run left it 1425# with bad permissions. 1426remove_trash_directory () { 1427 dir="$1" 1428 if ! rm -rf "$dir" 2>/dev/null 1429 then 1430 chmod -R u+rwx "$dir" 1431 rm -rf "$dir" 1432 fi 1433 ! test -d "$dir" 1434} 1435 1436# Test repository 1437remove_trash_directory "$TRASH_DIRECTORY" || { 1438 GIT_EXIT_OK=t 1439 echo >&5 "FATAL: Cannot prepare test area" 1440 exit 1 1441} 1442 1443remove_trash=t 1444if test -z "$TEST_NO_CREATE_REPO" 1445then 1446 git init "$TRASH_DIRECTORY" >&3 2>&4 || 1447 error "cannot run git init" 1448else 1449 mkdir -p "$TRASH_DIRECTORY" 1450fi 1451 1452# Use -P to resolve symlinks in our working directory so that the cwd 1453# in subprocesses like git equals our $PWD (for pathname comparisons). 1454cd -P "$TRASH_DIRECTORY" || exit 1 1455 1456if test -n "$write_junit_xml" 1457then 1458 junit_xml_dir="$TEST_OUTPUT_DIRECTORY/out" 1459 mkdir -p "$junit_xml_dir" 1460 junit_xml_base=${0##*/} 1461 junit_xml_path="$junit_xml_dir/TEST-${junit_xml_base%.sh}.xml" 1462 junit_attrs="name=\"${junit_xml_base%.sh}\"" 1463 junit_attrs="$junit_attrs timestamp=\"$(TZ=UTC \ 1464 date +%Y-%m-%dT%H:%M:%S)\"" 1465 write_junit_xml --truncate "<testsuites>" " <testsuite $junit_attrs>" 1466 junit_suite_start=$(test-tool date getnanos) 1467 if test -n "$GIT_TEST_TEE_OUTPUT_FILE" 1468 then 1469 GIT_TEST_TEE_OFFSET=0 1470 fi 1471fi 1472 1473# Convenience 1474# A regexp to match 5 and 35 hexdigits 1475_x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]' 1476_x35="$_x05$_x05$_x05$_x05$_x05$_x05$_x05" 1477 1478test_oid_init 1479 1480ZERO_OID=$(test_oid zero) 1481OID_REGEX=$(echo $ZERO_OID | sed -e 's/0/[0-9a-f]/g') 1482OIDPATH_REGEX=$(test_oid_to_path $ZERO_OID | sed -e 's/0/[0-9a-f]/g') 1483EMPTY_TREE=$(test_oid empty_tree) 1484EMPTY_BLOB=$(test_oid empty_blob) 1485 1486# Provide an implementation of the 'yes' utility; the upper bound 1487# limit is there to help Windows that cannot stop this loop from 1488# wasting cycles when the downstream stops reading, so do not be 1489# tempted to turn it into an infinite loop. cf. 6129c930 ("test-lib: 1490# limit the output of the yes utility", 2016-02-02) 1491yes () { 1492 if test $# = 0 1493 then 1494 y=y 1495 else 1496 y="$*" 1497 fi 1498 1499 i=0 1500 while test $i -lt 99 1501 do 1502 echo "$y" 1503 i=$(($i+1)) 1504 done 1505} 1506 1507# The GIT_TEST_FAIL_PREREQS code hooks into test_set_prereq(), and 1508# thus needs to be set up really early, and set an internal variable 1509# for convenience so the hot test_set_prereq() codepath doesn't need 1510# to call "git env--helper" (via test_bool_env). Only do that work 1511# if needed by seeing if GIT_TEST_FAIL_PREREQS is set at all. 1512GIT_TEST_FAIL_PREREQS_INTERNAL= 1513if test -n "$GIT_TEST_FAIL_PREREQS" 1514then 1515 if test_bool_env GIT_TEST_FAIL_PREREQS false 1516 then 1517 GIT_TEST_FAIL_PREREQS_INTERNAL=true 1518 test_set_prereq FAIL_PREREQS 1519 fi 1520else 1521 test_lazy_prereq FAIL_PREREQS ' 1522 test_bool_env GIT_TEST_FAIL_PREREQS false 1523 ' 1524fi 1525 1526# Fix some commands on Windows, and other OS-specific things 1527uname_s=$(uname -s) 1528case $uname_s in 1529*MINGW*) 1530 # Windows has its own (incompatible) sort and find 1531 sort () { 1532 /usr/bin/sort "$@" 1533 } 1534 find () { 1535 /usr/bin/find "$@" 1536 } 1537 # git sees Windows-style pwd 1538 pwd () { 1539 builtin pwd -W 1540 } 1541 # no POSIX permissions 1542 # backslashes in pathspec are converted to '/' 1543 # exec does not inherit the PID 1544 test_set_prereq MINGW 1545 test_set_prereq NATIVE_CRLF 1546 test_set_prereq SED_STRIPS_CR 1547 test_set_prereq GREP_STRIPS_CR 1548 test_set_prereq WINDOWS 1549 GIT_TEST_CMP=mingw_test_cmp 1550 ;; 1551*CYGWIN*) 1552 test_set_prereq POSIXPERM 1553 test_set_prereq EXECKEEPSPID 1554 test_set_prereq CYGWIN 1555 test_set_prereq SED_STRIPS_CR 1556 test_set_prereq GREP_STRIPS_CR 1557 test_set_prereq WINDOWS 1558 ;; 1559*) 1560 test_set_prereq POSIXPERM 1561 test_set_prereq BSLASHPSPEC 1562 test_set_prereq EXECKEEPSPID 1563 ;; 1564esac 1565 1566# Detect arches where a few things don't work 1567uname_m=$(uname -m) 1568case $uname_m in 1569parisc* | hppa*) 1570 test_set_prereq HPPA 1571 ;; 1572esac 1573 1574test_set_prereq REFFILES 1575 1576( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_1 1577test -z "$NO_PERL" && test_set_prereq PERL 1578test -z "$NO_PTHREADS" && test_set_prereq PTHREADS 1579test -z "$NO_PYTHON" && test_set_prereq PYTHON 1580test -n "$USE_LIBPCRE2" && test_set_prereq PCRE 1581test -n "$USE_LIBPCRE2" && test_set_prereq LIBPCRE2 1582test -z "$NO_GETTEXT" && test_set_prereq GETTEXT 1583test -n "$SANITIZE_LEAK" && test_set_prereq SANITIZE_LEAK 1584 1585if test -z "$GIT_TEST_CHECK_CACHE_TREE" 1586then 1587 GIT_TEST_CHECK_CACHE_TREE=true 1588 export GIT_TEST_CHECK_CACHE_TREE 1589fi 1590 1591test_lazy_prereq PIPE ' 1592 # test whether the filesystem supports FIFOs 1593 test_have_prereq !MINGW,!CYGWIN && 1594 rm -f testfifo && mkfifo testfifo 1595' 1596 1597test_lazy_prereq SYMLINKS ' 1598 # test whether the filesystem supports symbolic links 1599 ln -s x y && test -h y 1600' 1601 1602test_lazy_prereq SYMLINKS_WINDOWS ' 1603 # test whether symbolic links are enabled on Windows 1604 test_have_prereq MINGW && 1605 cmd //c "mklink y x" &> /dev/null && test -h y 1606' 1607 1608test_lazy_prereq FILEMODE ' 1609 test "$(git config --bool core.filemode)" = true 1610' 1611 1612test_lazy_prereq CASE_INSENSITIVE_FS ' 1613 echo good >CamelCase && 1614 echo bad >camelcase && 1615 test "$(cat CamelCase)" != good 1616' 1617 1618test_lazy_prereq FUNNYNAMES ' 1619 test_have_prereq !MINGW && 1620 touch -- \ 1621 "FUNNYNAMES tab embedded" \ 1622 "FUNNYNAMES \"quote embedded\"" \ 1623 "FUNNYNAMES newline 1624embedded" 2>/dev/null && 1625 rm -- \ 1626 "FUNNYNAMES tab embedded" \ 1627 "FUNNYNAMES \"quote embedded\"" \ 1628 "FUNNYNAMES newline 1629embedded" 2>/dev/null 1630' 1631 1632test_lazy_prereq UTF8_NFD_TO_NFC ' 1633 # check whether FS converts nfd unicode to nfc 1634 auml=$(printf "\303\244") 1635 aumlcdiar=$(printf "\141\314\210") 1636 >"$auml" && 1637 test -f "$aumlcdiar" 1638' 1639 1640test_lazy_prereq AUTOIDENT ' 1641 sane_unset GIT_AUTHOR_NAME && 1642 sane_unset GIT_AUTHOR_EMAIL && 1643 git var GIT_AUTHOR_IDENT 1644' 1645 1646test_lazy_prereq EXPENSIVE ' 1647 test -n "$GIT_TEST_LONG" 1648' 1649 1650test_lazy_prereq EXPENSIVE_ON_WINDOWS ' 1651 test_have_prereq EXPENSIVE || test_have_prereq !MINGW,!CYGWIN 1652' 1653 1654test_lazy_prereq USR_BIN_TIME ' 1655 test -x /usr/bin/time 1656' 1657 1658test_lazy_prereq NOT_ROOT ' 1659 uid=$(id -u) && 1660 test "$uid" != 0 1661' 1662 1663test_lazy_prereq JGIT ' 1664 jgit --version 1665' 1666 1667# SANITY is about "can you correctly predict what the filesystem would 1668# do by only looking at the permission bits of the files and 1669# directories?" A typical example of !SANITY is running the test 1670# suite as root, where a test may expect "chmod -r file && cat file" 1671# to fail because file is supposed to be unreadable after a successful 1672# chmod. In an environment (i.e. combination of what filesystem is 1673# being used and who is running the tests) that lacks SANITY, you may 1674# be able to delete or create a file when the containing directory 1675# doesn't have write permissions, or access a file even if the 1676# containing directory doesn't have read or execute permissions. 1677 1678test_lazy_prereq SANITY ' 1679 mkdir SANETESTD.1 SANETESTD.2 && 1680 1681 chmod +w SANETESTD.1 SANETESTD.2 && 1682 >SANETESTD.1/x 2>SANETESTD.2/x && 1683 chmod -w SANETESTD.1 && 1684 chmod -r SANETESTD.1/x && 1685 chmod -rx SANETESTD.2 || 1686 BUG "cannot prepare SANETESTD" 1687 1688 ! test -r SANETESTD.1/x && 1689 ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x 1690 status=$? 1691 1692 chmod +rwx SANETESTD.1 SANETESTD.2 && 1693 rm -rf SANETESTD.1 SANETESTD.2 || 1694 BUG "cannot clean SANETESTD" 1695 return $status 1696' 1697 1698test FreeBSD != $uname_s || GIT_UNZIP=${GIT_UNZIP:-/usr/local/bin/unzip} 1699GIT_UNZIP=${GIT_UNZIP:-unzip} 1700test_lazy_prereq UNZIP ' 1701 "$GIT_UNZIP" -v 1702 test $? -ne 127 1703' 1704 1705run_with_limited_cmdline () { 1706 (ulimit -s 128 && "$@") 1707} 1708 1709test_lazy_prereq CMDLINE_LIMIT ' 1710 test_have_prereq !HPPA,!MINGW,!CYGWIN && 1711 run_with_limited_cmdline true 1712' 1713 1714run_with_limited_stack () { 1715 (ulimit -s 128 && "$@") 1716} 1717 1718test_lazy_prereq ULIMIT_STACK_SIZE ' 1719 test_have_prereq !HPPA,!MINGW,!CYGWIN && 1720 run_with_limited_stack true 1721' 1722 1723run_with_limited_open_files () { 1724 (ulimit -n 32 && "$@") 1725} 1726 1727test_lazy_prereq ULIMIT_FILE_DESCRIPTORS ' 1728 test_have_prereq !MINGW,!CYGWIN && 1729 run_with_limited_open_files true 1730' 1731 1732build_option () { 1733 git version --build-options | 1734 sed -ne "s/^$1: //p" 1735} 1736 1737test_lazy_prereq LONG_IS_64BIT ' 1738 test 8 -le "$(build_option sizeof-long)" 1739' 1740 1741test_lazy_prereq TIME_IS_64BIT 'test-tool date is64bit' 1742test_lazy_prereq TIME_T_IS_64BIT 'test-tool date time_t-is64bit' 1743 1744test_lazy_prereq CURL ' 1745 curl --version 1746' 1747 1748# SHA1 is a test if the hash algorithm in use is SHA-1. This is both for tests 1749# which will not work with other hash algorithms and tests that work but don't 1750# test anything meaningful (e.g. special values which cause short collisions). 1751test_lazy_prereq SHA1 ' 1752 case "$GIT_DEFAULT_HASH" in 1753 sha1) true ;; 1754 "") test $(git hash-object /dev/null) = e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 ;; 1755 *) false ;; 1756 esac 1757' 1758 1759# Ensure that no test accidentally triggers a Git command 1760# that runs the actual maintenance scheduler, affecting a user's 1761# system permanently. 1762# Tests that verify the scheduler integration must set this locally 1763# to avoid errors. 1764GIT_TEST_MAINT_SCHEDULER="none:exit 1" 1765