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# Disallow the use of abbreviated options in the test suite by default 61if test -z "${GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS}" 62then 63 GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS=true 64 export GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS 65fi 66 67################################################################ 68# It appears that people try to run tests without building... 69"${GIT_TEST_INSTALLED:-$GIT_BUILD_DIR}/git$X" >/dev/null 70if test $? != 1 71then 72 if test -n "$GIT_TEST_INSTALLED" 73 then 74 echo >&2 "error: there is no working Git at '$GIT_TEST_INSTALLED'" 75 else 76 echo >&2 'error: you do not seem to have built git yet.' 77 fi 78 exit 1 79fi 80 81# Parse options while taking care to leave $@ intact, so we will still 82# have all the original command line options when executing the test 83# script again for '--tee' and '--verbose-log' below. 84store_arg_to= 85prev_opt= 86for opt 87do 88 if test -n "$store_arg_to" 89 then 90 eval $store_arg_to=\$opt 91 store_arg_to= 92 prev_opt= 93 continue 94 fi 95 96 case "$opt" in 97 -d|--d|--de|--deb|--debu|--debug) 98 debug=t ;; 99 -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate) 100 immediate=t ;; 101 -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests) 102 GIT_TEST_LONG=t; export GIT_TEST_LONG ;; 103 -r) 104 store_arg_to=run_list 105 ;; 106 --run=*) 107 run_list=${opt#--*=} ;; 108 -h|--h|--he|--hel|--help) 109 help=t ;; 110 -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose) 111 verbose=t ;; 112 --verbose-only=*) 113 verbose_only=${opt#--*=} 114 ;; 115 -q|--q|--qu|--qui|--quie|--quiet) 116 # Ignore --quiet under a TAP::Harness. Saying how many tests 117 # passed without the ok/not ok details is always an error. 118 test -z "$HARNESS_ACTIVE" && quiet=t ;; 119 --with-dashes) 120 with_dashes=t ;; 121 --no-bin-wrappers) 122 no_bin_wrappers=t ;; 123 --no-color) 124 color= ;; 125 --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind) 126 valgrind=memcheck 127 tee=t 128 ;; 129 --valgrind=*) 130 valgrind=${opt#--*=} 131 tee=t 132 ;; 133 --valgrind-only=*) 134 valgrind_only=${opt#--*=} 135 tee=t 136 ;; 137 --tee) 138 tee=t ;; 139 --root=*) 140 root=${opt#--*=} ;; 141 --chain-lint) 142 GIT_TEST_CHAIN_LINT=1 ;; 143 --no-chain-lint) 144 GIT_TEST_CHAIN_LINT=0 ;; 145 -x) 146 trace=t ;; 147 -V|--verbose-log) 148 verbose_log=t 149 tee=t 150 ;; 151 --write-junit-xml) 152 write_junit_xml=t 153 ;; 154 --stress) 155 stress=t ;; 156 --stress=*) 157 echo "error: --stress does not accept an argument: '$opt'" >&2 158 echo "did you mean --stress-jobs=${opt#*=} or --stress-limit=${opt#*=}?" >&2 159 exit 1 160 ;; 161 --stress-jobs=*) 162 stress=t; 163 stress=${opt#--*=} 164 case "$stress" in 165 *[!0-9]*|0*|"") 166 echo "error: --stress-jobs=<N> requires the number of jobs to run" >&2 167 exit 1 168 ;; 169 *) # Good. 170 ;; 171 esac 172 ;; 173 --stress-limit=*) 174 stress=t; 175 stress_limit=${opt#--*=} 176 case "$stress_limit" in 177 *[!0-9]*|0*|"") 178 echo "error: --stress-limit=<N> requires the number of repetitions" >&2 179 exit 1 180 ;; 181 *) # Good. 182 ;; 183 esac 184 ;; 185 *) 186 echo "error: unknown test option '$opt'" >&2; exit 1 ;; 187 esac 188 189 prev_opt=$opt 190done 191if test -n "$store_arg_to" 192then 193 echo "error: $prev_opt requires an argument" >&2 194 exit 1 195fi 196 197if test -n "$valgrind_only" 198then 199 test -z "$valgrind" && valgrind=memcheck 200 test -z "$verbose" && verbose_only="$valgrind_only" 201elif test -n "$valgrind" 202then 203 test -z "$verbose_log" && verbose=t 204fi 205 206if test -n "$stress" 207then 208 verbose=t 209 trace=t 210 immediate=t 211fi 212 213TEST_STRESS_JOB_SFX="${GIT_TEST_STRESS_JOB_NR:+.stress-$GIT_TEST_STRESS_JOB_NR}" 214TEST_NAME="$(basename "$0" .sh)" 215TEST_RESULTS_DIR="$TEST_OUTPUT_DIRECTORY/test-results" 216TEST_RESULTS_BASE="$TEST_RESULTS_DIR/$TEST_NAME$TEST_STRESS_JOB_SFX" 217TRASH_DIRECTORY="trash directory.$TEST_NAME$TEST_STRESS_JOB_SFX" 218test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY" 219case "$TRASH_DIRECTORY" in 220/*) ;; # absolute path is good 221 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;; 222esac 223 224# If --stress was passed, run this test repeatedly in several parallel loops. 225if test "$GIT_TEST_STRESS_STARTED" = "done" 226then 227 : # Don't stress test again. 228elif test -n "$stress" 229then 230 if test "$stress" != t 231 then 232 job_count=$stress 233 elif test -n "$GIT_TEST_STRESS_LOAD" 234 then 235 job_count="$GIT_TEST_STRESS_LOAD" 236 elif job_count=$(getconf _NPROCESSORS_ONLN 2>/dev/null) && 237 test -n "$job_count" 238 then 239 job_count=$((2 * $job_count)) 240 else 241 job_count=8 242 fi 243 244 mkdir -p "$TEST_RESULTS_DIR" 245 stressfail="$TEST_RESULTS_BASE.stress-failed" 246 rm -f "$stressfail" 247 248 stress_exit=0 249 trap ' 250 kill $job_pids 2>/dev/null 251 wait 252 stress_exit=1 253 ' TERM INT HUP 254 255 job_pids= 256 job_nr=0 257 while test $job_nr -lt "$job_count" 258 do 259 ( 260 GIT_TEST_STRESS_STARTED=done 261 GIT_TEST_STRESS_JOB_NR=$job_nr 262 export GIT_TEST_STRESS_STARTED GIT_TEST_STRESS_JOB_NR 263 264 trap ' 265 kill $test_pid 2>/dev/null 266 wait 267 exit 1 268 ' TERM INT 269 270 cnt=1 271 while ! test -e "$stressfail" && 272 { test -z "$stress_limit" || 273 test $cnt -le $stress_limit ; } 274 do 275 $TEST_SHELL_PATH "$0" "$@" >"$TEST_RESULTS_BASE.stress-$job_nr.out" 2>&1 & 276 test_pid=$! 277 278 if wait $test_pid 279 then 280 printf "OK %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt 281 else 282 echo $GIT_TEST_STRESS_JOB_NR >>"$stressfail" 283 printf "FAIL %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt 284 fi 285 cnt=$(($cnt + 1)) 286 done 287 ) & 288 job_pids="$job_pids $!" 289 job_nr=$(($job_nr + 1)) 290 done 291 292 wait 293 294 if test -f "$stressfail" 295 then 296 stress_exit=1 297 echo "Log(s) of failed test run(s):" 298 for failed_job_nr in $(sort -n "$stressfail") 299 do 300 echo "Contents of '$TEST_RESULTS_BASE.stress-$failed_job_nr.out':" 301 cat "$TEST_RESULTS_BASE.stress-$failed_job_nr.out" 302 done 303 rm -rf "$TRASH_DIRECTORY.stress-failed" 304 # Move the last one. 305 mv "$TRASH_DIRECTORY.stress-$failed_job_nr" "$TRASH_DIRECTORY.stress-failed" 306 fi 307 308 exit $stress_exit 309fi 310 311# if --tee was passed, write the output not only to the terminal, but 312# additionally to the file test-results/$BASENAME.out, too. 313if test "$GIT_TEST_TEE_STARTED" = "done" 314then 315 : # do not redirect again 316elif test -n "$tee" 317then 318 mkdir -p "$TEST_RESULTS_DIR" 319 320 # Make this filename available to the sub-process in case it is using 321 # --verbose-log. 322 GIT_TEST_TEE_OUTPUT_FILE=$TEST_RESULTS_BASE.out 323 export GIT_TEST_TEE_OUTPUT_FILE 324 325 # Truncate before calling "tee -a" to get rid of the results 326 # from any previous runs. 327 >"$GIT_TEST_TEE_OUTPUT_FILE" 328 329 (GIT_TEST_TEE_STARTED=done ${TEST_SHELL_PATH} "$0" "$@" 2>&1; 330 echo $? >"$TEST_RESULTS_BASE.exit") | tee -a "$GIT_TEST_TEE_OUTPUT_FILE" 331 test "$(cat "$TEST_RESULTS_BASE.exit")" = 0 332 exit 333fi 334 335if test -n "$trace" && test -n "$test_untraceable" 336then 337 # '-x' tracing requested, but this test script can't be reliably 338 # traced, unless it is run with a Bash version supporting 339 # BASH_XTRACEFD (introduced in Bash v4.1). 340 # 341 # Perform this version check _after_ the test script was 342 # potentially re-executed with $TEST_SHELL_PATH for '--tee' or 343 # '--verbose-log', so the right shell is checked and the 344 # warning is issued only once. 345 if test -n "$BASH_VERSION" && eval ' 346 test ${BASH_VERSINFO[0]} -gt 4 || { 347 test ${BASH_VERSINFO[0]} -eq 4 && 348 test ${BASH_VERSINFO[1]} -ge 1 349 } 350 ' 351 then 352 : Executed by a Bash version supporting BASH_XTRACEFD. Good. 353 else 354 echo >&2 "warning: ignoring -x; '$0' is untraceable without BASH_XTRACEFD" 355 trace= 356 fi 357fi 358if test -n "$trace" && test -z "$verbose_log" 359then 360 verbose=t 361fi 362 363# For repeatability, reset the environment to known value. 364# TERM is sanitized below, after saving color control sequences. 365LANG=C 366LC_ALL=C 367PAGER=cat 368TZ=UTC 369export LANG LC_ALL PAGER TZ 370EDITOR=: 371 372# GIT_TEST_GETTEXT_POISON should not influence git commands executed 373# during initialization of test-lib and the test repo. Back it up, 374# unset and then restore after initialization is finished. 375if test -n "$GIT_TEST_GETTEXT_POISON" 376then 377 GIT_TEST_GETTEXT_POISON_ORIG=$GIT_TEST_GETTEXT_POISON 378 unset GIT_TEST_GETTEXT_POISON 379fi 380 381# A call to "unset" with no arguments causes at least Solaris 10 382# /usr/xpg4/bin/sh and /bin/ksh to bail out. So keep the unsets 383# deriving from the command substitution clustered with the other 384# ones. 385unset VISUAL EMAIL LANGUAGE COLUMNS $("$PERL_PATH" -e ' 386 my @env = keys %ENV; 387 my $ok = join("|", qw( 388 TRACE 389 TR2_ 390 DEBUG 391 TEST 392 .*_TEST 393 PROVE 394 VALGRIND 395 UNZIP 396 PERF_ 397 CURL_VERBOSE 398 TRACE_CURL 399 )); 400 my @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env); 401 print join("\n", @vars); 402') 403unset XDG_CACHE_HOME 404unset XDG_CONFIG_HOME 405unset GITPERLLIB 406GIT_AUTHOR_EMAIL=author@example.com 407GIT_AUTHOR_NAME='A U Thor' 408GIT_COMMITTER_EMAIL=committer@example.com 409GIT_COMMITTER_NAME='C O Mitter' 410GIT_MERGE_VERBOSITY=5 411GIT_MERGE_AUTOEDIT=no 412export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT 413export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME 414export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME 415export EDITOR 416 417# Tests using GIT_TRACE typically don't want <timestamp> <file>:<line> output 418GIT_TRACE_BARE=1 419export GIT_TRACE_BARE 420 421check_var_migration () { 422 # the warnings and hints given from this helper depends 423 # on end-user settings, which will disrupt the self-test 424 # done on the test framework itself. 425 case "$GIT_TEST_FRAMEWORK_SELFTEST" in 426 t) return ;; 427 esac 428 429 old_name=$1 new_name=$2 430 eval "old_isset=\${${old_name}:+isset}" 431 eval "new_isset=\${${new_name}:+isset}" 432 433 case "$old_isset,$new_isset" in 434 isset,) 435 echo >&2 "warning: $old_name is now $new_name" 436 echo >&2 "hint: set $new_name too during the transition period" 437 eval "$new_name=\$$old_name" 438 ;; 439 isset,isset) 440 # do this later 441 # echo >&2 "warning: $old_name is now $new_name" 442 # echo >&2 "hint: remove $old_name" 443 ;; 444 esac 445} 446 447check_var_migration GIT_FSMONITOR_TEST GIT_TEST_FSMONITOR 448check_var_migration TEST_GIT_INDEX_VERSION GIT_TEST_INDEX_VERSION 449check_var_migration GIT_FORCE_PRELOAD_TEST GIT_TEST_PRELOAD_INDEX 450 451# Use specific version of the index file format 452if test -n "${GIT_TEST_INDEX_VERSION:+isset}" 453then 454 GIT_INDEX_VERSION="$GIT_TEST_INDEX_VERSION" 455 export GIT_INDEX_VERSION 456fi 457 458# Add libc MALLOC and MALLOC_PERTURB test 459# only if we are not executing the test with valgrind 460if test -n "$valgrind" || 461 test -n "$TEST_NO_MALLOC_CHECK" 462then 463 setup_malloc_check () { 464 : nothing 465 } 466 teardown_malloc_check () { 467 : nothing 468 } 469else 470 setup_malloc_check () { 471 MALLOC_CHECK_=3 MALLOC_PERTURB_=165 472 export MALLOC_CHECK_ MALLOC_PERTURB_ 473 } 474 teardown_malloc_check () { 475 unset MALLOC_CHECK_ MALLOC_PERTURB_ 476 } 477fi 478 479# Protect ourselves from common misconfiguration to export 480# CDPATH into the environment 481unset CDPATH 482 483unset GREP_OPTIONS 484unset UNZIP 485 486case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in 4871|2|true) 488 GIT_TRACE=4 489 ;; 490esac 491 492# Convenience 493# 494# A regexp to match 5, 35 and 40 hexdigits 495_x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]' 496_x35="$_x05$_x05$_x05$_x05$_x05$_x05$_x05" 497_x40="$_x35$_x05" 498 499# Zero SHA-1 500_z40=0000000000000000000000000000000000000000 501 502OID_REGEX="$_x40" 503ZERO_OID=$_z40 504EMPTY_TREE=4b825dc642cb6eb9a060e54bf8d69288fbee4904 505EMPTY_BLOB=e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 506 507# Line feed 508LF=' 509' 510 511# UTF-8 ZERO WIDTH NON-JOINER, which HFS+ ignores 512# when case-folding filenames 513u200c=$(printf '\342\200\214') 514 515export _x05 _x35 _x40 _z40 LF u200c EMPTY_TREE EMPTY_BLOB ZERO_OID OID_REGEX 516 517# Each test should start with something like this, after copyright notices: 518# 519# test_description='Description of this test... 520# This test checks if command xyzzy does the right thing... 521# ' 522# . ./test-lib.sh 523test "x$TERM" != "xdumb" && ( 524 test -t 1 && 525 tput bold >/dev/null 2>&1 && 526 tput setaf 1 >/dev/null 2>&1 && 527 tput sgr0 >/dev/null 2>&1 528 ) && 529 color=t 530 531if test -n "$color" 532then 533 # Save the color control sequences now rather than run tput 534 # each time say_color() is called. This is done for two 535 # reasons: 536 # * TERM will be changed to dumb 537 # * HOME will be changed to a temporary directory and tput 538 # might need to read ~/.terminfo from the original HOME 539 # directory to get the control sequences 540 # Note: This approach assumes the control sequences don't end 541 # in a newline for any terminal of interest (command 542 # substitutions strip trailing newlines). Given that most 543 # (all?) terminals in common use are related to ECMA-48, this 544 # shouldn't be a problem. 545 say_color_error=$(tput bold; tput setaf 1) # bold red 546 say_color_skip=$(tput setaf 4) # blue 547 say_color_warn=$(tput setaf 3) # brown/yellow 548 say_color_pass=$(tput setaf 2) # green 549 say_color_info=$(tput setaf 6) # cyan 550 say_color_reset=$(tput sgr0) 551 say_color_="" # no formatting for normal text 552 say_color () { 553 test -z "$1" && test -n "$quiet" && return 554 eval "say_color_color=\$say_color_$1" 555 shift 556 printf "%s\\n" "$say_color_color$*$say_color_reset" 557 } 558else 559 say_color() { 560 test -z "$1" && test -n "$quiet" && return 561 shift 562 printf "%s\n" "$*" 563 } 564fi 565 566TERM=dumb 567export TERM 568 569error () { 570 say_color error "error: $*" 571 GIT_EXIT_OK=t 572 exit 1 573} 574 575BUG () { 576 error >&7 "bug in the test script: $*" 577} 578 579say () { 580 say_color info "$*" 581} 582 583if test -n "$HARNESS_ACTIVE" 584then 585 if test "$verbose" = t || test -n "$verbose_only" 586 then 587 printf 'Bail out! %s\n' \ 588 'verbose mode forbidden under TAP harness; try --verbose-log' 589 exit 1 590 fi 591fi 592 593test "${test_description}" != "" || 594error "Test script did not set test_description." 595 596if test "$help" = "t" 597then 598 printf '%s\n' "$test_description" 599 exit 0 600fi 601 602exec 5>&1 603exec 6<&0 604exec 7>&2 605if test "$verbose_log" = "t" 606then 607 exec 3>>"$GIT_TEST_TEE_OUTPUT_FILE" 4>&3 608elif test "$verbose" = "t" 609then 610 exec 4>&2 3>&1 611else 612 exec 4>/dev/null 3>/dev/null 613fi 614 615# Send any "-x" output directly to stderr to avoid polluting tests 616# which capture stderr. We can do this unconditionally since it 617# has no effect if tracing isn't turned on. 618# 619# Note that this sets up the trace fd as soon as we assign the variable, so it 620# must come after the creation of descriptor 4 above. Likewise, we must never 621# unset this, as it has the side effect of closing descriptor 4, which we 622# use to show verbose tests to the user. 623# 624# Note also that we don't need or want to export it. The tracing is local to 625# this shell, and we would not want to influence any shells we exec. 626BASH_XTRACEFD=4 627 628test_failure=0 629test_count=0 630test_fixed=0 631test_broken=0 632test_success=0 633 634test_external_has_tap=0 635 636die () { 637 code=$? 638 # This is responsible for running the atexit commands even when a 639 # test script run with '--immediate' fails, or when the user hits 640 # ctrl-C, i.e. when 'test_done' is not invoked at all. 641 test_atexit_handler || code=$? 642 if test -n "$GIT_EXIT_OK" 643 then 644 exit $code 645 else 646 echo >&5 "FATAL: Unexpected exit with code $code" 647 exit 1 648 fi 649} 650 651GIT_EXIT_OK= 652trap 'die' EXIT 653# Disable '-x' tracing, because with some shells, notably dash, it 654# prevents running the cleanup commands when a test script run with 655# '--verbose-log -x' is interrupted. 656trap '{ code=$?; set +x; } 2>/dev/null; exit $code' INT TERM HUP 657 658# The user-facing functions are loaded from a separate file so that 659# test_perf subshells can have them too 660. "$TEST_DIRECTORY/test-lib-functions.sh" 661 662# You are not expected to call test_ok_ and test_failure_ directly, use 663# the test_expect_* functions instead. 664 665test_ok_ () { 666 if test -n "$write_junit_xml" 667 then 668 write_junit_xml_testcase "$*" 669 fi 670 test_success=$(($test_success + 1)) 671 say_color "" "ok $test_count - $@" 672} 673 674test_failure_ () { 675 if test -n "$write_junit_xml" 676 then 677 junit_insert="<failure message=\"not ok $test_count -" 678 junit_insert="$junit_insert $(xml_attr_encode "$1")\">" 679 junit_insert="$junit_insert $(xml_attr_encode \ 680 "$(if test -n "$GIT_TEST_TEE_OUTPUT_FILE" 681 then 682 test-tool path-utils skip-n-bytes \ 683 "$GIT_TEST_TEE_OUTPUT_FILE" $GIT_TEST_TEE_OFFSET 684 else 685 printf '%s\n' "$@" | sed 1d 686 fi)")" 687 junit_insert="$junit_insert</failure>" 688 if test -n "$GIT_TEST_TEE_OUTPUT_FILE" 689 then 690 junit_insert="$junit_insert<system-err>$(xml_attr_encode \ 691 "$(cat "$GIT_TEST_TEE_OUTPUT_FILE")")</system-err>" 692 fi 693 write_junit_xml_testcase "$1" " $junit_insert" 694 fi 695 test_failure=$(($test_failure + 1)) 696 say_color error "not ok $test_count - $1" 697 shift 698 printf '%s\n' "$*" | sed -e 's/^/# /' 699 test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; } 700} 701 702test_known_broken_ok_ () { 703 if test -n "$write_junit_xml" 704 then 705 write_junit_xml_testcase "$* (breakage fixed)" 706 fi 707 test_fixed=$(($test_fixed+1)) 708 say_color error "ok $test_count - $@ # TODO known breakage vanished" 709} 710 711test_known_broken_failure_ () { 712 if test -n "$write_junit_xml" 713 then 714 write_junit_xml_testcase "$* (known breakage)" 715 fi 716 test_broken=$(($test_broken+1)) 717 say_color warn "not ok $test_count - $@ # TODO known breakage" 718} 719 720test_debug () { 721 test "$debug" = "" || eval "$1" 722} 723 724match_pattern_list () { 725 arg="$1" 726 shift 727 test -z "$*" && return 1 728 for pattern_ 729 do 730 case "$arg" in 731 $pattern_) 732 return 0 733 esac 734 done 735 return 1 736} 737 738match_test_selector_list () { 739 title="$1" 740 shift 741 arg="$1" 742 shift 743 test -z "$1" && return 0 744 745 # Both commas and whitespace are accepted as separators. 746 OLDIFS=$IFS 747 IFS=' ,' 748 set -- $1 749 IFS=$OLDIFS 750 751 # If the first selector is negative we include by default. 752 include= 753 case "$1" in 754 !*) include=t ;; 755 esac 756 757 for selector 758 do 759 orig_selector=$selector 760 761 positive=t 762 case "$selector" in 763 !*) 764 positive= 765 selector=${selector##?} 766 ;; 767 esac 768 769 test -z "$selector" && continue 770 771 case "$selector" in 772 *-*) 773 if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null 774 then 775 echo "error: $title: invalid non-numeric in range" \ 776 "start: '$orig_selector'" >&2 777 exit 1 778 fi 779 if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null 780 then 781 echo "error: $title: invalid non-numeric in range" \ 782 "end: '$orig_selector'" >&2 783 exit 1 784 fi 785 ;; 786 *) 787 if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null 788 then 789 echo "error: $title: invalid non-numeric in test" \ 790 "selector: '$orig_selector'" >&2 791 exit 1 792 fi 793 esac 794 795 # Short cut for "obvious" cases 796 test -z "$include" && test -z "$positive" && continue 797 test -n "$include" && test -n "$positive" && continue 798 799 case "$selector" in 800 -*) 801 if test $arg -le ${selector#-} 802 then 803 include=$positive 804 fi 805 ;; 806 *-) 807 if test $arg -ge ${selector%-} 808 then 809 include=$positive 810 fi 811 ;; 812 *-*) 813 if test ${selector%%-*} -le $arg \ 814 && test $arg -le ${selector#*-} 815 then 816 include=$positive 817 fi 818 ;; 819 *) 820 if test $arg -eq $selector 821 then 822 include=$positive 823 fi 824 ;; 825 esac 826 done 827 828 test -n "$include" 829} 830 831maybe_teardown_verbose () { 832 test -z "$verbose_only" && return 833 exec 4>/dev/null 3>/dev/null 834 verbose= 835} 836 837last_verbose=t 838maybe_setup_verbose () { 839 test -z "$verbose_only" && return 840 if match_pattern_list $test_count $verbose_only 841 then 842 exec 4>&2 3>&1 843 # Emit a delimiting blank line when going from 844 # non-verbose to verbose. Within verbose mode the 845 # delimiter is printed by test_expect_*. The choice 846 # of the initial $last_verbose is such that before 847 # test 1, we do not print it. 848 test -z "$last_verbose" && echo >&3 "" 849 verbose=t 850 else 851 exec 4>/dev/null 3>/dev/null 852 verbose= 853 fi 854 last_verbose=$verbose 855} 856 857maybe_teardown_valgrind () { 858 test -z "$GIT_VALGRIND" && return 859 GIT_VALGRIND_ENABLED= 860} 861 862maybe_setup_valgrind () { 863 test -z "$GIT_VALGRIND" && return 864 if test -z "$valgrind_only" 865 then 866 GIT_VALGRIND_ENABLED=t 867 return 868 fi 869 GIT_VALGRIND_ENABLED= 870 if match_pattern_list $test_count $valgrind_only 871 then 872 GIT_VALGRIND_ENABLED=t 873 fi 874} 875 876want_trace () { 877 test "$trace" = t && { 878 test "$verbose" = t || test "$verbose_log" = t 879 } 880} 881 882# This is a separate function because some tests use 883# "return" to end a test_expect_success block early 884# (and we want to make sure we run any cleanup like 885# "set +x"). 886test_eval_inner_ () { 887 # Do not add anything extra (including LF) after '$*' 888 eval " 889 want_trace && set -x 890 $*" 891} 892 893test_eval_ () { 894 # If "-x" tracing is in effect, then we want to avoid polluting stderr 895 # with non-test commands. But once in "set -x" mode, we cannot prevent 896 # the shell from printing the "set +x" to turn it off (nor the saving 897 # of $? before that). But we can make sure that the output goes to 898 # /dev/null. 899 # 900 # There are a few subtleties here: 901 # 902 # - we have to redirect descriptor 4 in addition to 2, to cover 903 # BASH_XTRACEFD 904 # 905 # - the actual eval has to come before the redirection block (since 906 # it needs to see descriptor 4 to set up its stderr) 907 # 908 # - likewise, any error message we print must be outside the block to 909 # access descriptor 4 910 # 911 # - checking $? has to come immediately after the eval, but it must 912 # be _inside_ the block to avoid polluting the "set -x" output 913 # 914 915 test_eval_inner_ "$@" </dev/null >&3 2>&4 916 { 917 test_eval_ret_=$? 918 if want_trace 919 then 920 set +x 921 fi 922 } 2>/dev/null 4>&2 923 924 if test "$test_eval_ret_" != 0 && want_trace 925 then 926 say_color error >&4 "error: last command exited with \$?=$test_eval_ret_" 927 fi 928 return $test_eval_ret_ 929} 930 931test_run_ () { 932 test_cleanup=: 933 expecting_failure=$2 934 935 if test "${GIT_TEST_CHAIN_LINT:-1}" != 0; then 936 # turn off tracing for this test-eval, as it simply creates 937 # confusing noise in the "-x" output 938 trace_tmp=$trace 939 trace= 940 # 117 is magic because it is unlikely to match the exit 941 # code of other programs 942 if $(printf '%s\n' "$1" | sed -f "$GIT_BUILD_DIR/t/chainlint.sed" | grep -q '?![A-Z][A-Z]*?!') || 943 test "OK-117" != "$(test_eval_ "(exit 117) && $1${LF}${LF}echo OK-\$?" 3>&1)" 944 then 945 BUG "broken &&-chain or run-away HERE-DOC: $1" 946 fi 947 trace=$trace_tmp 948 fi 949 950 setup_malloc_check 951 test_eval_ "$1" 952 eval_ret=$? 953 teardown_malloc_check 954 955 if test -z "$immediate" || test $eval_ret = 0 || 956 test -n "$expecting_failure" && test "$test_cleanup" != ":" 957 then 958 setup_malloc_check 959 test_eval_ "$test_cleanup" 960 teardown_malloc_check 961 fi 962 if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE" 963 then 964 echo "" 965 fi 966 return "$eval_ret" 967} 968 969test_start_ () { 970 test_count=$(($test_count+1)) 971 maybe_setup_verbose 972 maybe_setup_valgrind 973 if test -n "$write_junit_xml" 974 then 975 junit_start=$(test-tool date getnanos) 976 fi 977} 978 979test_finish_ () { 980 echo >&3 "" 981 maybe_teardown_valgrind 982 maybe_teardown_verbose 983 if test -n "$GIT_TEST_TEE_OFFSET" 984 then 985 GIT_TEST_TEE_OFFSET=$(test-tool path-utils file-size \ 986 "$GIT_TEST_TEE_OUTPUT_FILE") 987 fi 988} 989 990test_skip () { 991 to_skip= 992 skipped_reason= 993 if match_pattern_list $this_test.$test_count $GIT_SKIP_TESTS 994 then 995 to_skip=t 996 skipped_reason="GIT_SKIP_TESTS" 997 fi 998 if test -z "$to_skip" && test -n "$test_prereq" && 999 ! test_have_prereq "$test_prereq"1000 then1001 to_skip=t10021003 of_prereq=1004 if test "$missing_prereq" != "$test_prereq"1005 then1006 of_prereq=" of $test_prereq"1007 fi1008 skipped_reason="missing $missing_prereq${of_prereq}"1009 fi1010 if test -z "$to_skip" && test -n "$run_list" &&1011 ! match_test_selector_list '--run' $test_count "$run_list"1012 then1013 to_skip=t1014 skipped_reason="--run"1015 fi10161017 case "$to_skip" in1018 t)1019 if test -n "$write_junit_xml"1020 then1021 message="$(xml_attr_encode "$skipped_reason")"1022 write_junit_xml_testcase "$1" \1023 " <skipped message=\"$message\" />"1024 fi10251026 say_color skip >&3 "skipping test: $@"1027 say_color skip "ok $test_count # skip $1 ($skipped_reason)"1028 : true1029 ;;1030 *)1031 false1032 ;;1033 esac1034}10351036# stub; perf-lib overrides it1037test_at_end_hook_ () {1038 :1039}10401041write_junit_xml () {1042 case "$1" in1043 --truncate)1044 >"$junit_xml_path"1045 junit_have_testcase=1046 shift1047 ;;1048 esac1049 printf '%s\n' "$@" >>"$junit_xml_path"1050}10511052xml_attr_encode () {1053 printf '%s\n' "$@" | test-tool xml-encode1054}10551056write_junit_xml_testcase () {1057 junit_attrs="name=\"$(xml_attr_encode "$this_test.$test_count $1")\""1058 shift1059 junit_attrs="$junit_attrs classname=\"$this_test\""1060 junit_attrs="$junit_attrs time=\"$(test-tool \1061 date getnanos $junit_start)\""1062 write_junit_xml "$(printf '%s\n' \1063 " <testcase $junit_attrs>" "$@" " </testcase>")"1064 junit_have_testcase=t1065}10661067test_atexit_cleanup=:1068test_atexit_handler () {1069 # In a succeeding test script 'test_atexit_handler' is invoked1070 # twice: first from 'test_done', then from 'die' in the trap on1071 # EXIT.1072 # This condition and resetting 'test_atexit_cleanup' below makes1073 # sure that the registered cleanup commands are run only once.1074 test : != "$test_atexit_cleanup" || return 010751076 setup_malloc_check1077 test_eval_ "$test_atexit_cleanup"1078 test_atexit_cleanup=:1079 teardown_malloc_check1080}10811082test_done () {1083 GIT_EXIT_OK=t10841085 # Run the atexit commands _before_ the trash directory is1086 # removed, so the commands can access pidfiles and socket files.1087 test_atexit_handler10881089 if test -n "$write_junit_xml" && test -n "$junit_xml_path"1090 then1091 test -n "$junit_have_testcase" || {1092 junit_start=$(test-tool date getnanos)1093 write_junit_xml_testcase "all tests skipped"1094 }10951096 # adjust the overall time1097 junit_time=$(test-tool date getnanos $junit_suite_start)1098 sed "s/<testsuite [^>]*/& time=\"$junit_time\"/" \1099 <"$junit_xml_path" >"$junit_xml_path.new"1100 mv "$junit_xml_path.new" "$junit_xml_path"11011102 write_junit_xml " </testsuite>" "</testsuites>"1103 fi11041105 if test -z "$HARNESS_ACTIVE"1106 then1107 mkdir -p "$TEST_RESULTS_DIR"11081109 cat >"$TEST_RESULTS_BASE.counts" <<-EOF1110 total $test_count1111 success $test_success1112 fixed $test_fixed1113 broken $test_broken1114 failed $test_failure11151116 EOF1117 fi11181119 if test "$test_fixed" != 01120 then1121 say_color error "# $test_fixed known breakage(s) vanished; please update test(s)"1122 fi1123 if test "$test_broken" != 01124 then1125 say_color warn "# still have $test_broken known breakage(s)"1126 fi1127 if test "$test_broken" != 0 || test "$test_fixed" != 01128 then1129 test_remaining=$(( $test_count - $test_broken - $test_fixed ))1130 msg="remaining $test_remaining test(s)"1131 else1132 test_remaining=$test_count1133 msg="$test_count test(s)"1134 fi1135 case "$test_failure" in1136 0)1137 if test $test_external_has_tap -eq 01138 then1139 if test $test_remaining -gt 01140 then1141 say_color pass "# passed all $msg"1142 fi11431144 # Maybe print SKIP message1145 test -z "$skip_all" || skip_all="# SKIP $skip_all"1146 case "$test_count" in1147 0)1148 say "1..$test_count${skip_all:+ $skip_all}"1149 ;;1150 *)1151 test -z "$skip_all" ||1152 say_color warn "$skip_all"1153 say "1..$test_count"1154 ;;1155 esac1156 fi11571158 if test -z "$debug"1159 then1160 test -d "$TRASH_DIRECTORY" ||1161 error "Tests passed but trash directory already removed before test cleanup; aborting"11621163 cd "$TRASH_DIRECTORY/.." &&1164 rm -fr "$TRASH_DIRECTORY" || {1165 # try again in a bit1166 sleep 5;1167 rm -fr "$TRASH_DIRECTORY"1168 } ||1169 error "Tests passed but test cleanup failed; aborting"1170 fi1171 test_at_end_hook_11721173 exit 0 ;;11741175 *)1176 if test $test_external_has_tap -eq 01177 then1178 say_color error "# failed $test_failure among $msg"1179 say "1..$test_count"1180 fi11811182 exit 1 ;;11831184 esac1185}11861187if test -n "$valgrind"1188then1189 make_symlink () {1190 test -h "$2" &&1191 test "$1" = "$(readlink "$2")" || {1192 # be super paranoid1193 if mkdir "$2".lock1194 then1195 rm -f "$2" &&1196 ln -s "$1" "$2" &&1197 rm -r "$2".lock1198 else1199 while test -d "$2".lock1200 do1201 say "Waiting for lock on $2."1202 sleep 11203 done1204 fi1205 }1206 }12071208 make_valgrind_symlink () {1209 # handle only executables, unless they are shell libraries that1210 # need to be in the exec-path.1211 test -x "$1" ||1212 test "# " = "$(test_copy_bytes 2 <"$1")" ||1213 return;12141215 base=$(basename "$1")1216 case "$base" in1217 test-*)1218 symlink_target="$GIT_BUILD_DIR/t/helper/$base"1219 ;;1220 *)1221 symlink_target="$GIT_BUILD_DIR/$base"1222 ;;1223 esac1224 # do not override scripts1225 if test -x "$symlink_target" &&1226 test ! -d "$symlink_target" &&1227 test "#!" != "$(test_copy_bytes 2 <"$symlink_target")"1228 then1229 symlink_target=../valgrind.sh1230 fi1231 case "$base" in1232 *.sh|*.perl)1233 symlink_target=../unprocessed-script1234 esac1235 # create the link, or replace it if it is out of date1236 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit1237 }12381239 # override all git executables in TEST_DIRECTORY/..1240 GIT_VALGRIND=$TEST_DIRECTORY/valgrind1241 mkdir -p "$GIT_VALGRIND"/bin1242 for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/t/helper/test-*1243 do1244 make_valgrind_symlink $file1245 done1246 # special-case the mergetools loadables1247 make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools"1248 OLDIFS=$IFS1249 IFS=:1250 for path in $PATH1251 do1252 ls "$path"/git-* 2> /dev/null |1253 while read file1254 do1255 make_valgrind_symlink "$file"1256 done1257 done1258 IFS=$OLDIFS1259 PATH=$GIT_VALGRIND/bin:$PATH1260 GIT_EXEC_PATH=$GIT_VALGRIND/bin1261 export GIT_VALGRIND1262 GIT_VALGRIND_MODE="$valgrind"1263 export GIT_VALGRIND_MODE1264 GIT_VALGRIND_ENABLED=t1265 test -n "$valgrind_only" && GIT_VALGRIND_ENABLED=1266 export GIT_VALGRIND_ENABLED1267elif test -n "$GIT_TEST_INSTALLED"1268then1269 GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path) ||1270 error "Cannot run git from $GIT_TEST_INSTALLED."1271 PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR/t/helper:$PATH1272 GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH}1273else # normal case, use ../bin-wrappers only unless $with_dashes:1274 if test -n "$no_bin_wrappers"1275 then1276 with_dashes=t1277 else1278 git_bin_dir="$GIT_BUILD_DIR/bin-wrappers"1279 if ! test -x "$git_bin_dir/git"1280 then1281 if test -z "$with_dashes"1282 then1283 say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH"1284 fi1285 with_dashes=t1286 fi1287 PATH="$git_bin_dir:$PATH"1288 fi1289 GIT_EXEC_PATH=$GIT_BUILD_DIR1290 if test -n "$with_dashes"1291 then1292 PATH="$GIT_BUILD_DIR:$GIT_BUILD_DIR/t/helper:$PATH"1293 fi1294fi1295GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt1296GIT_CONFIG_NOSYSTEM=11297GIT_ATTR_NOSYSTEM=11298export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM12991300if test -z "$GIT_TEST_CMP"1301then1302 if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT"1303 then1304 GIT_TEST_CMP="$DIFF -c"1305 else1306 GIT_TEST_CMP="$DIFF -u"1307 fi1308fi13091310GITPERLLIB="$GIT_BUILD_DIR"/perl/build/lib1311export GITPERLLIB1312test -d "$GIT_BUILD_DIR"/templates/blt || {1313 error "You haven't built things yet, have you?"1314}13151316if ! test -x "$GIT_BUILD_DIR"/t/helper/test-tool$X1317then1318 echo >&2 'You need to build test-tool:'1319 echo >&2 'Run "make t/helper/test-tool" in the source (toplevel) directory'1320 exit 11321fi13221323# Test repository1324rm -fr "$TRASH_DIRECTORY" || {1325 GIT_EXIT_OK=t1326 echo >&5 "FATAL: Cannot prepare test area"1327 exit 11328}13291330HOME="$TRASH_DIRECTORY"1331GNUPGHOME="$HOME/gnupg-home-not-used"1332export HOME GNUPGHOME13331334if test -z "$TEST_NO_CREATE_REPO"1335then1336 test_create_repo "$TRASH_DIRECTORY"1337else1338 mkdir -p "$TRASH_DIRECTORY"1339fi13401341# Use -P to resolve symlinks in our working directory so that the cwd1342# in subprocesses like git equals our $PWD (for pathname comparisons).1343cd -P "$TRASH_DIRECTORY" || exit 113441345this_test=${0##*/}1346this_test=${this_test%%-*}1347if match_pattern_list "$this_test" $GIT_SKIP_TESTS1348then1349 say_color info >&3 "skipping test $this_test altogether"1350 skip_all="skip all tests in $this_test"1351 test_done1352fi13531354if test -n "$write_junit_xml"1355then1356 junit_xml_dir="$TEST_OUTPUT_DIRECTORY/out"1357 mkdir -p "$junit_xml_dir"1358 junit_xml_base=${0##*/}1359 junit_xml_path="$junit_xml_dir/TEST-${junit_xml_base%.sh}.xml"1360 junit_attrs="name=\"${junit_xml_base%.sh}\""1361 junit_attrs="$junit_attrs timestamp=\"$(TZ=UTC \1362 date +%Y-%m-%dT%H:%M:%S)\""1363 write_junit_xml --truncate "<testsuites>" " <testsuite $junit_attrs>"1364 junit_suite_start=$(test-tool date getnanos)1365 if test -n "$GIT_TEST_TEE_OUTPUT_FILE"1366 then1367 GIT_TEST_TEE_OFFSET=01368 fi1369fi13701371# Provide an implementation of the 'yes' utility; the upper bound1372# limit is there to help Windows that cannot stop this loop from1373# wasting cycles when the downstream stops reading, so do not be1374# tempted to turn it into an infinite loop. cf. 6129c930 ("test-lib:1375# limit the output of the yes utility", 2016-02-02)1376yes () {1377 if test $# = 01378 then1379 y=y1380 else1381 y="$*"1382 fi13831384 i=01385 while test $i -lt 991386 do1387 echo "$y"1388 i=$(($i+1))1389 done1390}13911392# Fix some commands on Windows1393uname_s=$(uname -s)1394case $uname_s in1395*MINGW*)1396 # Windows has its own (incompatible) sort and find1397 sort () {1398 /usr/bin/sort "$@"1399 }1400 find () {1401 /usr/bin/find "$@"1402 }1403 # git sees Windows-style pwd1404 pwd () {1405 builtin pwd -W1406 }1407 # no POSIX permissions1408 # backslashes in pathspec are converted to '/'1409 # exec does not inherit the PID1410 test_set_prereq MINGW1411 test_set_prereq NATIVE_CRLF1412 test_set_prereq SED_STRIPS_CR1413 test_set_prereq GREP_STRIPS_CR1414 GIT_TEST_CMP=mingw_test_cmp1415 ;;1416*CYGWIN*)1417 test_set_prereq POSIXPERM1418 test_set_prereq EXECKEEPSPID1419 test_set_prereq CYGWIN1420 test_set_prereq SED_STRIPS_CR1421 test_set_prereq GREP_STRIPS_CR1422 ;;1423*)1424 test_set_prereq POSIXPERM1425 test_set_prereq BSLASHPSPEC1426 test_set_prereq EXECKEEPSPID1427 ;;1428esac14291430( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_11431test -z "$NO_PERL" && test_set_prereq PERL1432test -z "$NO_PTHREADS" && test_set_prereq PTHREADS1433test -z "$NO_PYTHON" && test_set_prereq PYTHON1434test -n "$USE_LIBPCRE1$USE_LIBPCRE2" && test_set_prereq PCRE1435test -n "$USE_LIBPCRE1" && test_set_prereq LIBPCRE11436test -n "$USE_LIBPCRE2" && test_set_prereq LIBPCRE21437test -z "$NO_GETTEXT" && test_set_prereq GETTEXT14381439if test -n "$GIT_TEST_GETTEXT_POISON_ORIG"1440then1441 GIT_TEST_GETTEXT_POISON=$GIT_TEST_GETTEXT_POISON_ORIG1442 export GIT_TEST_GETTEXT_POISON1443 unset GIT_TEST_GETTEXT_POISON_ORIG1444fi14451446# Can we rely on git's output in the C locale?1447if test -z "$GIT_TEST_GETTEXT_POISON"1448then1449 test_set_prereq C_LOCALE_OUTPUT1450fi14511452if test -z "$GIT_TEST_CHECK_CACHE_TREE"1453then1454 GIT_TEST_CHECK_CACHE_TREE=true1455 export GIT_TEST_CHECK_CACHE_TREE1456fi14571458test_lazy_prereq PIPE '1459 # test whether the filesystem supports FIFOs1460 test_have_prereq !MINGW,!CYGWIN &&1461 rm -f testfifo && mkfifo testfifo1462'14631464test_lazy_prereq SYMLINKS '1465 # test whether the filesystem supports symbolic links1466 ln -s x y && test -h y1467'14681469test_lazy_prereq FILEMODE '1470 test "$(git config --bool core.filemode)" = true1471'14721473test_lazy_prereq CASE_INSENSITIVE_FS '1474 echo good >CamelCase &&1475 echo bad >camelcase &&1476 test "$(cat CamelCase)" != good1477'14781479test_lazy_prereq FUNNYNAMES '1480 test_have_prereq !MINGW &&1481 touch -- \1482 "FUNNYNAMES tab embedded" \1483 "FUNNYNAMES \"quote embedded\"" \1484 "FUNNYNAMES newline1485embedded" 2>/dev/null &&1486 rm -- \1487 "FUNNYNAMES tab embedded" \1488 "FUNNYNAMES \"quote embedded\"" \1489 "FUNNYNAMES newline1490embedded" 2>/dev/null1491'14921493test_lazy_prereq UTF8_NFD_TO_NFC '1494 # check whether FS converts nfd unicode to nfc1495 auml=$(printf "\303\244")1496 aumlcdiar=$(printf "\141\314\210")1497 >"$auml" &&1498 test -f "$aumlcdiar"1499'15001501test_lazy_prereq AUTOIDENT '1502 sane_unset GIT_AUTHOR_NAME &&1503 sane_unset GIT_AUTHOR_EMAIL &&1504 git var GIT_AUTHOR_IDENT1505'15061507test_lazy_prereq EXPENSIVE '1508 test -n "$GIT_TEST_LONG"1509'15101511test_lazy_prereq EXPENSIVE_ON_WINDOWS '1512 test_have_prereq EXPENSIVE || test_have_prereq !MINGW,!CYGWIN1513'15141515test_lazy_prereq USR_BIN_TIME '1516 test -x /usr/bin/time1517'15181519test_lazy_prereq NOT_ROOT '1520 uid=$(id -u) &&1521 test "$uid" != 01522'15231524test_lazy_prereq JGIT '1525 jgit --version1526'15271528# SANITY is about "can you correctly predict what the filesystem would1529# do by only looking at the permission bits of the files and1530# directories?" A typical example of !SANITY is running the test1531# suite as root, where a test may expect "chmod -r file && cat file"1532# to fail because file is supposed to be unreadable after a successful1533# chmod. In an environment (i.e. combination of what filesystem is1534# being used and who is running the tests) that lacks SANITY, you may1535# be able to delete or create a file when the containing directory1536# doesn't have write permissions, or access a file even if the1537# containing directory doesn't have read or execute permissions.15381539test_lazy_prereq SANITY '1540 mkdir SANETESTD.1 SANETESTD.2 &&15411542 chmod +w SANETESTD.1 SANETESTD.2 &&1543 >SANETESTD.1/x 2>SANETESTD.2/x &&1544 chmod -w SANETESTD.1 &&1545 chmod -r SANETESTD.1/x &&1546 chmod -rx SANETESTD.2 ||1547 BUG "cannot prepare SANETESTD"15481549 ! test -r SANETESTD.1/x &&1550 ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x1551 status=$?15521553 chmod +rwx SANETESTD.1 SANETESTD.2 &&1554 rm -rf SANETESTD.1 SANETESTD.2 ||1555 BUG "cannot clean SANETESTD"1556 return $status1557'15581559test FreeBSD != $uname_s || GIT_UNZIP=${GIT_UNZIP:-/usr/local/bin/unzip}1560GIT_UNZIP=${GIT_UNZIP:-unzip}1561test_lazy_prereq UNZIP '1562 "$GIT_UNZIP" -v1563 test $? -ne 1271564'15651566run_with_limited_cmdline () {1567 (ulimit -s 128 && "$@")1568}15691570test_lazy_prereq CMDLINE_LIMIT '1571 test_have_prereq !MINGW,!CYGWIN &&1572 run_with_limited_cmdline true1573'15741575run_with_limited_stack () {1576 (ulimit -s 128 && "$@")1577}15781579test_lazy_prereq ULIMIT_STACK_SIZE '1580 test_have_prereq !MINGW,!CYGWIN &&1581 run_with_limited_stack true1582'15831584build_option () {1585 git version --build-options |1586 sed -ne "s/^$1: //p"1587}15881589test_lazy_prereq LONG_IS_64BIT '1590 test 8 -le "$(build_option sizeof-long)"1591'15921593test_lazy_prereq TIME_IS_64BIT 'test-tool date is64bit'1594test_lazy_prereq TIME_T_IS_64BIT 'test-tool date time_t-is64bit'15951596test_lazy_prereq CURL '1597 curl --version1598'15991600# SHA1 is a test if the hash algorithm in use is SHA-1. This is both for tests1601# which will not work with other hash algorithms and tests that work but don't1602# test anything meaningful (e.g. special values which cause short collisions).1603test_lazy_prereq SHA1 '1604 test $(git hash-object /dev/null) = e69de29bb2d1d6434b8b29ae775ad8c2e48c53911605'16061607test_lazy_prereq REBASE_P '1608 test -z "$GIT_TEST_SKIP_REBASE_P"1609'16101611test_lazy_prereq FAIL_PREREQS '1612 test -n "$GIT_TEST_FAIL_PREREQS"1613'