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