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