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 52################################################################ 53# It appears that people try to run tests without building... 54"$GIT_BUILD_DIR/git" >/dev/null 55if test $? != 1 56then 57 echo >&2 'error: you do not seem to have built git yet.' 58 exit 1 59fi 60 61. "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS 62export PERL_PATH SHELL_PATH 63 64# if --tee was passed, write the output not only to the terminal, but 65# additionally to the file test-results/$BASENAME.out, too. 66case "$GIT_TEST_TEE_STARTED, $* " in 67done,*) 68 # do not redirect again 69 ;; 70*' --tee '*|*' --va'*|*' --verbose-log '*) 71 mkdir -p "$TEST_OUTPUT_DIRECTORY/test-results" 72 BASE="$TEST_OUTPUT_DIRECTORY/test-results/$(basename "$0" .sh)" 73 74 # Make this filename available to the sub-process in case it is using 75 # --verbose-log. 76 GIT_TEST_TEE_OUTPUT_FILE=$BASE.out 77 export GIT_TEST_TEE_OUTPUT_FILE 78 79 # Truncate before calling "tee -a" to get rid of the results 80 # from any previous runs. 81 >"$GIT_TEST_TEE_OUTPUT_FILE" 82 83 (GIT_TEST_TEE_STARTED=done ${SHELL_PATH} "$0" "$@" 2>&1; 84 echo $? >"$BASE.exit") | tee -a "$GIT_TEST_TEE_OUTPUT_FILE" 85 test "$(cat "$BASE.exit")" = 0 86 exit 87 ;; 88esac 89 90# For repeatability, reset the environment to known value. 91# TERM is sanitized below, after saving color control sequences. 92LANG=C 93LC_ALL=C 94PAGER=cat 95TZ=UTC 96export LANG LC_ALL PAGER TZ 97EDITOR=: 98# A call to "unset" with no arguments causes at least Solaris 10 99# /usr/xpg4/bin/sh and /bin/ksh to bail out. So keep the unsets 100# deriving from the command substitution clustered with the other 101# ones. 102unset VISUAL EMAIL LANGUAGE COLUMNS $("$PERL_PATH" -e ' 103 my @env = keys %ENV; 104 my $ok = join("|", qw( 105 TRACE 106 DEBUG 107 TEST 108 .*_TEST 109 PROVE 110 VALGRIND 111 UNZIP 112 PERF_ 113 CURL_VERBOSE 114 TRACE_CURL 115 )); 116 my @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env); 117 print join("\n", @vars); 118') 119unset XDG_CONFIG_HOME 120unset GITPERLLIB 121GIT_AUTHOR_EMAIL=author@example.com 122GIT_AUTHOR_NAME='A U Thor' 123GIT_COMMITTER_EMAIL=committer@example.com 124GIT_COMMITTER_NAME='C O Mitter' 125GIT_MERGE_VERBOSITY=5 126GIT_MERGE_AUTOEDIT=no 127export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT 128export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME 129export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME 130export EDITOR 131 132# Tests using GIT_TRACE typically don't want <timestamp> <file>:<line> output 133GIT_TRACE_BARE=1 134export GIT_TRACE_BARE 135 136if test -n "${TEST_GIT_INDEX_VERSION:+isset}" 137then 138 GIT_INDEX_VERSION="$TEST_GIT_INDEX_VERSION" 139 export GIT_INDEX_VERSION 140fi 141 142# Add libc MALLOC and MALLOC_PERTURB test 143# only if we are not executing the test with valgrind 144if expr " $GIT_TEST_OPTS " : ".* --valgrind " >/dev/null || 145 test -n "$TEST_NO_MALLOC_CHECK" 146then 147 setup_malloc_check () { 148 : nothing 149 } 150 teardown_malloc_check () { 151 : nothing 152 } 153else 154 setup_malloc_check () { 155 MALLOC_CHECK_=3 MALLOC_PERTURB_=165 156 export MALLOC_CHECK_ MALLOC_PERTURB_ 157 } 158 teardown_malloc_check () { 159 unset MALLOC_CHECK_ MALLOC_PERTURB_ 160 } 161fi 162 163# Protect ourselves from common misconfiguration to export 164# CDPATH into the environment 165unset CDPATH 166 167unset GREP_OPTIONS 168unset UNZIP 169 170case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in 1711|2|true) 172 GIT_TRACE=4 173 ;; 174esac 175 176# Convenience 177# 178# A regexp to match 5, 35 and 40 hexdigits 179_x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]' 180_x35="$_x05$_x05$_x05$_x05$_x05$_x05$_x05" 181_x40="$_x35$_x05" 182 183# Zero SHA-1 184_z40=0000000000000000000000000000000000000000 185 186EMPTY_TREE=4b825dc642cb6eb9a060e54bf8d69288fbee4904 187EMPTY_BLOB=e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 188 189# Line feed 190LF=' 191' 192 193# UTF-8 ZERO WIDTH NON-JOINER, which HFS+ ignores 194# when case-folding filenames 195u200c=$(printf '\342\200\214') 196 197export _x05 _x35 _x40 _z40 LF u200c EMPTY_TREE EMPTY_BLOB 198 199# Each test should start with something like this, after copyright notices: 200# 201# test_description='Description of this test... 202# This test checks if command xyzzy does the right thing... 203# ' 204# . ./test-lib.sh 205test "x$TERM" != "xdumb" && ( 206 test -t 1 && 207 tput bold >/dev/null 2>&1 && 208 tput setaf 1 >/dev/null 2>&1 && 209 tput sgr0 >/dev/null 2>&1 210 ) && 211 color=t 212 213while test "$#" -ne 0 214do 215 case "$1" in 216 -d|--d|--de|--deb|--debu|--debug) 217 debug=t; shift ;; 218 -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate) 219 immediate=t; shift ;; 220 -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests) 221 GIT_TEST_LONG=t; export GIT_TEST_LONG; shift ;; 222 -r) 223 shift; test "$#" -ne 0 || { 224 echo 'error: -r requires an argument' >&2; 225 exit 1; 226 } 227 run_list=$1; shift ;; 228 --run=*) 229 run_list=${1#--*=}; shift ;; 230 -h|--h|--he|--hel|--help) 231 help=t; shift ;; 232 -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose) 233 verbose=t; shift ;; 234 --verbose-only=*) 235 verbose_only=${1#--*=} 236 shift ;; 237 -q|--q|--qu|--qui|--quie|--quiet) 238 # Ignore --quiet under a TAP::Harness. Saying how many tests 239 # passed without the ok/not ok details is always an error. 240 test -z "$HARNESS_ACTIVE" && quiet=t; shift ;; 241 --with-dashes) 242 with_dashes=t; shift ;; 243 --no-color) 244 color=; shift ;; 245 --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind) 246 valgrind=memcheck 247 shift ;; 248 --valgrind=*) 249 valgrind=${1#--*=} 250 shift ;; 251 --valgrind-only=*) 252 valgrind_only=${1#--*=} 253 shift ;; 254 --tee) 255 shift ;; # was handled already 256 --root=*) 257 root=${1#--*=} 258 shift ;; 259 --chain-lint) 260 GIT_TEST_CHAIN_LINT=1 261 shift ;; 262 --no-chain-lint) 263 GIT_TEST_CHAIN_LINT=0 264 shift ;; 265 -x) 266 trace=t 267 shift ;; 268 --verbose-log) 269 verbose_log=t 270 shift ;; 271 *) 272 echo "error: unknown test option '$1'" >&2; exit 1 ;; 273 esac 274done 275 276if test -n "$valgrind_only" 277then 278 test -z "$valgrind" && valgrind=memcheck 279 test -z "$verbose" && verbose_only="$valgrind_only" 280elif test -n "$valgrind" 281then 282 test -z "$verbose_log" && verbose=t 283fi 284 285if test -n "$trace" && test -z "$verbose_log" 286then 287 verbose=t 288fi 289 290if test -n "$color" 291then 292 # Save the color control sequences now rather than run tput 293 # each time say_color() is called. This is done for two 294 # reasons: 295 # * TERM will be changed to dumb 296 # * HOME will be changed to a temporary directory and tput 297 # might need to read ~/.terminfo from the original HOME 298 # directory to get the control sequences 299 # Note: This approach assumes the control sequences don't end 300 # in a newline for any terminal of interest (command 301 # substitutions strip trailing newlines). Given that most 302 # (all?) terminals in common use are related to ECMA-48, this 303 # shouldn't be a problem. 304 say_color_error=$(tput bold; tput setaf 1) # bold red 305 say_color_skip=$(tput setaf 4) # blue 306 say_color_warn=$(tput setaf 3) # brown/yellow 307 say_color_pass=$(tput setaf 2) # green 308 say_color_info=$(tput setaf 6) # cyan 309 say_color_reset=$(tput sgr0) 310 say_color_="" # no formatting for normal text 311 say_color () { 312 test -z "$1" && test -n "$quiet" && return 313 eval "say_color_color=\$say_color_$1" 314 shift 315 printf "%s\\n" "$say_color_color$*$say_color_reset" 316 } 317else 318 say_color() { 319 test -z "$1" && test -n "$quiet" && return 320 shift 321 printf "%s\n" "$*" 322 } 323fi 324 325TERM=dumb 326export TERM 327 328error () { 329 say_color error "error: $*" 330 GIT_EXIT_OK=t 331 exit 1 332} 333 334say () { 335 say_color info "$*" 336} 337 338if test -n "$HARNESS_ACTIVE" 339then 340 if test "$verbose" = t || test -n "$verbose_only" 341 then 342 printf 'Bail out! %s\n' \ 343 'verbose mode forbidden under TAP harness; try --verbose-log' 344 exit 1 345 fi 346fi 347 348test "${test_description}" != "" || 349error "Test script did not set test_description." 350 351if test "$help" = "t" 352then 353 printf '%s\n' "$test_description" 354 exit 0 355fi 356 357exec 5>&1 358exec 6<&0 359exec 7>&2 360if test "$verbose_log" = "t" 361then 362 exec 3>>"$GIT_TEST_TEE_OUTPUT_FILE" 4>&3 363elif test "$verbose" = "t" 364then 365 exec 4>&2 3>&1 366else 367 exec 4>/dev/null 3>/dev/null 368fi 369 370# Send any "-x" output directly to stderr to avoid polluting tests 371# which capture stderr. We can do this unconditionally since it 372# has no effect if tracing isn't turned on. 373# 374# Note that this sets up the trace fd as soon as we assign the variable, so it 375# must come after the creation of descriptor 4 above. Likewise, we must never 376# unset this, as it has the side effect of closing descriptor 4, which we 377# use to show verbose tests to the user. 378# 379# Note also that we don't need or want to export it. The tracing is local to 380# this shell, and we would not want to influence any shells we exec. 381BASH_XTRACEFD=4 382 383test_failure=0 384test_count=0 385test_fixed=0 386test_broken=0 387test_success=0 388 389test_external_has_tap=0 390 391die () { 392 code=$? 393 if test -n "$GIT_EXIT_OK" 394 then 395 exit $code 396 else 397 echo >&5 "FATAL: Unexpected exit with code $code" 398 exit 1 399 fi 400} 401 402GIT_EXIT_OK= 403trap 'die' EXIT 404trap 'exit $?' INT 405 406# The user-facing functions are loaded from a separate file so that 407# test_perf subshells can have them too 408. "$TEST_DIRECTORY/test-lib-functions.sh" 409 410# You are not expected to call test_ok_ and test_failure_ directly, use 411# the test_expect_* functions instead. 412 413test_ok_ () { 414 test_success=$(($test_success + 1)) 415 say_color "" "ok $test_count - $@" 416} 417 418test_failure_ () { 419 test_failure=$(($test_failure + 1)) 420 say_color error "not ok $test_count - $1" 421 shift 422 printf '%s\n' "$*" | sed -e 's/^/# /' 423 test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; } 424} 425 426test_known_broken_ok_ () { 427 test_fixed=$(($test_fixed+1)) 428 say_color error "ok $test_count - $@ # TODO known breakage vanished" 429} 430 431test_known_broken_failure_ () { 432 test_broken=$(($test_broken+1)) 433 say_color warn "not ok $test_count - $@ # TODO known breakage" 434} 435 436test_debug () { 437 test "$debug" = "" || eval "$1" 438} 439 440match_pattern_list () { 441 arg="$1" 442 shift 443 test -z "$*" && return 1 444 for pattern_ 445 do 446 case "$arg" in 447 $pattern_) 448 return 0 449 esac 450 done 451 return 1 452} 453 454match_test_selector_list () { 455 title="$1" 456 shift 457 arg="$1" 458 shift 459 test -z "$1" && return 0 460 461 # Both commas and whitespace are accepted as separators. 462 OLDIFS=$IFS 463 IFS=' ,' 464 set -- $1 465 IFS=$OLDIFS 466 467 # If the first selector is negative we include by default. 468 include= 469 case "$1" in 470 !*) include=t ;; 471 esac 472 473 for selector 474 do 475 orig_selector=$selector 476 477 positive=t 478 case "$selector" in 479 !*) 480 positive= 481 selector=${selector##?} 482 ;; 483 esac 484 485 test -z "$selector" && continue 486 487 case "$selector" in 488 *-*) 489 if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null 490 then 491 echo "error: $title: invalid non-numeric in range" \ 492 "start: '$orig_selector'" >&2 493 exit 1 494 fi 495 if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null 496 then 497 echo "error: $title: invalid non-numeric in range" \ 498 "end: '$orig_selector'" >&2 499 exit 1 500 fi 501 ;; 502 *) 503 if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null 504 then 505 echo "error: $title: invalid non-numeric in test" \ 506 "selector: '$orig_selector'" >&2 507 exit 1 508 fi 509 esac 510 511 # Short cut for "obvious" cases 512 test -z "$include" && test -z "$positive" && continue 513 test -n "$include" && test -n "$positive" && continue 514 515 case "$selector" in 516 -*) 517 if test $arg -le ${selector#-} 518 then 519 include=$positive 520 fi 521 ;; 522 *-) 523 if test $arg -ge ${selector%-} 524 then 525 include=$positive 526 fi 527 ;; 528 *-*) 529 if test ${selector%%-*} -le $arg \ 530 && test $arg -le ${selector#*-} 531 then 532 include=$positive 533 fi 534 ;; 535 *) 536 if test $arg -eq $selector 537 then 538 include=$positive 539 fi 540 ;; 541 esac 542 done 543 544 test -n "$include" 545} 546 547maybe_teardown_verbose () { 548 test -z "$verbose_only" && return 549 exec 4>/dev/null 3>/dev/null 550 verbose= 551} 552 553last_verbose=t 554maybe_setup_verbose () { 555 test -z "$verbose_only" && return 556 if match_pattern_list $test_count $verbose_only 557 then 558 exec 4>&2 3>&1 559 # Emit a delimiting blank line when going from 560 # non-verbose to verbose. Within verbose mode the 561 # delimiter is printed by test_expect_*. The choice 562 # of the initial $last_verbose is such that before 563 # test 1, we do not print it. 564 test -z "$last_verbose" && echo >&3 "" 565 verbose=t 566 else 567 exec 4>/dev/null 3>/dev/null 568 verbose= 569 fi 570 last_verbose=$verbose 571} 572 573maybe_teardown_valgrind () { 574 test -z "$GIT_VALGRIND" && return 575 GIT_VALGRIND_ENABLED= 576} 577 578maybe_setup_valgrind () { 579 test -z "$GIT_VALGRIND" && return 580 if test -z "$valgrind_only" 581 then 582 GIT_VALGRIND_ENABLED=t 583 return 584 fi 585 GIT_VALGRIND_ENABLED= 586 if match_pattern_list $test_count $valgrind_only 587 then 588 GIT_VALGRIND_ENABLED=t 589 fi 590} 591 592want_trace () { 593 test "$trace" = t && { 594 test "$verbose" = t || test "$verbose_log" = t 595 } 596} 597 598# This is a separate function because some tests use 599# "return" to end a test_expect_success block early 600# (and we want to make sure we run any cleanup like 601# "set +x"). 602test_eval_inner_ () { 603 # Do not add anything extra (including LF) after '$*' 604 eval " 605 want_trace && set -x 606 $*" 607} 608 609test_eval_ () { 610 # If "-x" tracing is in effect, then we want to avoid polluting stderr 611 # with non-test commands. But once in "set -x" mode, we cannot prevent 612 # the shell from printing the "set +x" to turn it off (nor the saving 613 # of $? before that). But we can make sure that the output goes to 614 # /dev/null. 615 # 616 # There are a few subtleties here: 617 # 618 # - we have to redirect descriptor 4 in addition to 2, to cover 619 # BASH_XTRACEFD 620 # 621 # - the actual eval has to come before the redirection block (since 622 # it needs to see descriptor 4 to set up its stderr) 623 # 624 # - likewise, any error message we print must be outside the block to 625 # access descriptor 4 626 # 627 # - checking $? has to come immediately after the eval, but it must 628 # be _inside_ the block to avoid polluting the "set -x" output 629 # 630 631 test_eval_inner_ "$@" </dev/null >&3 2>&4 632 { 633 test_eval_ret_=$? 634 if want_trace 635 then 636 set +x 637 fi 638 } 2>/dev/null 4>&2 639 640 if test "$test_eval_ret_" != 0 && want_trace 641 then 642 say_color error >&4 "error: last command exited with \$?=$test_eval_ret_" 643 fi 644 return $test_eval_ret_ 645} 646 647test_run_ () { 648 test_cleanup=: 649 expecting_failure=$2 650 651 if test "${GIT_TEST_CHAIN_LINT:-1}" != 0; then 652 # turn off tracing for this test-eval, as it simply creates 653 # confusing noise in the "-x" output 654 trace_tmp=$trace 655 trace= 656 # 117 is magic because it is unlikely to match the exit 657 # code of other programs 658 if test "OK-117" != "$(test_eval_ "(exit 117) && $1${LF}${LF}echo OK-\$?" 3>&1)" 659 then 660 error "bug in the test script: broken &&-chain or run-away HERE-DOC: $1" 661 fi 662 trace=$trace_tmp 663 fi 664 665 setup_malloc_check 666 test_eval_ "$1" 667 eval_ret=$? 668 teardown_malloc_check 669 670 if test -z "$immediate" || test $eval_ret = 0 || 671 test -n "$expecting_failure" && test "$test_cleanup" != ":" 672 then 673 setup_malloc_check 674 test_eval_ "$test_cleanup" 675 teardown_malloc_check 676 fi 677 if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE" 678 then 679 echo "" 680 fi 681 return "$eval_ret" 682} 683 684test_start_ () { 685 test_count=$(($test_count+1)) 686 maybe_setup_verbose 687 maybe_setup_valgrind 688} 689 690test_finish_ () { 691 echo >&3 "" 692 maybe_teardown_valgrind 693 maybe_teardown_verbose 694} 695 696test_skip () { 697 to_skip= 698 skipped_reason= 699 if match_pattern_list $this_test.$test_count $GIT_SKIP_TESTS 700 then 701 to_skip=t 702 skipped_reason="GIT_SKIP_TESTS" 703 fi 704 if test -z "$to_skip" && test -n "$test_prereq" && 705 ! test_have_prereq "$test_prereq" 706 then 707 to_skip=t 708 709 of_prereq= 710 if test "$missing_prereq" != "$test_prereq" 711 then 712 of_prereq=" of $test_prereq" 713 fi 714 skipped_reason="missing $missing_prereq${of_prereq}" 715 fi 716 if test -z "$to_skip" && test -n "$run_list" && 717 ! match_test_selector_list '--run' $test_count "$run_list" 718 then 719 to_skip=t 720 skipped_reason="--run" 721 fi 722 723 case "$to_skip" in 724 t) 725 say_color skip >&3 "skipping test: $@" 726 say_color skip "ok $test_count # skip $1 ($skipped_reason)" 727 : true 728 ;; 729 *) 730 false 731 ;; 732 esac 733} 734 735# stub; perf-lib overrides it 736test_at_end_hook_ () { 737 : 738} 739 740test_done () { 741 GIT_EXIT_OK=t 742 743 if test -z "$HARNESS_ACTIVE" 744 then 745 test_results_dir="$TEST_OUTPUT_DIRECTORY/test-results" 746 mkdir -p "$test_results_dir" 747 base=${0##*/} 748 test_results_path="$test_results_dir/${base%.sh}.counts" 749 750 cat >"$test_results_path" <<-EOF 751 total $test_count 752 success $test_success 753 fixed $test_fixed 754 broken $test_broken 755 failed $test_failure 756 757 EOF 758 fi 759 760 if test "$test_fixed" != 0 761 then 762 say_color error "# $test_fixed known breakage(s) vanished; please update test(s)" 763 fi 764 if test "$test_broken" != 0 765 then 766 say_color warn "# still have $test_broken known breakage(s)" 767 fi 768 if test "$test_broken" != 0 || test "$test_fixed" != 0 769 then 770 test_remaining=$(( $test_count - $test_broken - $test_fixed )) 771 msg="remaining $test_remaining test(s)" 772 else 773 test_remaining=$test_count 774 msg="$test_count test(s)" 775 fi 776 case "$test_failure" in 777 0) 778 if test $test_external_has_tap -eq 0 779 then 780 if test $test_remaining -gt 0 781 then 782 say_color pass "# passed all $msg" 783 fi 784 785 # Maybe print SKIP message 786 test -z "$skip_all" || skip_all="# SKIP $skip_all" 787 case "$test_count" in 788 0) 789 say "1..$test_count${skip_all:+ $skip_all}" 790 ;; 791 *) 792 test -z "$skip_all" || 793 say_color warn "$skip_all" 794 say "1..$test_count" 795 ;; 796 esac 797 fi 798 799 if test -z "$debug" 800 then 801 test -d "$TRASH_DIRECTORY" || 802 error "Tests passed but trash directory already removed before test cleanup; aborting" 803 804 cd "$TRASH_DIRECTORY/.." && 805 rm -fr "$TRASH_DIRECTORY" || 806 error "Tests passed but test cleanup failed; aborting" 807 fi 808 test_at_end_hook_ 809 810 exit 0 ;; 811 812 *) 813 if test $test_external_has_tap -eq 0 814 then 815 say_color error "# failed $test_failure among $msg" 816 say "1..$test_count" 817 fi 818 819 exit 1 ;; 820 821 esac 822} 823 824if test -n "$valgrind" 825then 826 make_symlink () { 827 test -h "$2" && 828 test "$1" = "$(readlink "$2")" || { 829 # be super paranoid 830 if mkdir "$2".lock 831 then 832 rm -f "$2" && 833 ln -s "$1" "$2" && 834 rm -r "$2".lock 835 else 836 while test -d "$2".lock 837 do 838 say "Waiting for lock on $2." 839 sleep 1 840 done 841 fi 842 } 843 } 844 845 make_valgrind_symlink () { 846 # handle only executables, unless they are shell libraries that 847 # need to be in the exec-path. 848 test -x "$1" || 849 test "# " = "$(head -c 2 <"$1")" || 850 return; 851 852 base=$(basename "$1") 853 case "$base" in 854 test-*) 855 symlink_target="$GIT_BUILD_DIR/t/helper/$base" 856 ;; 857 *) 858 symlink_target="$GIT_BUILD_DIR/$base" 859 ;; 860 esac 861 # do not override scripts 862 if test -x "$symlink_target" && 863 test ! -d "$symlink_target" && 864 test "#!" != "$(head -c 2 < "$symlink_target")" 865 then 866 symlink_target=../valgrind.sh 867 fi 868 case "$base" in 869 *.sh|*.perl) 870 symlink_target=../unprocessed-script 871 esac 872 # create the link, or replace it if it is out of date 873 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit 874 } 875 876 # override all git executables in TEST_DIRECTORY/.. 877 GIT_VALGRIND=$TEST_DIRECTORY/valgrind 878 mkdir -p "$GIT_VALGRIND"/bin 879 for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/t/helper/test-* 880 do 881 make_valgrind_symlink $file 882 done 883 # special-case the mergetools loadables 884 make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools" 885 OLDIFS=$IFS 886 IFS=: 887 for path in $PATH 888 do 889 ls "$path"/git-* 2> /dev/null | 890 while read file 891 do 892 make_valgrind_symlink "$file" 893 done 894 done 895 IFS=$OLDIFS 896 PATH=$GIT_VALGRIND/bin:$PATH 897 GIT_EXEC_PATH=$GIT_VALGRIND/bin 898 export GIT_VALGRIND 899 GIT_VALGRIND_MODE="$valgrind" 900 export GIT_VALGRIND_MODE 901 GIT_VALGRIND_ENABLED=t 902 test -n "$valgrind_only" && GIT_VALGRIND_ENABLED= 903 export GIT_VALGRIND_ENABLED 904elif test -n "$GIT_TEST_INSTALLED" 905then 906 GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path) || 907 error "Cannot run git from $GIT_TEST_INSTALLED." 908 PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR:$PATH 909 GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH} 910else # normal case, use ../bin-wrappers only unless $with_dashes: 911 git_bin_dir="$GIT_BUILD_DIR/bin-wrappers" 912 if ! test -x "$git_bin_dir/git" 913 then 914 if test -z "$with_dashes" 915 then 916 say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH" 917 fi 918 with_dashes=t 919 fi 920 PATH="$git_bin_dir:$PATH" 921 GIT_EXEC_PATH=$GIT_BUILD_DIR 922 if test -n "$with_dashes" 923 then 924 PATH="$GIT_BUILD_DIR:$PATH" 925 fi 926fi 927GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt 928GIT_CONFIG_NOSYSTEM=1 929GIT_ATTR_NOSYSTEM=1 930export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM 931 932if test -z "$GIT_TEST_CMP" 933then 934 if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT" 935 then 936 GIT_TEST_CMP="$DIFF -c" 937 else 938 GIT_TEST_CMP="$DIFF -u" 939 fi 940fi 941 942GITPERLLIB="$GIT_BUILD_DIR"/perl/blib/lib:"$GIT_BUILD_DIR"/perl/blib/arch/auto/Git 943export GITPERLLIB 944test -d "$GIT_BUILD_DIR"/templates/blt || { 945 error "You haven't built things yet, have you?" 946} 947 948if ! test -x "$GIT_BUILD_DIR"/t/helper/test-chmtime 949then 950 echo >&2 'You need to build test-chmtime:' 951 echo >&2 'Run "make t/helper/test-chmtime" in the source (toplevel) directory' 952 exit 1 953fi 954 955# Test repository 956TRASH_DIRECTORY="trash directory.$(basename "$0" .sh)" 957test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY" 958case "$TRASH_DIRECTORY" in 959/*) ;; # absolute path is good 960 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;; 961esac 962rm -fr "$TRASH_DIRECTORY" || { 963 GIT_EXIT_OK=t 964 echo >&5 "FATAL: Cannot prepare test area" 965 exit 1 966} 967 968HOME="$TRASH_DIRECTORY" 969GNUPGHOME="$HOME/gnupg-home-not-used" 970export HOME GNUPGHOME 971 972if test -z "$TEST_NO_CREATE_REPO" 973then 974 test_create_repo "$TRASH_DIRECTORY" 975else 976 mkdir -p "$TRASH_DIRECTORY" 977fi 978# Use -P to resolve symlinks in our working directory so that the cwd 979# in subprocesses like git equals our $PWD (for pathname comparisons). 980cd -P "$TRASH_DIRECTORY" || exit 1 981 982this_test=${0##*/} 983this_test=${this_test%%-*} 984if match_pattern_list "$this_test" $GIT_SKIP_TESTS 985then 986 say_color info >&3 "skipping test $this_test altogether" 987 skip_all="skip all tests in $this_test" 988 test_done 989fi 990 991# Provide an implementation of the 'yes' utility 992yes () { 993 if test $# = 0 994 then 995 y=y 996 else 997 y="$*" 998 fi 9991000 i=01001 while test $i -lt 991002 do1003 echo "$y"1004 i=$(($i+1))1005 done1006}10071008# Fix some commands on Windows1009uname_s=$(uname -s)1010case $uname_s in1011*MINGW*)1012 # Windows has its own (incompatible) sort and find1013 sort () {1014 /usr/bin/sort "$@"1015 }1016 find () {1017 /usr/bin/find "$@"1018 }1019 # git sees Windows-style pwd1020 pwd () {1021 builtin pwd -W1022 }1023 # no POSIX permissions1024 # backslashes in pathspec are converted to '/'1025 # exec does not inherit the PID1026 test_set_prereq MINGW1027 test_set_prereq NATIVE_CRLF1028 test_set_prereq SED_STRIPS_CR1029 test_set_prereq GREP_STRIPS_CR1030 GIT_TEST_CMP=mingw_test_cmp1031 ;;1032*CYGWIN*)1033 test_set_prereq POSIXPERM1034 test_set_prereq EXECKEEPSPID1035 test_set_prereq CYGWIN1036 test_set_prereq SED_STRIPS_CR1037 test_set_prereq GREP_STRIPS_CR1038 ;;1039*)1040 test_set_prereq POSIXPERM1041 test_set_prereq BSLASHPSPEC1042 test_set_prereq EXECKEEPSPID1043 ;;1044esac10451046( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_11047test -z "$NO_PERL" && test_set_prereq PERL1048test -z "$NO_PTHREADS" && test_set_prereq PTHREADS1049test -z "$NO_PYTHON" && test_set_prereq PYTHON1050test -n "$USE_LIBPCRE1$USE_LIBPCRE2" && test_set_prereq PCRE1051test -z "$NO_GETTEXT" && test_set_prereq GETTEXT10521053# Can we rely on git's output in the C locale?1054if test -n "$GETTEXT_POISON"1055then1056 GIT_GETTEXT_POISON=YesPlease1057 export GIT_GETTEXT_POISON1058 test_set_prereq GETTEXT_POISON1059else1060 test_set_prereq C_LOCALE_OUTPUT1061fi10621063# Use this instead of test_cmp to compare files that contain expected and1064# actual output from git commands that can be translated. When running1065# under GETTEXT_POISON this pretends that the command produced expected1066# results.1067test_i18ncmp () {1068 test -n "$GETTEXT_POISON" || test_cmp "$@"1069}10701071# Use this instead of "grep expected-string actual" to see if the1072# output from a git command that can be translated either contains an1073# expected string, or does not contain an unwanted one. When running1074# under GETTEXT_POISON this pretends that the command produced expected1075# results.1076test_i18ngrep () {1077 if test -n "$GETTEXT_POISON"1078 then1079 : # pretend success1080 elif test "x!" = "x$1"1081 then1082 shift1083 ! grep "$@"1084 else1085 grep "$@"1086 fi1087}10881089test_lazy_prereq PIPE '1090 # test whether the filesystem supports FIFOs1091 test_have_prereq !MINGW,!CYGWIN &&1092 rm -f testfifo && mkfifo testfifo1093'10941095test_lazy_prereq SYMLINKS '1096 # test whether the filesystem supports symbolic links1097 ln -s x y && test -h y1098'10991100test_lazy_prereq FILEMODE '1101 test "$(git config --bool core.filemode)" = true1102'11031104test_lazy_prereq CASE_INSENSITIVE_FS '1105 echo good >CamelCase &&1106 echo bad >camelcase &&1107 test "$(cat CamelCase)" != good1108'11091110test_lazy_prereq UTF8_NFD_TO_NFC '1111 # check whether FS converts nfd unicode to nfc1112 auml=$(printf "\303\244")1113 aumlcdiar=$(printf "\141\314\210")1114 >"$auml" &&1115 case "$(echo *)" in1116 "$aumlcdiar")1117 true ;;1118 *)1119 false ;;1120 esac1121'11221123test_lazy_prereq AUTOIDENT '1124 sane_unset GIT_AUTHOR_NAME &&1125 sane_unset GIT_AUTHOR_EMAIL &&1126 git var GIT_AUTHOR_IDENT1127'11281129test_lazy_prereq EXPENSIVE '1130 test -n "$GIT_TEST_LONG"1131'11321133test_lazy_prereq USR_BIN_TIME '1134 test -x /usr/bin/time1135'11361137test_lazy_prereq NOT_ROOT '1138 uid=$(id -u) &&1139 test "$uid" != 01140'11411142test_lazy_prereq JGIT '1143 type jgit1144'11451146# SANITY is about "can you correctly predict what the filesystem would1147# do by only looking at the permission bits of the files and1148# directories?" A typical example of !SANITY is running the test1149# suite as root, where a test may expect "chmod -r file && cat file"1150# to fail because file is supposed to be unreadable after a successful1151# chmod. In an environment (i.e. combination of what filesystem is1152# being used and who is running the tests) that lacks SANITY, you may1153# be able to delete or create a file when the containing directory1154# doesn't have write permissions, or access a file even if the1155# containing directory doesn't have read or execute permissions.11561157test_lazy_prereq SANITY '1158 mkdir SANETESTD.1 SANETESTD.2 &&11591160 chmod +w SANETESTD.1 SANETESTD.2 &&1161 >SANETESTD.1/x 2>SANETESTD.2/x &&1162 chmod -w SANETESTD.1 &&1163 chmod -r SANETESTD.1/x &&1164 chmod -rx SANETESTD.2 ||1165 error "bug in test sript: cannot prepare SANETESTD"11661167 ! test -r SANETESTD.1/x &&1168 ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x1169 status=$?11701171 chmod +rwx SANETESTD.1 SANETESTD.2 &&1172 rm -rf SANETESTD.1 SANETESTD.2 ||1173 error "bug in test sript: cannot clean SANETESTD"1174 return $status1175'11761177test FreeBSD != $uname_s || GIT_UNZIP=${GIT_UNZIP:-/usr/local/bin/unzip}1178GIT_UNZIP=${GIT_UNZIP:-unzip}1179test_lazy_prereq UNZIP '1180 "$GIT_UNZIP" -v1181 test $? -ne 1271182'11831184run_with_limited_cmdline () {1185 (ulimit -s 128 && "$@")1186}11871188test_lazy_prereq CMDLINE_LIMIT '1189 test_have_prereq !MINGW,!CYGWIN &&1190 run_with_limited_cmdline true1191'11921193run_with_limited_stack () {1194 (ulimit -s 128 && "$@")1195}11961197test_lazy_prereq ULIMIT_STACK_SIZE '1198 test_have_prereq !MINGW,!CYGWIN &&1199 run_with_limited_stack true1200'12011202build_option () {1203 git version --build-options |1204 sed -ne "s/^$1: //p"1205}12061207test_lazy_prereq LONG_IS_64BIT '1208 test 8 -le "$(build_option sizeof-long)"1209'12101211test_lazy_prereq TIME_IS_64BIT 'test-date is64bit'1212test_lazy_prereq TIME_T_IS_64BIT 'test-date time_t-is64bit'