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