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 ${TEST_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_CACHE_HOME 120unset XDG_CONFIG_HOME 121unset GITPERLLIB 122GIT_AUTHOR_EMAIL=author@example.com 123GIT_AUTHOR_NAME='A U Thor' 124GIT_COMMITTER_EMAIL=committer@example.com 125GIT_COMMITTER_NAME='C O Mitter' 126GIT_MERGE_VERBOSITY=5 127GIT_MERGE_AUTOEDIT=no 128export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT 129export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME 130export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME 131export EDITOR 132 133# Tests using GIT_TRACE typically don't want <timestamp> <file>:<line> output 134GIT_TRACE_BARE=1 135export GIT_TRACE_BARE 136 137if test -n "${TEST_GIT_INDEX_VERSION:+isset}" 138then 139 GIT_INDEX_VERSION="$TEST_GIT_INDEX_VERSION" 140 export GIT_INDEX_VERSION 141fi 142 143# Add libc MALLOC and MALLOC_PERTURB test 144# only if we are not executing the test with valgrind 145if expr " $GIT_TEST_OPTS " : ".* --valgrind " >/dev/null || 146 test -n "$TEST_NO_MALLOC_CHECK" 147then 148 setup_malloc_check () { 149 : nothing 150 } 151 teardown_malloc_check () { 152 : nothing 153 } 154else 155 setup_malloc_check () { 156 MALLOC_CHECK_=3 MALLOC_PERTURB_=165 157 export MALLOC_CHECK_ MALLOC_PERTURB_ 158 } 159 teardown_malloc_check () { 160 unset MALLOC_CHECK_ MALLOC_PERTURB_ 161 } 162fi 163 164# Protect ourselves from common misconfiguration to export 165# CDPATH into the environment 166unset CDPATH 167 168unset GREP_OPTIONS 169unset UNZIP 170 171case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in 1721|2|true) 173 GIT_TRACE=4 174 ;; 175esac 176 177# Convenience 178# 179# A regexp to match 5, 35 and 40 hexdigits 180_x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]' 181_x35="$_x05$_x05$_x05$_x05$_x05$_x05$_x05" 182_x40="$_x35$_x05" 183 184# Zero SHA-1 185_z40=0000000000000000000000000000000000000000 186 187OID_REGEX="$_x40" 188ZERO_OID=$_z40 189EMPTY_TREE=4b825dc642cb6eb9a060e54bf8d69288fbee4904 190EMPTY_BLOB=e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 191 192# Line feed 193LF=' 194' 195 196# UTF-8 ZERO WIDTH NON-JOINER, which HFS+ ignores 197# when case-folding filenames 198u200c=$(printf '\342\200\214') 199 200export _x05 _x35 _x40 _z40 LF u200c EMPTY_TREE EMPTY_BLOB ZERO_OID OID_REGEX 201 202# Each test should start with something like this, after copyright notices: 203# 204# test_description='Description of this test... 205# This test checks if command xyzzy does the right thing... 206# ' 207# . ./test-lib.sh 208test "x$TERM" != "xdumb" && ( 209 test -t 1 && 210 tput bold >/dev/null 2>&1 && 211 tput setaf 1 >/dev/null 2>&1 && 212 tput sgr0 >/dev/null 2>&1 213 ) && 214 color=t 215 216while test "$#" -ne 0 217do 218 case "$1" in 219 -d|--d|--de|--deb|--debu|--debug) 220 debug=t; shift ;; 221 -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate) 222 immediate=t; shift ;; 223 -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests) 224 GIT_TEST_LONG=t; export GIT_TEST_LONG; shift ;; 225 -r) 226 shift; test "$#" -ne 0 || { 227 echo 'error: -r requires an argument' >&2; 228 exit 1; 229 } 230 run_list=$1; shift ;; 231 --run=*) 232 run_list=${1#--*=}; shift ;; 233 -h|--h|--he|--hel|--help) 234 help=t; shift ;; 235 -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose) 236 verbose=t; shift ;; 237 --verbose-only=*) 238 verbose_only=${1#--*=} 239 shift ;; 240 -q|--q|--qu|--qui|--quie|--quiet) 241 # Ignore --quiet under a TAP::Harness. Saying how many tests 242 # passed without the ok/not ok details is always an error. 243 test -z "$HARNESS_ACTIVE" && quiet=t; shift ;; 244 --with-dashes) 245 with_dashes=t; shift ;; 246 --no-color) 247 color=; shift ;; 248 --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind) 249 valgrind=memcheck 250 shift ;; 251 --valgrind=*) 252 valgrind=${1#--*=} 253 shift ;; 254 --valgrind-only=*) 255 valgrind_only=${1#--*=} 256 shift ;; 257 --tee) 258 shift ;; # was handled already 259 --root=*) 260 root=${1#--*=} 261 shift ;; 262 --chain-lint) 263 GIT_TEST_CHAIN_LINT=1 264 shift ;; 265 --no-chain-lint) 266 GIT_TEST_CHAIN_LINT=0 267 shift ;; 268 -x) 269 # Some test scripts can't be reliably traced with '-x', 270 # unless the test is run with a Bash version supporting 271 # BASH_XTRACEFD (introduced in Bash v4.1). Check whether 272 # this test is marked as such, and ignore '-x' if it 273 # isn't executed with a suitable Bash version. 274 if test -z "$test_untraceable" || { 275 test -n "$BASH_VERSION" && { 276 test ${BASH_VERSINFO[0]} -gt 4 || { 277 test ${BASH_VERSINFO[0]} -eq 4 && 278 test ${BASH_VERSINFO[1]} -ge 1 279 } 280 } 281 } 282 then 283 trace=t 284 else 285 echo >&2 "warning: ignoring -x; '$0' is untraceable without BASH_XTRACEFD" 286 fi 287 shift ;; 288 --verbose-log) 289 verbose_log=t 290 shift ;; 291 *) 292 echo "error: unknown test option '$1'" >&2; exit 1 ;; 293 esac 294done 295 296if test -n "$valgrind_only" 297then 298 test -z "$valgrind" && valgrind=memcheck 299 test -z "$verbose" && verbose_only="$valgrind_only" 300elif test -n "$valgrind" 301then 302 test -z "$verbose_log" && verbose=t 303fi 304 305if test -n "$trace" && test -z "$verbose_log" 306then 307 verbose=t 308fi 309 310if test -n "$color" 311then 312 # Save the color control sequences now rather than run tput 313 # each time say_color() is called. This is done for two 314 # reasons: 315 # * TERM will be changed to dumb 316 # * HOME will be changed to a temporary directory and tput 317 # might need to read ~/.terminfo from the original HOME 318 # directory to get the control sequences 319 # Note: This approach assumes the control sequences don't end 320 # in a newline for any terminal of interest (command 321 # substitutions strip trailing newlines). Given that most 322 # (all?) terminals in common use are related to ECMA-48, this 323 # shouldn't be a problem. 324 say_color_error=$(tput bold; tput setaf 1) # bold red 325 say_color_skip=$(tput setaf 4) # blue 326 say_color_warn=$(tput setaf 3) # brown/yellow 327 say_color_pass=$(tput setaf 2) # green 328 say_color_info=$(tput setaf 6) # cyan 329 say_color_reset=$(tput sgr0) 330 say_color_="" # no formatting for normal text 331 say_color () { 332 test -z "$1" && test -n "$quiet" && return 333 eval "say_color_color=\$say_color_$1" 334 shift 335 printf "%s\\n" "$say_color_color$*$say_color_reset" 336 } 337else 338 say_color() { 339 test -z "$1" && test -n "$quiet" && return 340 shift 341 printf "%s\n" "$*" 342 } 343fi 344 345TERM=dumb 346export TERM 347 348error () { 349 say_color error "error: $*" 350 GIT_EXIT_OK=t 351 exit 1 352} 353 354say () { 355 say_color info "$*" 356} 357 358if test -n "$HARNESS_ACTIVE" 359then 360 if test "$verbose" = t || test -n "$verbose_only" 361 then 362 printf 'Bail out! %s\n' \ 363 'verbose mode forbidden under TAP harness; try --verbose-log' 364 exit 1 365 fi 366fi 367 368test "${test_description}" != "" || 369error "Test script did not set test_description." 370 371if test "$help" = "t" 372then 373 printf '%s\n' "$test_description" 374 exit 0 375fi 376 377exec 5>&1 378exec 6<&0 379exec 7>&2 380if test "$verbose_log" = "t" 381then 382 exec 3>>"$GIT_TEST_TEE_OUTPUT_FILE" 4>&3 383elif test "$verbose" = "t" 384then 385 exec 4>&2 3>&1 386else 387 exec 4>/dev/null 3>/dev/null 388fi 389 390# Send any "-x" output directly to stderr to avoid polluting tests 391# which capture stderr. We can do this unconditionally since it 392# has no effect if tracing isn't turned on. 393# 394# Note that this sets up the trace fd as soon as we assign the variable, so it 395# must come after the creation of descriptor 4 above. Likewise, we must never 396# unset this, as it has the side effect of closing descriptor 4, which we 397# use to show verbose tests to the user. 398# 399# Note also that we don't need or want to export it. The tracing is local to 400# this shell, and we would not want to influence any shells we exec. 401BASH_XTRACEFD=4 402 403test_failure=0 404test_count=0 405test_fixed=0 406test_broken=0 407test_success=0 408 409test_external_has_tap=0 410 411die () { 412 code=$? 413 if test -n "$GIT_EXIT_OK" 414 then 415 exit $code 416 else 417 echo >&5 "FATAL: Unexpected exit with code $code" 418 exit 1 419 fi 420} 421 422GIT_EXIT_OK= 423trap 'die' EXIT 424trap 'exit $?' INT 425 426# The user-facing functions are loaded from a separate file so that 427# test_perf subshells can have them too 428. "$TEST_DIRECTORY/test-lib-functions.sh" 429 430# You are not expected to call test_ok_ and test_failure_ directly, use 431# the test_expect_* functions instead. 432 433test_ok_ () { 434 test_success=$(($test_success + 1)) 435 say_color "" "ok $test_count - $@" 436} 437 438test_failure_ () { 439 test_failure=$(($test_failure + 1)) 440 say_color error "not ok $test_count - $1" 441 shift 442 printf '%s\n' "$*" | sed -e 's/^/# /' 443 test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; } 444} 445 446test_known_broken_ok_ () { 447 test_fixed=$(($test_fixed+1)) 448 say_color error "ok $test_count - $@ # TODO known breakage vanished" 449} 450 451test_known_broken_failure_ () { 452 test_broken=$(($test_broken+1)) 453 say_color warn "not ok $test_count - $@ # TODO known breakage" 454} 455 456test_debug () { 457 test "$debug" = "" || eval "$1" 458} 459 460match_pattern_list () { 461 arg="$1" 462 shift 463 test -z "$*" && return 1 464 for pattern_ 465 do 466 case "$arg" in 467 $pattern_) 468 return 0 469 esac 470 done 471 return 1 472} 473 474match_test_selector_list () { 475 title="$1" 476 shift 477 arg="$1" 478 shift 479 test -z "$1" && return 0 480 481 # Both commas and whitespace are accepted as separators. 482 OLDIFS=$IFS 483 IFS=' ,' 484 set -- $1 485 IFS=$OLDIFS 486 487 # If the first selector is negative we include by default. 488 include= 489 case "$1" in 490 !*) include=t ;; 491 esac 492 493 for selector 494 do 495 orig_selector=$selector 496 497 positive=t 498 case "$selector" in 499 !*) 500 positive= 501 selector=${selector##?} 502 ;; 503 esac 504 505 test -z "$selector" && continue 506 507 case "$selector" in 508 *-*) 509 if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null 510 then 511 echo "error: $title: invalid non-numeric in range" \ 512 "start: '$orig_selector'" >&2 513 exit 1 514 fi 515 if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null 516 then 517 echo "error: $title: invalid non-numeric in range" \ 518 "end: '$orig_selector'" >&2 519 exit 1 520 fi 521 ;; 522 *) 523 if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null 524 then 525 echo "error: $title: invalid non-numeric in test" \ 526 "selector: '$orig_selector'" >&2 527 exit 1 528 fi 529 esac 530 531 # Short cut for "obvious" cases 532 test -z "$include" && test -z "$positive" && continue 533 test -n "$include" && test -n "$positive" && continue 534 535 case "$selector" in 536 -*) 537 if test $arg -le ${selector#-} 538 then 539 include=$positive 540 fi 541 ;; 542 *-) 543 if test $arg -ge ${selector%-} 544 then 545 include=$positive 546 fi 547 ;; 548 *-*) 549 if test ${selector%%-*} -le $arg \ 550 && test $arg -le ${selector#*-} 551 then 552 include=$positive 553 fi 554 ;; 555 *) 556 if test $arg -eq $selector 557 then 558 include=$positive 559 fi 560 ;; 561 esac 562 done 563 564 test -n "$include" 565} 566 567maybe_teardown_verbose () { 568 test -z "$verbose_only" && return 569 exec 4>/dev/null 3>/dev/null 570 verbose= 571} 572 573last_verbose=t 574maybe_setup_verbose () { 575 test -z "$verbose_only" && return 576 if match_pattern_list $test_count $verbose_only 577 then 578 exec 4>&2 3>&1 579 # Emit a delimiting blank line when going from 580 # non-verbose to verbose. Within verbose mode the 581 # delimiter is printed by test_expect_*. The choice 582 # of the initial $last_verbose is such that before 583 # test 1, we do not print it. 584 test -z "$last_verbose" && echo >&3 "" 585 verbose=t 586 else 587 exec 4>/dev/null 3>/dev/null 588 verbose= 589 fi 590 last_verbose=$verbose 591} 592 593maybe_teardown_valgrind () { 594 test -z "$GIT_VALGRIND" && return 595 GIT_VALGRIND_ENABLED= 596} 597 598maybe_setup_valgrind () { 599 test -z "$GIT_VALGRIND" && return 600 if test -z "$valgrind_only" 601 then 602 GIT_VALGRIND_ENABLED=t 603 return 604 fi 605 GIT_VALGRIND_ENABLED= 606 if match_pattern_list $test_count $valgrind_only 607 then 608 GIT_VALGRIND_ENABLED=t 609 fi 610} 611 612want_trace () { 613 test "$trace" = t && { 614 test "$verbose" = t || test "$verbose_log" = t 615 } 616} 617 618# This is a separate function because some tests use 619# "return" to end a test_expect_success block early 620# (and we want to make sure we run any cleanup like 621# "set +x"). 622test_eval_inner_ () { 623 # Do not add anything extra (including LF) after '$*' 624 eval " 625 want_trace && set -x 626 $*" 627} 628 629test_eval_ () { 630 # If "-x" tracing is in effect, then we want to avoid polluting stderr 631 # with non-test commands. But once in "set -x" mode, we cannot prevent 632 # the shell from printing the "set +x" to turn it off (nor the saving 633 # of $? before that). But we can make sure that the output goes to 634 # /dev/null. 635 # 636 # There are a few subtleties here: 637 # 638 # - we have to redirect descriptor 4 in addition to 2, to cover 639 # BASH_XTRACEFD 640 # 641 # - the actual eval has to come before the redirection block (since 642 # it needs to see descriptor 4 to set up its stderr) 643 # 644 # - likewise, any error message we print must be outside the block to 645 # access descriptor 4 646 # 647 # - checking $? has to come immediately after the eval, but it must 648 # be _inside_ the block to avoid polluting the "set -x" output 649 # 650 651 test_eval_inner_ "$@" </dev/null >&3 2>&4 652 { 653 test_eval_ret_=$? 654 if want_trace 655 then 656 set +x 657 fi 658 } 2>/dev/null 4>&2 659 660 if test "$test_eval_ret_" != 0 && want_trace 661 then 662 say_color error >&4 "error: last command exited with \$?=$test_eval_ret_" 663 fi 664 return $test_eval_ret_ 665} 666 667test_run_ () { 668 test_cleanup=: 669 expecting_failure=$2 670 671 if test "${GIT_TEST_CHAIN_LINT:-1}" != 0; then 672 # turn off tracing for this test-eval, as it simply creates 673 # confusing noise in the "-x" output 674 trace_tmp=$trace 675 trace= 676 # 117 is magic because it is unlikely to match the exit 677 # code of other programs 678 if test "OK-117" != "$(test_eval_ "(exit 117) && $1${LF}${LF}echo OK-\$?" 3>&1)" 679 then 680 error "bug in the test script: broken &&-chain or run-away HERE-DOC: $1" 681 fi 682 trace=$trace_tmp 683 fi 684 685 setup_malloc_check 686 test_eval_ "$1" 687 eval_ret=$? 688 teardown_malloc_check 689 690 if test -z "$immediate" || test $eval_ret = 0 || 691 test -n "$expecting_failure" && test "$test_cleanup" != ":" 692 then 693 setup_malloc_check 694 test_eval_ "$test_cleanup" 695 teardown_malloc_check 696 fi 697 if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE" 698 then 699 echo "" 700 fi 701 return "$eval_ret" 702} 703 704test_start_ () { 705 test_count=$(($test_count+1)) 706 maybe_setup_verbose 707 maybe_setup_valgrind 708} 709 710test_finish_ () { 711 echo >&3 "" 712 maybe_teardown_valgrind 713 maybe_teardown_verbose 714} 715 716test_skip () { 717 to_skip= 718 skipped_reason= 719 if match_pattern_list $this_test.$test_count $GIT_SKIP_TESTS 720 then 721 to_skip=t 722 skipped_reason="GIT_SKIP_TESTS" 723 fi 724 if test -z "$to_skip" && test -n "$test_prereq" && 725 ! test_have_prereq "$test_prereq" 726 then 727 to_skip=t 728 729 of_prereq= 730 if test "$missing_prereq" != "$test_prereq" 731 then 732 of_prereq=" of $test_prereq" 733 fi 734 skipped_reason="missing $missing_prereq${of_prereq}" 735 fi 736 if test -z "$to_skip" && test -n "$run_list" && 737 ! match_test_selector_list '--run' $test_count "$run_list" 738 then 739 to_skip=t 740 skipped_reason="--run" 741 fi 742 743 case "$to_skip" in 744 t) 745 say_color skip >&3 "skipping test: $@" 746 say_color skip "ok $test_count # skip $1 ($skipped_reason)" 747 : true 748 ;; 749 *) 750 false 751 ;; 752 esac 753} 754 755# stub; perf-lib overrides it 756test_at_end_hook_ () { 757 : 758} 759 760test_done () { 761 GIT_EXIT_OK=t 762 763 if test -z "$HARNESS_ACTIVE" 764 then 765 test_results_dir="$TEST_OUTPUT_DIRECTORY/test-results" 766 mkdir -p "$test_results_dir" 767 base=${0##*/} 768 test_results_path="$test_results_dir/${base%.sh}.counts" 769 770 cat >"$test_results_path" <<-EOF 771 total $test_count 772 success $test_success 773 fixed $test_fixed 774 broken $test_broken 775 failed $test_failure 776 777 EOF 778 fi 779 780 if test "$test_fixed" != 0 781 then 782 say_color error "# $test_fixed known breakage(s) vanished; please update test(s)" 783 fi 784 if test "$test_broken" != 0 785 then 786 say_color warn "# still have $test_broken known breakage(s)" 787 fi 788 if test "$test_broken" != 0 || test "$test_fixed" != 0 789 then 790 test_remaining=$(( $test_count - $test_broken - $test_fixed )) 791 msg="remaining $test_remaining test(s)" 792 else 793 test_remaining=$test_count 794 msg="$test_count test(s)" 795 fi 796 case "$test_failure" in 797 0) 798 if test $test_external_has_tap -eq 0 799 then 800 if test $test_remaining -gt 0 801 then 802 say_color pass "# passed all $msg" 803 fi 804 805 # Maybe print SKIP message 806 test -z "$skip_all" || skip_all="# SKIP $skip_all" 807 case "$test_count" in 808 0) 809 say "1..$test_count${skip_all:+ $skip_all}" 810 ;; 811 *) 812 test -z "$skip_all" || 813 say_color warn "$skip_all" 814 say "1..$test_count" 815 ;; 816 esac 817 fi 818 819 if test -z "$debug" 820 then 821 test -d "$TRASH_DIRECTORY" || 822 error "Tests passed but trash directory already removed before test cleanup; aborting" 823 824 cd "$TRASH_DIRECTORY/.." && 825 rm -fr "$TRASH_DIRECTORY" || 826 error "Tests passed but test cleanup failed; aborting" 827 fi 828 test_at_end_hook_ 829 830 exit 0 ;; 831 832 *) 833 if test $test_external_has_tap -eq 0 834 then 835 say_color error "# failed $test_failure among $msg" 836 say "1..$test_count" 837 fi 838 839 exit 1 ;; 840 841 esac 842} 843 844if test -n "$valgrind" 845then 846 make_symlink () { 847 test -h "$2" && 848 test "$1" = "$(readlink "$2")" || { 849 # be super paranoid 850 if mkdir "$2".lock 851 then 852 rm -f "$2" && 853 ln -s "$1" "$2" && 854 rm -r "$2".lock 855 else 856 while test -d "$2".lock 857 do 858 say "Waiting for lock on $2." 859 sleep 1 860 done 861 fi 862 } 863 } 864 865 make_valgrind_symlink () { 866 # handle only executables, unless they are shell libraries that 867 # need to be in the exec-path. 868 test -x "$1" || 869 test "# " = "$(head -c 2 <"$1")" || 870 return; 871 872 base=$(basename "$1") 873 case "$base" in 874 test-*) 875 symlink_target="$GIT_BUILD_DIR/t/helper/$base" 876 ;; 877 *) 878 symlink_target="$GIT_BUILD_DIR/$base" 879 ;; 880 esac 881 # do not override scripts 882 if test -x "$symlink_target" && 883 test ! -d "$symlink_target" && 884 test "#!" != "$(head -c 2 < "$symlink_target")" 885 then 886 symlink_target=../valgrind.sh 887 fi 888 case "$base" in 889 *.sh|*.perl) 890 symlink_target=../unprocessed-script 891 esac 892 # create the link, or replace it if it is out of date 893 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit 894 } 895 896 # override all git executables in TEST_DIRECTORY/.. 897 GIT_VALGRIND=$TEST_DIRECTORY/valgrind 898 mkdir -p "$GIT_VALGRIND"/bin 899 for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/t/helper/test-* 900 do 901 make_valgrind_symlink $file 902 done 903 # special-case the mergetools loadables 904 make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools" 905 OLDIFS=$IFS 906 IFS=: 907 for path in $PATH 908 do 909 ls "$path"/git-* 2> /dev/null | 910 while read file 911 do 912 make_valgrind_symlink "$file" 913 done 914 done 915 IFS=$OLDIFS 916 PATH=$GIT_VALGRIND/bin:$PATH 917 GIT_EXEC_PATH=$GIT_VALGRIND/bin 918 export GIT_VALGRIND 919 GIT_VALGRIND_MODE="$valgrind" 920 export GIT_VALGRIND_MODE 921 GIT_VALGRIND_ENABLED=t 922 test -n "$valgrind_only" && GIT_VALGRIND_ENABLED= 923 export GIT_VALGRIND_ENABLED 924elif test -n "$GIT_TEST_INSTALLED" 925then 926 GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path) || 927 error "Cannot run git from $GIT_TEST_INSTALLED." 928 PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR:$PATH 929 GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH} 930else # normal case, use ../bin-wrappers only unless $with_dashes: 931 git_bin_dir="$GIT_BUILD_DIR/bin-wrappers" 932 if ! test -x "$git_bin_dir/git" 933 then 934 if test -z "$with_dashes" 935 then 936 say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH" 937 fi 938 with_dashes=t 939 fi 940 PATH="$git_bin_dir:$PATH" 941 GIT_EXEC_PATH=$GIT_BUILD_DIR 942 if test -n "$with_dashes" 943 then 944 PATH="$GIT_BUILD_DIR:$PATH" 945 fi 946fi 947GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt 948GIT_CONFIG_NOSYSTEM=1 949GIT_ATTR_NOSYSTEM=1 950export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM 951 952if test -z "$GIT_TEST_CMP" 953then 954 if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT" 955 then 956 GIT_TEST_CMP="$DIFF -c" 957 else 958 GIT_TEST_CMP="$DIFF -u" 959 fi 960fi 961 962GITPERLLIB="$GIT_BUILD_DIR"/perl/build/lib 963export GITPERLLIB 964test -d "$GIT_BUILD_DIR"/templates/blt || { 965 error "You haven't built things yet, have you?" 966} 967 968if ! test -x "$GIT_BUILD_DIR"/t/helper/test-tool 969then 970 echo >&2 'You need to build test-tool:' 971 echo >&2 'Run "make t/helper/test-tool" in the source (toplevel) directory' 972 exit 1 973fi 974 975# Test repository 976TRASH_DIRECTORY="trash directory.$(basename "$0" .sh)" 977test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY" 978case "$TRASH_DIRECTORY" in 979/*) ;; # absolute path is good 980 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;; 981esac 982rm -fr "$TRASH_DIRECTORY" || { 983 GIT_EXIT_OK=t 984 echo >&5 "FATAL: Cannot prepare test area" 985 exit 1 986} 987 988HOME="$TRASH_DIRECTORY" 989GNUPGHOME="$HOME/gnupg-home-not-used" 990export HOME GNUPGHOME 991 992if test -z "$TEST_NO_CREATE_REPO" 993then 994 test_create_repo "$TRASH_DIRECTORY" 995else 996 mkdir -p "$TRASH_DIRECTORY" 997fi 998# Use -P to resolve symlinks in our working directory so that the cwd 999# in subprocesses like git equals our $PWD (for pathname comparisons).1000cd -P "$TRASH_DIRECTORY" || exit 110011002this_test=${0##*/}1003this_test=${this_test%%-*}1004if match_pattern_list "$this_test" $GIT_SKIP_TESTS1005then1006 say_color info >&3 "skipping test $this_test altogether"1007 skip_all="skip all tests in $this_test"1008 test_done1009fi10101011# Provide an implementation of the 'yes' utility1012yes () {1013 if test $# = 01014 then1015 y=y1016 else1017 y="$*"1018 fi10191020 i=01021 while test $i -lt 991022 do1023 echo "$y"1024 i=$(($i+1))1025 done1026}10271028# Fix some commands on Windows1029uname_s=$(uname -s)1030case $uname_s in1031*MINGW*)1032 # Windows has its own (incompatible) sort and find1033 sort () {1034 /usr/bin/sort "$@"1035 }1036 find () {1037 /usr/bin/find "$@"1038 }1039 # git sees Windows-style pwd1040 pwd () {1041 builtin pwd -W1042 }1043 # no POSIX permissions1044 # backslashes in pathspec are converted to '/'1045 # exec does not inherit the PID1046 test_set_prereq MINGW1047 test_set_prereq NATIVE_CRLF1048 test_set_prereq SED_STRIPS_CR1049 test_set_prereq GREP_STRIPS_CR1050 GIT_TEST_CMP=mingw_test_cmp1051 ;;1052*CYGWIN*)1053 test_set_prereq POSIXPERM1054 test_set_prereq EXECKEEPSPID1055 test_set_prereq CYGWIN1056 test_set_prereq SED_STRIPS_CR1057 test_set_prereq GREP_STRIPS_CR1058 ;;1059*)1060 test_set_prereq POSIXPERM1061 test_set_prereq BSLASHPSPEC1062 test_set_prereq EXECKEEPSPID1063 ;;1064esac10651066( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_11067test -z "$NO_PERL" && test_set_prereq PERL1068test -z "$NO_PTHREADS" && test_set_prereq PTHREADS1069test -z "$NO_PYTHON" && test_set_prereq PYTHON1070test -n "$USE_LIBPCRE1$USE_LIBPCRE2" && test_set_prereq PCRE1071test -n "$USE_LIBPCRE1" && test_set_prereq LIBPCRE11072test -n "$USE_LIBPCRE2" && test_set_prereq LIBPCRE21073test -z "$NO_GETTEXT" && test_set_prereq GETTEXT10741075# Can we rely on git's output in the C locale?1076if test -n "$GETTEXT_POISON"1077then1078 GIT_GETTEXT_POISON=YesPlease1079 export GIT_GETTEXT_POISON1080 test_set_prereq GETTEXT_POISON1081else1082 test_set_prereq C_LOCALE_OUTPUT1083fi10841085test_lazy_prereq PIPE '1086 # test whether the filesystem supports FIFOs1087 test_have_prereq !MINGW,!CYGWIN &&1088 rm -f testfifo && mkfifo testfifo1089'10901091test_lazy_prereq SYMLINKS '1092 # test whether the filesystem supports symbolic links1093 ln -s x y && test -h y1094'10951096test_lazy_prereq FILEMODE '1097 test "$(git config --bool core.filemode)" = true1098'10991100test_lazy_prereq CASE_INSENSITIVE_FS '1101 echo good >CamelCase &&1102 echo bad >camelcase &&1103 test "$(cat CamelCase)" != good1104'11051106test_lazy_prereq UTF8_NFD_TO_NFC '1107 # check whether FS converts nfd unicode to nfc1108 auml=$(printf "\303\244")1109 aumlcdiar=$(printf "\141\314\210")1110 >"$auml" &&1111 test -f "$aumlcdiar"1112'11131114test_lazy_prereq AUTOIDENT '1115 sane_unset GIT_AUTHOR_NAME &&1116 sane_unset GIT_AUTHOR_EMAIL &&1117 git var GIT_AUTHOR_IDENT1118'11191120test_lazy_prereq EXPENSIVE '1121 test -n "$GIT_TEST_LONG"1122'11231124test_lazy_prereq EXPENSIVE_ON_WINDOWS '1125 test_have_prereq EXPENSIVE || test_have_prereq !MINGW,!CYGWIN1126'11271128test_lazy_prereq USR_BIN_TIME '1129 test -x /usr/bin/time1130'11311132test_lazy_prereq NOT_ROOT '1133 uid=$(id -u) &&1134 test "$uid" != 01135'11361137test_lazy_prereq JGIT '1138 type jgit1139'11401141# SANITY is about "can you correctly predict what the filesystem would1142# do by only looking at the permission bits of the files and1143# directories?" A typical example of !SANITY is running the test1144# suite as root, where a test may expect "chmod -r file && cat file"1145# to fail because file is supposed to be unreadable after a successful1146# chmod. In an environment (i.e. combination of what filesystem is1147# being used and who is running the tests) that lacks SANITY, you may1148# be able to delete or create a file when the containing directory1149# doesn't have write permissions, or access a file even if the1150# containing directory doesn't have read or execute permissions.11511152test_lazy_prereq SANITY '1153 mkdir SANETESTD.1 SANETESTD.2 &&11541155 chmod +w SANETESTD.1 SANETESTD.2 &&1156 >SANETESTD.1/x 2>SANETESTD.2/x &&1157 chmod -w SANETESTD.1 &&1158 chmod -r SANETESTD.1/x &&1159 chmod -rx SANETESTD.2 ||1160 error "bug in test sript: cannot prepare SANETESTD"11611162 ! test -r SANETESTD.1/x &&1163 ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x1164 status=$?11651166 chmod +rwx SANETESTD.1 SANETESTD.2 &&1167 rm -rf SANETESTD.1 SANETESTD.2 ||1168 error "bug in test sript: cannot clean SANETESTD"1169 return $status1170'11711172test FreeBSD != $uname_s || GIT_UNZIP=${GIT_UNZIP:-/usr/local/bin/unzip}1173GIT_UNZIP=${GIT_UNZIP:-unzip}1174test_lazy_prereq UNZIP '1175 "$GIT_UNZIP" -v1176 test $? -ne 1271177'11781179run_with_limited_cmdline () {1180 (ulimit -s 128 && "$@")1181}11821183test_lazy_prereq CMDLINE_LIMIT '1184 test_have_prereq !MINGW,!CYGWIN &&1185 run_with_limited_cmdline true1186'11871188run_with_limited_stack () {1189 (ulimit -s 128 && "$@")1190}11911192test_lazy_prereq ULIMIT_STACK_SIZE '1193 test_have_prereq !MINGW,!CYGWIN &&1194 run_with_limited_stack true1195'11961197build_option () {1198 git version --build-options |1199 sed -ne "s/^$1: //p"1200}12011202test_lazy_prereq LONG_IS_64BIT '1203 test 8 -le "$(build_option sizeof-long)"1204'12051206test_lazy_prereq TIME_IS_64BIT 'test-tool date is64bit'1207test_lazy_prereq TIME_T_IS_64BIT 'test-tool date time_t-is64bit'12081209test_lazy_prereq CURL '1210 curl --version1211'12121213# SHA1 is a test if the hash algorithm in use is SHA-1. This is both for tests1214# which will not work with other hash algorithms and tests that work but don't1215# test anything meaningful (e.g. special values which cause short collisions).1216test_lazy_prereq SHA1 '1217 test $(git hash-object /dev/null) = e69de29bb2d1d6434b8b29ae775ad8c2e48c53911218'