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################################################################ 61# It appears that people try to run tests without building... 62"${GIT_TEST_INSTALLED:-$GIT_BUILD_DIR}/git$X" >/dev/null 63if test $? != 1 64then 65 if test -n "$GIT_TEST_INSTALLED" 66 then 67 echo >&2 "error: there is no working Git at '$GIT_TEST_INSTALLED'" 68 else 69 echo >&2 'error: you do not seem to have built git yet.' 70 fi 71 exit 1 72fi 73 74# Parse options while taking care to leave $@ intact, so we will still 75# have all the original command line options when executing the test 76# script again for '--tee' and '--verbose-log' below. 77store_arg_to= 78prev_opt= 79for opt 80do 81 if test -n "$store_arg_to" 82 then 83 eval $store_arg_to=\$opt 84 store_arg_to= 85 prev_opt= 86 continue 87 fi 88 89 case "$opt" in 90 -d|--d|--de|--deb|--debu|--debug) 91 debug=t ;; 92 -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate) 93 immediate=t ;; 94 -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests) 95 GIT_TEST_LONG=t; export GIT_TEST_LONG ;; 96 -r) 97 store_arg_to=run_list 98 ;; 99 --run=*) 100 run_list=${opt#--*=} ;; 101 -h|--h|--he|--hel|--help) 102 help=t ;; 103 -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose) 104 verbose=t ;; 105 --verbose-only=*) 106 verbose_only=${opt#--*=} 107 ;; 108 -q|--q|--qu|--qui|--quie|--quiet) 109 # Ignore --quiet under a TAP::Harness. Saying how many tests 110 # passed without the ok/not ok details is always an error. 111 test -z "$HARNESS_ACTIVE" && quiet=t ;; 112 --with-dashes) 113 with_dashes=t ;; 114 --no-bin-wrappers) 115 no_bin_wrappers=t ;; 116 --no-color) 117 color= ;; 118 --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind) 119 valgrind=memcheck 120 tee=t 121 ;; 122 --valgrind=*) 123 valgrind=${opt#--*=} 124 tee=t 125 ;; 126 --valgrind-only=*) 127 valgrind_only=${opt#--*=} 128 tee=t 129 ;; 130 --tee) 131 tee=t ;; 132 --root=*) 133 root=${opt#--*=} ;; 134 --chain-lint) 135 GIT_TEST_CHAIN_LINT=1 ;; 136 --no-chain-lint) 137 GIT_TEST_CHAIN_LINT=0 ;; 138 -x) 139 trace=t ;; 140 -V|--verbose-log) 141 verbose_log=t 142 tee=t 143 ;; 144 --write-junit-xml) 145 write_junit_xml=t 146 ;; 147 --stress) 148 stress=t ;; 149 --stress=*) 150 echo "error: --stress does not accept an argument: '$opt'" >&2 151 echo "did you mean --stress-jobs=${opt#*=} or --stress-limit=${opt#*=}?" >&2 152 exit 1 153 ;; 154 --stress-jobs=*) 155 stress=t; 156 stress=${opt#--*=} 157 case "$stress" in 158 *[!0-9]*|0*|"") 159 echo "error: --stress-jobs=<N> requires the number of jobs to run" >&2 160 exit 1 161 ;; 162 *) # Good. 163 ;; 164 esac 165 ;; 166 --stress-limit=*) 167 stress=t; 168 stress_limit=${opt#--*=} 169 case "$stress_limit" in 170 *[!0-9]*|0*|"") 171 echo "error: --stress-limit=<N> requires the number of repetitions" >&2 172 exit 1 173 ;; 174 *) # Good. 175 ;; 176 esac 177 ;; 178 *) 179 echo "error: unknown test option '$opt'" >&2; exit 1 ;; 180 esac 181 182 prev_opt=$opt 183done 184if test -n "$store_arg_to" 185then 186 echo "error: $prev_opt requires an argument" >&2 187 exit 1 188fi 189 190if test -n "$valgrind_only" 191then 192 test -z "$valgrind" && valgrind=memcheck 193 test -z "$verbose" && verbose_only="$valgrind_only" 194elif test -n "$valgrind" 195then 196 test -z "$verbose_log" && verbose=t 197fi 198 199if test -n "$stress" 200then 201 verbose=t 202 trace=t 203 immediate=t 204fi 205 206TEST_STRESS_JOB_SFX="${GIT_TEST_STRESS_JOB_NR:+.stress-$GIT_TEST_STRESS_JOB_NR}" 207TEST_NAME="$(basename "$0" .sh)" 208TEST_RESULTS_DIR="$TEST_OUTPUT_DIRECTORY/test-results" 209TEST_RESULTS_BASE="$TEST_RESULTS_DIR/$TEST_NAME$TEST_STRESS_JOB_SFX" 210TRASH_DIRECTORY="trash directory.$TEST_NAME$TEST_STRESS_JOB_SFX" 211test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY" 212case "$TRASH_DIRECTORY" in 213/*) ;; # absolute path is good 214 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;; 215esac 216 217# If --stress was passed, run this test repeatedly in several parallel loops. 218if test "$GIT_TEST_STRESS_STARTED" = "done" 219then 220 : # Don't stress test again. 221elif test -n "$stress" 222then 223 if test "$stress" != t 224 then 225 job_count=$stress 226 elif test -n "$GIT_TEST_STRESS_LOAD" 227 then 228 job_count="$GIT_TEST_STRESS_LOAD" 229 elif job_count=$(getconf _NPROCESSORS_ONLN 2>/dev/null) && 230 test -n "$job_count" 231 then 232 job_count=$((2 * $job_count)) 233 else 234 job_count=8 235 fi 236 237 mkdir -p "$TEST_RESULTS_DIR" 238 stressfail="$TEST_RESULTS_BASE.stress-failed" 239 rm -f "$stressfail" 240 241 stress_exit=0 242 trap ' 243 kill $job_pids 2>/dev/null 244 wait 245 stress_exit=1 246 ' TERM INT HUP 247 248 job_pids= 249 job_nr=0 250 while test $job_nr -lt "$job_count" 251 do 252 ( 253 GIT_TEST_STRESS_STARTED=done 254 GIT_TEST_STRESS_JOB_NR=$job_nr 255 export GIT_TEST_STRESS_STARTED GIT_TEST_STRESS_JOB_NR 256 257 trap ' 258 kill $test_pid 2>/dev/null 259 wait 260 exit 1 261 ' TERM INT 262 263 cnt=1 264 while ! test -e "$stressfail" && 265 { test -z "$stress_limit" || 266 test $cnt -le $stress_limit ; } 267 do 268 $TEST_SHELL_PATH "$0" "$@" >"$TEST_RESULTS_BASE.stress-$job_nr.out" 2>&1 & 269 test_pid=$! 270 271 if wait $test_pid 272 then 273 printf "OK %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt 274 else 275 echo $GIT_TEST_STRESS_JOB_NR >>"$stressfail" 276 printf "FAIL %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt 277 fi 278 cnt=$(($cnt + 1)) 279 done 280 ) & 281 job_pids="$job_pids $!" 282 job_nr=$(($job_nr + 1)) 283 done 284 285 wait 286 287 if test -f "$stressfail" 288 then 289 stress_exit=1 290 echo "Log(s) of failed test run(s):" 291 for failed_job_nr in $(sort -n "$stressfail") 292 do 293 echo "Contents of '$TEST_RESULTS_BASE.stress-$failed_job_nr.out':" 294 cat "$TEST_RESULTS_BASE.stress-$failed_job_nr.out" 295 done 296 rm -rf "$TRASH_DIRECTORY.stress-failed" 297 # Move the last one. 298 mv "$TRASH_DIRECTORY.stress-$failed_job_nr" "$TRASH_DIRECTORY.stress-failed" 299 fi 300 301 exit $stress_exit 302fi 303 304# if --tee was passed, write the output not only to the terminal, but 305# additionally to the file test-results/$BASENAME.out, too. 306if test "$GIT_TEST_TEE_STARTED" = "done" 307then 308 : # do not redirect again 309elif test -n "$tee" 310then 311 mkdir -p "$TEST_RESULTS_DIR" 312 313 # Make this filename available to the sub-process in case it is using 314 # --verbose-log. 315 GIT_TEST_TEE_OUTPUT_FILE=$TEST_RESULTS_BASE.out 316 export GIT_TEST_TEE_OUTPUT_FILE 317 318 # Truncate before calling "tee -a" to get rid of the results 319 # from any previous runs. 320 >"$GIT_TEST_TEE_OUTPUT_FILE" 321 322 (GIT_TEST_TEE_STARTED=done ${TEST_SHELL_PATH} "$0" "$@" 2>&1; 323 echo $? >"$TEST_RESULTS_BASE.exit") | tee -a "$GIT_TEST_TEE_OUTPUT_FILE" 324 test "$(cat "$TEST_RESULTS_BASE.exit")" = 0 325 exit 326fi 327 328if test -n "$trace" && test -n "$test_untraceable" 329then 330 # '-x' tracing requested, but this test script can't be reliably 331 # traced, unless it is run with a Bash version supporting 332 # BASH_XTRACEFD (introduced in Bash v4.1). 333 # 334 # Perform this version check _after_ the test script was 335 # potentially re-executed with $TEST_SHELL_PATH for '--tee' or 336 # '--verbose-log', so the right shell is checked and the 337 # warning is issued only once. 338 if test -n "$BASH_VERSION" && eval ' 339 test ${BASH_VERSINFO[0]} -gt 4 || { 340 test ${BASH_VERSINFO[0]} -eq 4 && 341 test ${BASH_VERSINFO[1]} -ge 1 342 } 343 ' 344 then 345 : Executed by a Bash version supporting BASH_XTRACEFD. Good. 346 else 347 echo >&2 "warning: ignoring -x; '$0' is untraceable without BASH_XTRACEFD" 348 trace= 349 fi 350fi 351if test -n "$trace" && test -z "$verbose_log" 352then 353 verbose=t 354fi 355 356# For repeatability, reset the environment to known value. 357# TERM is sanitized below, after saving color control sequences. 358LANG=C 359LC_ALL=C 360PAGER=cat 361TZ=UTC 362export LANG LC_ALL PAGER TZ 363EDITOR=: 364 365# GIT_TEST_GETTEXT_POISON should not influence git commands executed 366# during initialization of test-lib and the test repo. Back it up, 367# unset and then restore after initialization is finished. 368if test -n "$GIT_TEST_GETTEXT_POISON" 369then 370 GIT_TEST_GETTEXT_POISON_ORIG=$GIT_TEST_GETTEXT_POISON 371 unset GIT_TEST_GETTEXT_POISON 372fi 373 374# A call to "unset" with no arguments causes at least Solaris 10 375# /usr/xpg4/bin/sh and /bin/ksh to bail out. So keep the unsets 376# deriving from the command substitution clustered with the other 377# ones. 378unset VISUAL EMAIL LANGUAGE COLUMNS $("$PERL_PATH" -e ' 379 my @env = keys %ENV; 380 my $ok = join("|", qw( 381 TRACE 382 DEBUG 383 TEST 384 .*_TEST 385 PROVE 386 VALGRIND 387 UNZIP 388 PERF_ 389 CURL_VERBOSE 390 TRACE_CURL 391 )); 392 my @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env); 393 print join("\n", @vars); 394') 395unset XDG_CACHE_HOME 396unset XDG_CONFIG_HOME 397unset GITPERLLIB 398GIT_AUTHOR_EMAIL=author@example.com 399GIT_AUTHOR_NAME='A U Thor' 400GIT_COMMITTER_EMAIL=committer@example.com 401GIT_COMMITTER_NAME='C O Mitter' 402GIT_MERGE_VERBOSITY=5 403GIT_MERGE_AUTOEDIT=no 404export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT 405export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME 406export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME 407export EDITOR 408 409# Tests using GIT_TRACE typically don't want <timestamp> <file>:<line> output 410GIT_TRACE_BARE=1 411export GIT_TRACE_BARE 412 413check_var_migration () { 414 # the warnings and hints given from this helper depends 415 # on end-user settings, which will disrupt the self-test 416 # done on the test framework itself. 417 case "$GIT_TEST_FRAMEWORK_SELFTEST" in 418 t) return ;; 419 esac 420 421 old_name=$1 new_name=$2 422 eval "old_isset=\${${old_name}:+isset}" 423 eval "new_isset=\${${new_name}:+isset}" 424 425 case "$old_isset,$new_isset" in 426 isset,) 427 echo >&2 "warning: $old_name is now $new_name" 428 echo >&2 "hint: set $new_name too during the transition period" 429 eval "$new_name=\$$old_name" 430 ;; 431 isset,isset) 432 # do this later 433 # echo >&2 "warning: $old_name is now $new_name" 434 # echo >&2 "hint: remove $old_name" 435 ;; 436 esac 437} 438 439check_var_migration GIT_FSMONITOR_TEST GIT_TEST_FSMONITOR 440check_var_migration TEST_GIT_INDEX_VERSION GIT_TEST_INDEX_VERSION 441check_var_migration GIT_FORCE_PRELOAD_TEST GIT_TEST_PRELOAD_INDEX 442 443# Use specific version of the index file format 444if test -n "${GIT_TEST_INDEX_VERSION:+isset}" 445then 446 GIT_INDEX_VERSION="$GIT_TEST_INDEX_VERSION" 447 export GIT_INDEX_VERSION 448fi 449 450# Add libc MALLOC and MALLOC_PERTURB test 451# only if we are not executing the test with valgrind 452if test -n "$valgrind" || 453 test -n "$TEST_NO_MALLOC_CHECK" 454then 455 setup_malloc_check () { 456 : nothing 457 } 458 teardown_malloc_check () { 459 : nothing 460 } 461else 462 setup_malloc_check () { 463 MALLOC_CHECK_=3 MALLOC_PERTURB_=165 464 export MALLOC_CHECK_ MALLOC_PERTURB_ 465 } 466 teardown_malloc_check () { 467 unset MALLOC_CHECK_ MALLOC_PERTURB_ 468 } 469fi 470 471# Protect ourselves from common misconfiguration to export 472# CDPATH into the environment 473unset CDPATH 474 475unset GREP_OPTIONS 476unset UNZIP 477 478case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in 4791|2|true) 480 GIT_TRACE=4 481 ;; 482esac 483 484# Convenience 485# 486# A regexp to match 5, 35 and 40 hexdigits 487_x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]' 488_x35="$_x05$_x05$_x05$_x05$_x05$_x05$_x05" 489_x40="$_x35$_x05" 490 491# Zero SHA-1 492_z40=0000000000000000000000000000000000000000 493 494OID_REGEX="$_x40" 495ZERO_OID=$_z40 496EMPTY_TREE=4b825dc642cb6eb9a060e54bf8d69288fbee4904 497EMPTY_BLOB=e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 498 499# Line feed 500LF=' 501' 502 503# UTF-8 ZERO WIDTH NON-JOINER, which HFS+ ignores 504# when case-folding filenames 505u200c=$(printf '\342\200\214') 506 507export _x05 _x35 _x40 _z40 LF u200c EMPTY_TREE EMPTY_BLOB ZERO_OID OID_REGEX 508 509# Each test should start with something like this, after copyright notices: 510# 511# test_description='Description of this test... 512# This test checks if command xyzzy does the right thing... 513# ' 514# . ./test-lib.sh 515test "x$TERM" != "xdumb" && ( 516 test -t 1 && 517 tput bold >/dev/null 2>&1 && 518 tput setaf 1 >/dev/null 2>&1 && 519 tput sgr0 >/dev/null 2>&1 520 ) && 521 color=t 522 523if test -n "$color" 524then 525 # Save the color control sequences now rather than run tput 526 # each time say_color() is called. This is done for two 527 # reasons: 528 # * TERM will be changed to dumb 529 # * HOME will be changed to a temporary directory and tput 530 # might need to read ~/.terminfo from the original HOME 531 # directory to get the control sequences 532 # Note: This approach assumes the control sequences don't end 533 # in a newline for any terminal of interest (command 534 # substitutions strip trailing newlines). Given that most 535 # (all?) terminals in common use are related to ECMA-48, this 536 # shouldn't be a problem. 537 say_color_error=$(tput bold; tput setaf 1) # bold red 538 say_color_skip=$(tput setaf 4) # blue 539 say_color_warn=$(tput setaf 3) # brown/yellow 540 say_color_pass=$(tput setaf 2) # green 541 say_color_info=$(tput setaf 6) # cyan 542 say_color_reset=$(tput sgr0) 543 say_color_="" # no formatting for normal text 544 say_color () { 545 test -z "$1" && test -n "$quiet" && return 546 eval "say_color_color=\$say_color_$1" 547 shift 548 printf "%s\\n" "$say_color_color$*$say_color_reset" 549 } 550else 551 say_color() { 552 test -z "$1" && test -n "$quiet" && return 553 shift 554 printf "%s\n" "$*" 555 } 556fi 557 558TERM=dumb 559export TERM 560 561error () { 562 say_color error "error: $*" 563 GIT_EXIT_OK=t 564 exit 1 565} 566 567BUG () { 568 error >&7 "bug in the test script: $*" 569} 570 571say () { 572 say_color info "$*" 573} 574 575if test -n "$HARNESS_ACTIVE" 576then 577 if test "$verbose" = t || test -n "$verbose_only" 578 then 579 printf 'Bail out! %s\n' \ 580 'verbose mode forbidden under TAP harness; try --verbose-log' 581 exit 1 582 fi 583fi 584 585test "${test_description}" != "" || 586error "Test script did not set test_description." 587 588if test "$help" = "t" 589then 590 printf '%s\n' "$test_description" 591 exit 0 592fi 593 594exec 5>&1 595exec 6<&0 596exec 7>&2 597if test "$verbose_log" = "t" 598then 599 exec 3>>"$GIT_TEST_TEE_OUTPUT_FILE" 4>&3 600elif test "$verbose" = "t" 601then 602 exec 4>&2 3>&1 603else 604 exec 4>/dev/null 3>/dev/null 605fi 606 607# Send any "-x" output directly to stderr to avoid polluting tests 608# which capture stderr. We can do this unconditionally since it 609# has no effect if tracing isn't turned on. 610# 611# Note that this sets up the trace fd as soon as we assign the variable, so it 612# must come after the creation of descriptor 4 above. Likewise, we must never 613# unset this, as it has the side effect of closing descriptor 4, which we 614# use to show verbose tests to the user. 615# 616# Note also that we don't need or want to export it. The tracing is local to 617# this shell, and we would not want to influence any shells we exec. 618BASH_XTRACEFD=4 619 620test_failure=0 621test_count=0 622test_fixed=0 623test_broken=0 624test_success=0 625 626test_external_has_tap=0 627 628die () { 629 code=$? 630 if test -n "$GIT_EXIT_OK" 631 then 632 exit $code 633 else 634 echo >&5 "FATAL: Unexpected exit with code $code" 635 exit 1 636 fi 637} 638 639GIT_EXIT_OK= 640trap 'die' EXIT 641trap 'exit $?' INT TERM HUP 642 643# The user-facing functions are loaded from a separate file so that 644# test_perf subshells can have them too 645. "$TEST_DIRECTORY/test-lib-functions.sh" 646 647# You are not expected to call test_ok_ and test_failure_ directly, use 648# the test_expect_* functions instead. 649 650test_ok_ () { 651 if test -n "$write_junit_xml" 652 then 653 write_junit_xml_testcase "$*" 654 fi 655 test_success=$(($test_success + 1)) 656 say_color "" "ok $test_count - $@" 657} 658 659test_failure_ () { 660 if test -n "$write_junit_xml" 661 then 662 junit_insert="<failure message=\"not ok $test_count -" 663 junit_insert="$junit_insert $(xml_attr_encode "$1")\">" 664 junit_insert="$junit_insert $(xml_attr_encode \ 665 "$(if test -n "$GIT_TEST_TEE_OUTPUT_FILE" 666 then 667 test-tool path-utils skip-n-bytes \ 668 "$GIT_TEST_TEE_OUTPUT_FILE" $GIT_TEST_TEE_OFFSET 669 else 670 printf '%s\n' "$@" | sed 1d 671 fi)")" 672 junit_insert="$junit_insert</failure>" 673 if test -n "$GIT_TEST_TEE_OUTPUT_FILE" 674 then 675 junit_insert="$junit_insert<system-err>$(xml_attr_encode \ 676 "$(cat "$GIT_TEST_TEE_OUTPUT_FILE")")</system-err>" 677 fi 678 write_junit_xml_testcase "$1" " $junit_insert" 679 fi 680 test_failure=$(($test_failure + 1)) 681 say_color error "not ok $test_count - $1" 682 shift 683 printf '%s\n' "$*" | sed -e 's/^/# /' 684 test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; } 685} 686 687test_known_broken_ok_ () { 688 if test -n "$write_junit_xml" 689 then 690 write_junit_xml_testcase "$* (breakage fixed)" 691 fi 692 test_fixed=$(($test_fixed+1)) 693 say_color error "ok $test_count - $@ # TODO known breakage vanished" 694} 695 696test_known_broken_failure_ () { 697 if test -n "$write_junit_xml" 698 then 699 write_junit_xml_testcase "$* (known breakage)" 700 fi 701 test_broken=$(($test_broken+1)) 702 say_color warn "not ok $test_count - $@ # TODO known breakage" 703} 704 705test_debug () { 706 test "$debug" = "" || eval "$1" 707} 708 709match_pattern_list () { 710 arg="$1" 711 shift 712 test -z "$*" && return 1 713 for pattern_ 714 do 715 case "$arg" in 716 $pattern_) 717 return 0 718 esac 719 done 720 return 1 721} 722 723match_test_selector_list () { 724 title="$1" 725 shift 726 arg="$1" 727 shift 728 test -z "$1" && return 0 729 730 # Both commas and whitespace are accepted as separators. 731 OLDIFS=$IFS 732 IFS=' ,' 733 set -- $1 734 IFS=$OLDIFS 735 736 # If the first selector is negative we include by default. 737 include= 738 case "$1" in 739 !*) include=t ;; 740 esac 741 742 for selector 743 do 744 orig_selector=$selector 745 746 positive=t 747 case "$selector" in 748 !*) 749 positive= 750 selector=${selector##?} 751 ;; 752 esac 753 754 test -z "$selector" && continue 755 756 case "$selector" in 757 *-*) 758 if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null 759 then 760 echo "error: $title: invalid non-numeric in range" \ 761 "start: '$orig_selector'" >&2 762 exit 1 763 fi 764 if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null 765 then 766 echo "error: $title: invalid non-numeric in range" \ 767 "end: '$orig_selector'" >&2 768 exit 1 769 fi 770 ;; 771 *) 772 if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null 773 then 774 echo "error: $title: invalid non-numeric in test" \ 775 "selector: '$orig_selector'" >&2 776 exit 1 777 fi 778 esac 779 780 # Short cut for "obvious" cases 781 test -z "$include" && test -z "$positive" && continue 782 test -n "$include" && test -n "$positive" && continue 783 784 case "$selector" in 785 -*) 786 if test $arg -le ${selector#-} 787 then 788 include=$positive 789 fi 790 ;; 791 *-) 792 if test $arg -ge ${selector%-} 793 then 794 include=$positive 795 fi 796 ;; 797 *-*) 798 if test ${selector%%-*} -le $arg \ 799 && test $arg -le ${selector#*-} 800 then 801 include=$positive 802 fi 803 ;; 804 *) 805 if test $arg -eq $selector 806 then 807 include=$positive 808 fi 809 ;; 810 esac 811 done 812 813 test -n "$include" 814} 815 816maybe_teardown_verbose () { 817 test -z "$verbose_only" && return 818 exec 4>/dev/null 3>/dev/null 819 verbose= 820} 821 822last_verbose=t 823maybe_setup_verbose () { 824 test -z "$verbose_only" && return 825 if match_pattern_list $test_count $verbose_only 826 then 827 exec 4>&2 3>&1 828 # Emit a delimiting blank line when going from 829 # non-verbose to verbose. Within verbose mode the 830 # delimiter is printed by test_expect_*. The choice 831 # of the initial $last_verbose is such that before 832 # test 1, we do not print it. 833 test -z "$last_verbose" && echo >&3 "" 834 verbose=t 835 else 836 exec 4>/dev/null 3>/dev/null 837 verbose= 838 fi 839 last_verbose=$verbose 840} 841 842maybe_teardown_valgrind () { 843 test -z "$GIT_VALGRIND" && return 844 GIT_VALGRIND_ENABLED= 845} 846 847maybe_setup_valgrind () { 848 test -z "$GIT_VALGRIND" && return 849 if test -z "$valgrind_only" 850 then 851 GIT_VALGRIND_ENABLED=t 852 return 853 fi 854 GIT_VALGRIND_ENABLED= 855 if match_pattern_list $test_count $valgrind_only 856 then 857 GIT_VALGRIND_ENABLED=t 858 fi 859} 860 861want_trace () { 862 test "$trace" = t && { 863 test "$verbose" = t || test "$verbose_log" = t 864 } 865} 866 867# This is a separate function because some tests use 868# "return" to end a test_expect_success block early 869# (and we want to make sure we run any cleanup like 870# "set +x"). 871test_eval_inner_ () { 872 # Do not add anything extra (including LF) after '$*' 873 eval " 874 want_trace && set -x 875 $*" 876} 877 878test_eval_ () { 879 # If "-x" tracing is in effect, then we want to avoid polluting stderr 880 # with non-test commands. But once in "set -x" mode, we cannot prevent 881 # the shell from printing the "set +x" to turn it off (nor the saving 882 # of $? before that). But we can make sure that the output goes to 883 # /dev/null. 884 # 885 # There are a few subtleties here: 886 # 887 # - we have to redirect descriptor 4 in addition to 2, to cover 888 # BASH_XTRACEFD 889 # 890 # - the actual eval has to come before the redirection block (since 891 # it needs to see descriptor 4 to set up its stderr) 892 # 893 # - likewise, any error message we print must be outside the block to 894 # access descriptor 4 895 # 896 # - checking $? has to come immediately after the eval, but it must 897 # be _inside_ the block to avoid polluting the "set -x" output 898 # 899 900 test_eval_inner_ "$@" </dev/null >&3 2>&4 901 { 902 test_eval_ret_=$? 903 if want_trace 904 then 905 set +x 906 fi 907 } 2>/dev/null 4>&2 908 909 if test "$test_eval_ret_" != 0 && want_trace 910 then 911 say_color error >&4 "error: last command exited with \$?=$test_eval_ret_" 912 fi 913 return $test_eval_ret_ 914} 915 916test_run_ () { 917 test_cleanup=: 918 expecting_failure=$2 919 920 if test "${GIT_TEST_CHAIN_LINT:-1}" != 0; then 921 # turn off tracing for this test-eval, as it simply creates 922 # confusing noise in the "-x" output 923 trace_tmp=$trace 924 trace= 925 # 117 is magic because it is unlikely to match the exit 926 # code of other programs 927 if $(printf '%s\n' "$1" | sed -f "$GIT_BUILD_DIR/t/chainlint.sed" | grep -q '?![A-Z][A-Z]*?!') || 928 test "OK-117" != "$(test_eval_ "(exit 117) && $1${LF}${LF}echo OK-\$?" 3>&1)" 929 then 930 BUG "broken &&-chain or run-away HERE-DOC: $1" 931 fi 932 trace=$trace_tmp 933 fi 934 935 setup_malloc_check 936 test_eval_ "$1" 937 eval_ret=$? 938 teardown_malloc_check 939 940 if test -z "$immediate" || test $eval_ret = 0 || 941 test -n "$expecting_failure" && test "$test_cleanup" != ":" 942 then 943 setup_malloc_check 944 test_eval_ "$test_cleanup" 945 teardown_malloc_check 946 fi 947 if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE" 948 then 949 echo "" 950 fi 951 return "$eval_ret" 952} 953 954test_start_ () { 955 test_count=$(($test_count+1)) 956 maybe_setup_verbose 957 maybe_setup_valgrind 958 if test -n "$write_junit_xml" 959 then 960 junit_start=$(test-tool date getnanos) 961 fi 962} 963 964test_finish_ () { 965 echo >&3 "" 966 maybe_teardown_valgrind 967 maybe_teardown_verbose 968 if test -n "$GIT_TEST_TEE_OFFSET" 969 then 970 GIT_TEST_TEE_OFFSET=$(test-tool path-utils file-size \ 971 "$GIT_TEST_TEE_OUTPUT_FILE") 972 fi 973} 974 975test_skip () { 976 to_skip= 977 skipped_reason= 978 if match_pattern_list $this_test.$test_count $GIT_SKIP_TESTS 979 then 980 to_skip=t 981 skipped_reason="GIT_SKIP_TESTS" 982 fi 983 if test -z "$to_skip" && test -n "$test_prereq" && 984 ! test_have_prereq "$test_prereq" 985 then 986 to_skip=t 987 988 of_prereq= 989 if test "$missing_prereq" != "$test_prereq" 990 then 991 of_prereq=" of $test_prereq" 992 fi 993 skipped_reason="missing $missing_prereq${of_prereq}" 994 fi 995 if test -z "$to_skip" && test -n "$run_list" && 996 ! match_test_selector_list '--run' $test_count "$run_list" 997 then 998 to_skip=t 999 skipped_reason="--run"1000 fi10011002 case "$to_skip" in1003 t)1004 if test -n "$write_junit_xml"1005 then1006 message="$(xml_attr_encode "$skipped_reason")"1007 write_junit_xml_testcase "$1" \1008 " <skipped message=\"$message\" />"1009 fi10101011 say_color skip >&3 "skipping test: $@"1012 say_color skip "ok $test_count # skip $1 ($skipped_reason)"1013 : true1014 ;;1015 *)1016 false1017 ;;1018 esac1019}10201021# stub; perf-lib overrides it1022test_at_end_hook_ () {1023 :1024}10251026write_junit_xml () {1027 case "$1" in1028 --truncate)1029 >"$junit_xml_path"1030 junit_have_testcase=1031 shift1032 ;;1033 esac1034 printf '%s\n' "$@" >>"$junit_xml_path"1035}10361037xml_attr_encode () {1038 printf '%s\n' "$@" | test-tool xml-encode1039}10401041write_junit_xml_testcase () {1042 junit_attrs="name=\"$(xml_attr_encode "$this_test.$test_count $1")\""1043 shift1044 junit_attrs="$junit_attrs classname=\"$this_test\""1045 junit_attrs="$junit_attrs time=\"$(test-tool \1046 date getnanos $junit_start)\""1047 write_junit_xml "$(printf '%s\n' \1048 " <testcase $junit_attrs>" "$@" " </testcase>")"1049 junit_have_testcase=t1050}10511052test_done () {1053 GIT_EXIT_OK=t10541055 if test -n "$write_junit_xml" && test -n "$junit_xml_path"1056 then1057 test -n "$junit_have_testcase" || {1058 junit_start=$(test-tool date getnanos)1059 write_junit_xml_testcase "all tests skipped"1060 }10611062 # adjust the overall time1063 junit_time=$(test-tool date getnanos $junit_suite_start)1064 sed "s/<testsuite [^>]*/& time=\"$junit_time\"/" \1065 <"$junit_xml_path" >"$junit_xml_path.new"1066 mv "$junit_xml_path.new" "$junit_xml_path"10671068 write_junit_xml " </testsuite>" "</testsuites>"1069 fi10701071 if test -z "$HARNESS_ACTIVE"1072 then1073 mkdir -p "$TEST_RESULTS_DIR"10741075 cat >"$TEST_RESULTS_BASE.counts" <<-EOF1076 total $test_count1077 success $test_success1078 fixed $test_fixed1079 broken $test_broken1080 failed $test_failure10811082 EOF1083 fi10841085 if test "$test_fixed" != 01086 then1087 say_color error "# $test_fixed known breakage(s) vanished; please update test(s)"1088 fi1089 if test "$test_broken" != 01090 then1091 say_color warn "# still have $test_broken known breakage(s)"1092 fi1093 if test "$test_broken" != 0 || test "$test_fixed" != 01094 then1095 test_remaining=$(( $test_count - $test_broken - $test_fixed ))1096 msg="remaining $test_remaining test(s)"1097 else1098 test_remaining=$test_count1099 msg="$test_count test(s)"1100 fi1101 case "$test_failure" in1102 0)1103 if test $test_external_has_tap -eq 01104 then1105 if test $test_remaining -gt 01106 then1107 say_color pass "# passed all $msg"1108 fi11091110 # Maybe print SKIP message1111 test -z "$skip_all" || skip_all="# SKIP $skip_all"1112 case "$test_count" in1113 0)1114 say "1..$test_count${skip_all:+ $skip_all}"1115 ;;1116 *)1117 test -z "$skip_all" ||1118 say_color warn "$skip_all"1119 say "1..$test_count"1120 ;;1121 esac1122 fi11231124 if test -z "$debug"1125 then1126 test -d "$TRASH_DIRECTORY" ||1127 error "Tests passed but trash directory already removed before test cleanup; aborting"11281129 cd "$TRASH_DIRECTORY/.." &&1130 rm -fr "$TRASH_DIRECTORY" || {1131 # try again in a bit1132 sleep 5;1133 rm -fr "$TRASH_DIRECTORY"1134 } ||1135 error "Tests passed but test cleanup failed; aborting"1136 fi1137 test_at_end_hook_11381139 exit 0 ;;11401141 *)1142 if test $test_external_has_tap -eq 01143 then1144 say_color error "# failed $test_failure among $msg"1145 say "1..$test_count"1146 fi11471148 exit 1 ;;11491150 esac1151}11521153if test -n "$valgrind"1154then1155 make_symlink () {1156 test -h "$2" &&1157 test "$1" = "$(readlink "$2")" || {1158 # be super paranoid1159 if mkdir "$2".lock1160 then1161 rm -f "$2" &&1162 ln -s "$1" "$2" &&1163 rm -r "$2".lock1164 else1165 while test -d "$2".lock1166 do1167 say "Waiting for lock on $2."1168 sleep 11169 done1170 fi1171 }1172 }11731174 make_valgrind_symlink () {1175 # handle only executables, unless they are shell libraries that1176 # need to be in the exec-path.1177 test -x "$1" ||1178 test "# " = "$(test_copy_bytes 2 <"$1")" ||1179 return;11801181 base=$(basename "$1")1182 case "$base" in1183 test-*)1184 symlink_target="$GIT_BUILD_DIR/t/helper/$base"1185 ;;1186 *)1187 symlink_target="$GIT_BUILD_DIR/$base"1188 ;;1189 esac1190 # do not override scripts1191 if test -x "$symlink_target" &&1192 test ! -d "$symlink_target" &&1193 test "#!" != "$(test_copy_bytes 2 <"$symlink_target")"1194 then1195 symlink_target=../valgrind.sh1196 fi1197 case "$base" in1198 *.sh|*.perl)1199 symlink_target=../unprocessed-script1200 esac1201 # create the link, or replace it if it is out of date1202 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit1203 }12041205 # override all git executables in TEST_DIRECTORY/..1206 GIT_VALGRIND=$TEST_DIRECTORY/valgrind1207 mkdir -p "$GIT_VALGRIND"/bin1208 for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/t/helper/test-*1209 do1210 make_valgrind_symlink $file1211 done1212 # special-case the mergetools loadables1213 make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools"1214 OLDIFS=$IFS1215 IFS=:1216 for path in $PATH1217 do1218 ls "$path"/git-* 2> /dev/null |1219 while read file1220 do1221 make_valgrind_symlink "$file"1222 done1223 done1224 IFS=$OLDIFS1225 PATH=$GIT_VALGRIND/bin:$PATH1226 GIT_EXEC_PATH=$GIT_VALGRIND/bin1227 export GIT_VALGRIND1228 GIT_VALGRIND_MODE="$valgrind"1229 export GIT_VALGRIND_MODE1230 GIT_VALGRIND_ENABLED=t1231 test -n "$valgrind_only" && GIT_VALGRIND_ENABLED=1232 export GIT_VALGRIND_ENABLED1233elif test -n "$GIT_TEST_INSTALLED"1234then1235 GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path) ||1236 error "Cannot run git from $GIT_TEST_INSTALLED."1237 PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR/t/helper:$PATH1238 GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH}1239else # normal case, use ../bin-wrappers only unless $with_dashes:1240 if test -n "$no_bin_wrappers"1241 then1242 with_dashes=t1243 else1244 git_bin_dir="$GIT_BUILD_DIR/bin-wrappers"1245 if ! test -x "$git_bin_dir/git"1246 then1247 if test -z "$with_dashes"1248 then1249 say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH"1250 fi1251 with_dashes=t1252 fi1253 PATH="$git_bin_dir:$PATH"1254 fi1255 GIT_EXEC_PATH=$GIT_BUILD_DIR1256 if test -n "$with_dashes"1257 then1258 PATH="$GIT_BUILD_DIR:$GIT_BUILD_DIR/t/helper:$PATH"1259 fi1260fi1261GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt1262GIT_CONFIG_NOSYSTEM=11263GIT_ATTR_NOSYSTEM=11264export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM12651266if test -z "$GIT_TEST_CMP"1267then1268 if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT"1269 then1270 GIT_TEST_CMP="$DIFF -c"1271 else1272 GIT_TEST_CMP="$DIFF -u"1273 fi1274fi12751276GITPERLLIB="$GIT_BUILD_DIR"/perl/build/lib1277export GITPERLLIB1278test -d "$GIT_BUILD_DIR"/templates/blt || {1279 error "You haven't built things yet, have you?"1280}12811282if ! test -x "$GIT_BUILD_DIR"/t/helper/test-tool$X1283then1284 echo >&2 'You need to build test-tool:'1285 echo >&2 'Run "make t/helper/test-tool" in the source (toplevel) directory'1286 exit 11287fi12881289# Test repository1290rm -fr "$TRASH_DIRECTORY" || {1291 GIT_EXIT_OK=t1292 echo >&5 "FATAL: Cannot prepare test area"1293 exit 11294}12951296HOME="$TRASH_DIRECTORY"1297GNUPGHOME="$HOME/gnupg-home-not-used"1298export HOME GNUPGHOME12991300if test -z "$TEST_NO_CREATE_REPO"1301then1302 test_create_repo "$TRASH_DIRECTORY"1303else1304 mkdir -p "$TRASH_DIRECTORY"1305fi13061307# Use -P to resolve symlinks in our working directory so that the cwd1308# in subprocesses like git equals our $PWD (for pathname comparisons).1309cd -P "$TRASH_DIRECTORY" || exit 113101311this_test=${0##*/}1312this_test=${this_test%%-*}1313if match_pattern_list "$this_test" $GIT_SKIP_TESTS1314then1315 say_color info >&3 "skipping test $this_test altogether"1316 skip_all="skip all tests in $this_test"1317 test_done1318fi13191320if test -n "$write_junit_xml"1321then1322 junit_xml_dir="$TEST_OUTPUT_DIRECTORY/out"1323 mkdir -p "$junit_xml_dir"1324 junit_xml_base=${0##*/}1325 junit_xml_path="$junit_xml_dir/TEST-${junit_xml_base%.sh}.xml"1326 junit_attrs="name=\"${junit_xml_base%.sh}\""1327 junit_attrs="$junit_attrs timestamp=\"$(TZ=UTC \1328 date +%Y-%m-%dT%H:%M:%S)\""1329 write_junit_xml --truncate "<testsuites>" " <testsuite $junit_attrs>"1330 junit_suite_start=$(test-tool date getnanos)1331 if test -n "$GIT_TEST_TEE_OUTPUT_FILE"1332 then1333 GIT_TEST_TEE_OFFSET=01334 fi1335fi13361337# Provide an implementation of the 'yes' utility; the upper bound1338# limit is there to help Windows that cannot stop this loop from1339# wasting cycles when the downstream stops reading, so do not be1340# tempted to turn it into an infinite loop. cf. 6129c930 ("test-lib:1341# limit the output of the yes utility", 2016-02-02)1342yes () {1343 if test $# = 01344 then1345 y=y1346 else1347 y="$*"1348 fi13491350 i=01351 while test $i -lt 991352 do1353 echo "$y"1354 i=$(($i+1))1355 done1356}13571358# Fix some commands on Windows1359uname_s=$(uname -s)1360case $uname_s in1361*MINGW*)1362 # Windows has its own (incompatible) sort and find1363 sort () {1364 /usr/bin/sort "$@"1365 }1366 find () {1367 /usr/bin/find "$@"1368 }1369 # git sees Windows-style pwd1370 pwd () {1371 builtin pwd -W1372 }1373 # no POSIX permissions1374 # backslashes in pathspec are converted to '/'1375 # exec does not inherit the PID1376 test_set_prereq MINGW1377 test_set_prereq NATIVE_CRLF1378 test_set_prereq SED_STRIPS_CR1379 test_set_prereq GREP_STRIPS_CR1380 GIT_TEST_CMP=mingw_test_cmp1381 ;;1382*CYGWIN*)1383 test_set_prereq POSIXPERM1384 test_set_prereq EXECKEEPSPID1385 test_set_prereq CYGWIN1386 test_set_prereq SED_STRIPS_CR1387 test_set_prereq GREP_STRIPS_CR1388 ;;1389*)1390 test_set_prereq POSIXPERM1391 test_set_prereq BSLASHPSPEC1392 test_set_prereq EXECKEEPSPID1393 ;;1394esac13951396( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_11397test -z "$NO_PERL" && test_set_prereq PERL1398test -z "$NO_PTHREADS" && test_set_prereq PTHREADS1399test -z "$NO_PYTHON" && test_set_prereq PYTHON1400test -n "$USE_LIBPCRE1$USE_LIBPCRE2" && test_set_prereq PCRE1401test -n "$USE_LIBPCRE1" && test_set_prereq LIBPCRE11402test -n "$USE_LIBPCRE2" && test_set_prereq LIBPCRE21403test -z "$NO_GETTEXT" && test_set_prereq GETTEXT14041405if test -n "$GIT_TEST_GETTEXT_POISON_ORIG"1406then1407 GIT_TEST_GETTEXT_POISON=$GIT_TEST_GETTEXT_POISON_ORIG1408 unset GIT_TEST_GETTEXT_POISON_ORIG1409fi14101411# Can we rely on git's output in the C locale?1412if test -z "$GIT_TEST_GETTEXT_POISON"1413then1414 test_set_prereq C_LOCALE_OUTPUT1415fi14161417if test -z "$GIT_TEST_CHECK_CACHE_TREE"1418then1419 GIT_TEST_CHECK_CACHE_TREE=true1420 export GIT_TEST_CHECK_CACHE_TREE1421fi14221423test_lazy_prereq PIPE '1424 # test whether the filesystem supports FIFOs1425 test_have_prereq !MINGW,!CYGWIN &&1426 rm -f testfifo && mkfifo testfifo1427'14281429test_lazy_prereq SYMLINKS '1430 # test whether the filesystem supports symbolic links1431 ln -s x y && test -h y1432'14331434test_lazy_prereq FILEMODE '1435 test "$(git config --bool core.filemode)" = true1436'14371438test_lazy_prereq CASE_INSENSITIVE_FS '1439 echo good >CamelCase &&1440 echo bad >camelcase &&1441 test "$(cat CamelCase)" != good1442'14431444test_lazy_prereq FUNNYNAMES '1445 test_have_prereq !MINGW &&1446 touch -- \1447 "FUNNYNAMES tab embedded" \1448 "FUNNYNAMES \"quote embedded\"" \1449 "FUNNYNAMES newline1450embedded" 2>/dev/null &&1451 rm -- \1452 "FUNNYNAMES tab embedded" \1453 "FUNNYNAMES \"quote embedded\"" \1454 "FUNNYNAMES newline1455embedded" 2>/dev/null1456'14571458test_lazy_prereq UTF8_NFD_TO_NFC '1459 # check whether FS converts nfd unicode to nfc1460 auml=$(printf "\303\244")1461 aumlcdiar=$(printf "\141\314\210")1462 >"$auml" &&1463 test -f "$aumlcdiar"1464'14651466test_lazy_prereq AUTOIDENT '1467 sane_unset GIT_AUTHOR_NAME &&1468 sane_unset GIT_AUTHOR_EMAIL &&1469 git var GIT_AUTHOR_IDENT1470'14711472test_lazy_prereq EXPENSIVE '1473 test -n "$GIT_TEST_LONG"1474'14751476test_lazy_prereq EXPENSIVE_ON_WINDOWS '1477 test_have_prereq EXPENSIVE || test_have_prereq !MINGW,!CYGWIN1478'14791480test_lazy_prereq USR_BIN_TIME '1481 test -x /usr/bin/time1482'14831484test_lazy_prereq NOT_ROOT '1485 uid=$(id -u) &&1486 test "$uid" != 01487'14881489test_lazy_prereq JGIT '1490 type jgit1491'14921493# SANITY is about "can you correctly predict what the filesystem would1494# do by only looking at the permission bits of the files and1495# directories?" A typical example of !SANITY is running the test1496# suite as root, where a test may expect "chmod -r file && cat file"1497# to fail because file is supposed to be unreadable after a successful1498# chmod. In an environment (i.e. combination of what filesystem is1499# being used and who is running the tests) that lacks SANITY, you may1500# be able to delete or create a file when the containing directory1501# doesn't have write permissions, or access a file even if the1502# containing directory doesn't have read or execute permissions.15031504test_lazy_prereq SANITY '1505 mkdir SANETESTD.1 SANETESTD.2 &&15061507 chmod +w SANETESTD.1 SANETESTD.2 &&1508 >SANETESTD.1/x 2>SANETESTD.2/x &&1509 chmod -w SANETESTD.1 &&1510 chmod -r SANETESTD.1/x &&1511 chmod -rx SANETESTD.2 ||1512 BUG "cannot prepare SANETESTD"15131514 ! test -r SANETESTD.1/x &&1515 ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x1516 status=$?15171518 chmod +rwx SANETESTD.1 SANETESTD.2 &&1519 rm -rf SANETESTD.1 SANETESTD.2 ||1520 BUG "cannot clean SANETESTD"1521 return $status1522'15231524test FreeBSD != $uname_s || GIT_UNZIP=${GIT_UNZIP:-/usr/local/bin/unzip}1525GIT_UNZIP=${GIT_UNZIP:-unzip}1526test_lazy_prereq UNZIP '1527 "$GIT_UNZIP" -v1528 test $? -ne 1271529'15301531run_with_limited_cmdline () {1532 (ulimit -s 128 && "$@")1533}15341535test_lazy_prereq CMDLINE_LIMIT '1536 test_have_prereq !MINGW,!CYGWIN &&1537 run_with_limited_cmdline true1538'15391540run_with_limited_stack () {1541 (ulimit -s 128 && "$@")1542}15431544test_lazy_prereq ULIMIT_STACK_SIZE '1545 test_have_prereq !MINGW,!CYGWIN &&1546 run_with_limited_stack true1547'15481549build_option () {1550 git version --build-options |1551 sed -ne "s/^$1: //p"1552}15531554test_lazy_prereq LONG_IS_64BIT '1555 test 8 -le "$(build_option sizeof-long)"1556'15571558test_lazy_prereq TIME_IS_64BIT 'test-tool date is64bit'1559test_lazy_prereq TIME_T_IS_64BIT 'test-tool date time_t-is64bit'15601561test_lazy_prereq CURL '1562 curl --version1563'15641565# SHA1 is a test if the hash algorithm in use is SHA-1. This is both for tests1566# which will not work with other hash algorithms and tests that work but don't1567# test anything meaningful (e.g. special values which cause short collisions).1568test_lazy_prereq SHA1 '1569 test $(git hash-object /dev/null) = e69de29bb2d1d6434b8b29ae775ad8c2e48c53911570'15711572test_lazy_prereq REBASE_P '1573 test -z "$GIT_TEST_SKIP_REBASE_P"1574'