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=$(expr "z$1" : 'z[^=]*=\(.*\)'); 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=$(expr "z$1" : 'z[^=]*=\(.*\)') 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=$(expr "z$1" : 'z[^=]*=\(.*\)') 226 shift ;; 227 --valgrind-only=*) 228 valgrind_only=$(expr "z$1" : 'z[^=]*=\(.*\)') 229 shift ;; 230 --tee) 231 shift ;; # was handled already 232 --root=*) 233 root=$(expr "z$1" : 'z[^=]*=\(.*\)') 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 325test_failure=0 326test_count=0 327test_fixed=0 328test_broken=0 329test_success=0 330 331test_external_has_tap=0 332 333die () { 334 code=$? 335 if test -n "$GIT_EXIT_OK" 336 then 337 exit $code 338 else 339 echo >&5 "FATAL: Unexpected exit with code $code" 340 exit 1 341 fi 342} 343 344GIT_EXIT_OK= 345trap 'die' EXIT 346trap 'exit $?' INT 347 348# The user-facing functions are loaded from a separate file so that 349# test_perf subshells can have them too 350. "$TEST_DIRECTORY/test-lib-functions.sh" 351 352# You are not expected to call test_ok_ and test_failure_ directly, use 353# the test_expect_* functions instead. 354 355test_ok_ () { 356 test_success=$(($test_success + 1)) 357 say_color "" "ok $test_count - $@" 358} 359 360test_failure_ () { 361 test_failure=$(($test_failure + 1)) 362 say_color error "not ok $test_count - $1" 363 shift 364 printf '%s\n' "$*" | sed -e 's/^/# /' 365 test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; } 366} 367 368test_known_broken_ok_ () { 369 test_fixed=$(($test_fixed+1)) 370 say_color error "ok $test_count - $@ # TODO known breakage vanished" 371} 372 373test_known_broken_failure_ () { 374 test_broken=$(($test_broken+1)) 375 say_color warn "not ok $test_count - $@ # TODO known breakage" 376} 377 378test_debug () { 379 test "$debug" = "" || eval "$1" 380} 381 382match_pattern_list () { 383 arg="$1" 384 shift 385 test -z "$*" && return 1 386 for pattern_ 387 do 388 case "$arg" in 389 $pattern_) 390 return 0 391 esac 392 done 393 return 1 394} 395 396match_test_selector_list () { 397 title="$1" 398 shift 399 arg="$1" 400 shift 401 test -z "$1" && return 0 402 403 # Both commas and whitespace are accepted as separators. 404 OLDIFS=$IFS 405 IFS=' ,' 406 set -- $1 407 IFS=$OLDIFS 408 409 # If the first selector is negative we include by default. 410 include= 411 case "$1" in 412 !*) include=t ;; 413 esac 414 415 for selector 416 do 417 orig_selector=$selector 418 419 positive=t 420 case "$selector" in 421 !*) 422 positive= 423 selector=${selector##?} 424 ;; 425 esac 426 427 test -z "$selector" && continue 428 429 case "$selector" in 430 *-*) 431 if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null 432 then 433 echo "error: $title: invalid non-numeric in range" \ 434 "start: '$orig_selector'" >&2 435 exit 1 436 fi 437 if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null 438 then 439 echo "error: $title: invalid non-numeric in range" \ 440 "end: '$orig_selector'" >&2 441 exit 1 442 fi 443 ;; 444 *) 445 if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null 446 then 447 echo "error: $title: invalid non-numeric in test" \ 448 "selector: '$orig_selector'" >&2 449 exit 1 450 fi 451 esac 452 453 # Short cut for "obvious" cases 454 test -z "$include" && test -z "$positive" && continue 455 test -n "$include" && test -n "$positive" && continue 456 457 case "$selector" in 458 -*) 459 if test $arg -le ${selector#-} 460 then 461 include=$positive 462 fi 463 ;; 464 *-) 465 if test $arg -ge ${selector%-} 466 then 467 include=$positive 468 fi 469 ;; 470 *-*) 471 if test ${selector%%-*} -le $arg \ 472 && test $arg -le ${selector#*-} 473 then 474 include=$positive 475 fi 476 ;; 477 *) 478 if test $arg -eq $selector 479 then 480 include=$positive 481 fi 482 ;; 483 esac 484 done 485 486 test -n "$include" 487} 488 489maybe_teardown_verbose () { 490 test -z "$verbose_only" && return 491 exec 4>/dev/null 3>/dev/null 492 verbose= 493} 494 495last_verbose=t 496maybe_setup_verbose () { 497 test -z "$verbose_only" && return 498 if match_pattern_list $test_count $verbose_only 499 then 500 exec 4>&2 3>&1 501 # Emit a delimiting blank line when going from 502 # non-verbose to verbose. Within verbose mode the 503 # delimiter is printed by test_expect_*. The choice 504 # of the initial $last_verbose is such that before 505 # test 1, we do not print it. 506 test -z "$last_verbose" && echo >&3 "" 507 verbose=t 508 else 509 exec 4>/dev/null 3>/dev/null 510 verbose= 511 fi 512 last_verbose=$verbose 513} 514 515maybe_teardown_valgrind () { 516 test -z "$GIT_VALGRIND" && return 517 GIT_VALGRIND_ENABLED= 518} 519 520maybe_setup_valgrind () { 521 test -z "$GIT_VALGRIND" && return 522 if test -z "$valgrind_only" 523 then 524 GIT_VALGRIND_ENABLED=t 525 return 526 fi 527 GIT_VALGRIND_ENABLED= 528 if match_pattern_list $test_count $valgrind_only 529 then 530 GIT_VALGRIND_ENABLED=t 531 fi 532} 533 534# This is a separate function because some tests use 535# "return" to end a test_expect_success block early 536# (and we want to make sure we run any cleanup like 537# "set +x"). 538test_eval_inner_ () { 539 # Do not add anything extra (including LF) after '$*' 540 eval " 541 test \"$trace\" = t && set -x 542 $*" 543} 544 545test_eval_ () { 546 # We run this block with stderr redirected to avoid extra cruft 547 # during a "-x" trace. Once in "set -x" mode, we cannot prevent 548 # the shell from printing the "set +x" to turn it off (nor the saving 549 # of $? before that). But we can make sure that the output goes to 550 # /dev/null. 551 # 552 # The test itself is run with stderr put back to &4 (so either to 553 # /dev/null, or to the original stderr if --verbose was used). 554 { 555 test_eval_inner_ "$@" </dev/null >&3 2>&4 556 test_eval_ret_=$? 557 if test "$trace" = t 558 then 559 set +x 560 if test "$test_eval_ret_" != 0 561 then 562 say_color error >&4 "error: last command exited with \$?=$test_eval_ret_" 563 fi 564 fi 565 } 2>/dev/null 566 return $test_eval_ret_ 567} 568 569test_run_ () { 570 test_cleanup=: 571 expecting_failure=$2 572 573 if test "${GIT_TEST_CHAIN_LINT:-0}" != 0; then 574 # 117 is magic because it is unlikely to match the exit 575 # code of other programs 576 test_eval_ "(exit 117) && $1" 577 if test "$?" != 117; then 578 error "bug in the test script: broken &&-chain: $1" 579 fi 580 fi 581 582 setup_malloc_check 583 test_eval_ "$1" 584 eval_ret=$? 585 teardown_malloc_check 586 587 if test -z "$immediate" || test $eval_ret = 0 || 588 test -n "$expecting_failure" && test "$test_cleanup" != ":" 589 then 590 setup_malloc_check 591 test_eval_ "$test_cleanup" 592 teardown_malloc_check 593 fi 594 if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE" 595 then 596 echo "" 597 fi 598 return "$eval_ret" 599} 600 601test_start_ () { 602 test_count=$(($test_count+1)) 603 maybe_setup_verbose 604 maybe_setup_valgrind 605} 606 607test_finish_ () { 608 echo >&3 "" 609 maybe_teardown_valgrind 610 maybe_teardown_verbose 611} 612 613test_skip () { 614 to_skip= 615 skipped_reason= 616 if match_pattern_list $this_test.$test_count $GIT_SKIP_TESTS 617 then 618 to_skip=t 619 skipped_reason="GIT_SKIP_TESTS" 620 fi 621 if test -z "$to_skip" && test -n "$test_prereq" && 622 ! test_have_prereq "$test_prereq" 623 then 624 to_skip=t 625 626 of_prereq= 627 if test "$missing_prereq" != "$test_prereq" 628 then 629 of_prereq=" of $test_prereq" 630 fi 631 skipped_reason="missing $missing_prereq${of_prereq}" 632 fi 633 if test -z "$to_skip" && test -n "$run_list" && 634 ! match_test_selector_list '--run' $test_count "$run_list" 635 then 636 to_skip=t 637 skipped_reason="--run" 638 fi 639 640 case "$to_skip" in 641 t) 642 say_color skip >&3 "skipping test: $@" 643 say_color skip "ok $test_count # skip $1 ($skipped_reason)" 644 : true 645 ;; 646 *) 647 false 648 ;; 649 esac 650} 651 652# stub; perf-lib overrides it 653test_at_end_hook_ () { 654 : 655} 656 657test_done () { 658 GIT_EXIT_OK=t 659 660 if test -z "$HARNESS_ACTIVE" 661 then 662 test_results_dir="$TEST_OUTPUT_DIRECTORY/test-results" 663 mkdir -p "$test_results_dir" 664 base=${0##*/} 665 test_results_path="$test_results_dir/${base%.sh}-$$.counts" 666 667 cat >>"$test_results_path" <<-EOF 668 total $test_count 669 success $test_success 670 fixed $test_fixed 671 broken $test_broken 672 failed $test_failure 673 674 EOF 675 fi 676 677 if test "$test_fixed" != 0 678 then 679 say_color error "# $test_fixed known breakage(s) vanished; please update test(s)" 680 fi 681 if test "$test_broken" != 0 682 then 683 say_color warn "# still have $test_broken known breakage(s)" 684 fi 685 if test "$test_broken" != 0 || test "$test_fixed" != 0 686 then 687 test_remaining=$(( $test_count - $test_broken - $test_fixed )) 688 msg="remaining $test_remaining test(s)" 689 else 690 test_remaining=$test_count 691 msg="$test_count test(s)" 692 fi 693 case "$test_failure" in 694 0) 695 # Maybe print SKIP message 696 if test -n "$skip_all" && test $test_count -gt 0 697 then 698 error "Can't use skip_all after running some tests" 699 fi 700 test -z "$skip_all" || skip_all=" # SKIP $skip_all" 701 702 if test $test_external_has_tap -eq 0 703 then 704 if test $test_remaining -gt 0 705 then 706 say_color pass "# passed all $msg" 707 fi 708 say "1..$test_count$skip_all" 709 fi 710 711 test -d "$remove_trash" && 712 cd "$(dirname "$remove_trash")" && 713 rm -rf "$(basename "$remove_trash")" 714 715 test_at_end_hook_ 716 717 exit 0 ;; 718 719 *) 720 if test $test_external_has_tap -eq 0 721 then 722 say_color error "# failed $test_failure among $msg" 723 say "1..$test_count" 724 fi 725 726 exit 1 ;; 727 728 esac 729} 730 731if test -n "$valgrind" 732then 733 make_symlink () { 734 test -h "$2" && 735 test "$1" = "$(readlink "$2")" || { 736 # be super paranoid 737 if mkdir "$2".lock 738 then 739 rm -f "$2" && 740 ln -s "$1" "$2" && 741 rm -r "$2".lock 742 else 743 while test -d "$2".lock 744 do 745 say "Waiting for lock on $2." 746 sleep 1 747 done 748 fi 749 } 750 } 751 752 make_valgrind_symlink () { 753 # handle only executables, unless they are shell libraries that 754 # need to be in the exec-path. 755 test -x "$1" || 756 test "# " = "$(head -c 2 <"$1")" || 757 return; 758 759 base=$(basename "$1") 760 symlink_target=$GIT_BUILD_DIR/$base 761 # do not override scripts 762 if test -x "$symlink_target" && 763 test ! -d "$symlink_target" && 764 test "#!" != "$(head -c 2 < "$symlink_target")" 765 then 766 symlink_target=../valgrind.sh 767 fi 768 case "$base" in 769 *.sh|*.perl) 770 symlink_target=../unprocessed-script 771 esac 772 # create the link, or replace it if it is out of date 773 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit 774 } 775 776 # override all git executables in TEST_DIRECTORY/.. 777 GIT_VALGRIND=$TEST_DIRECTORY/valgrind 778 mkdir -p "$GIT_VALGRIND"/bin 779 for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/test-* 780 do 781 make_valgrind_symlink $file 782 done 783 # special-case the mergetools loadables 784 make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools" 785 OLDIFS=$IFS 786 IFS=: 787 for path in $PATH 788 do 789 ls "$path"/git-* 2> /dev/null | 790 while read file 791 do 792 make_valgrind_symlink "$file" 793 done 794 done 795 IFS=$OLDIFS 796 PATH=$GIT_VALGRIND/bin:$PATH 797 GIT_EXEC_PATH=$GIT_VALGRIND/bin 798 export GIT_VALGRIND 799 GIT_VALGRIND_MODE="$valgrind" 800 export GIT_VALGRIND_MODE 801 GIT_VALGRIND_ENABLED=t 802 test -n "$valgrind_only" && GIT_VALGRIND_ENABLED= 803 export GIT_VALGRIND_ENABLED 804elif test -n "$GIT_TEST_INSTALLED" 805then 806 GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path) || 807 error "Cannot run git from $GIT_TEST_INSTALLED." 808 PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR:$PATH 809 GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH} 810else # normal case, use ../bin-wrappers only unless $with_dashes: 811 git_bin_dir="$GIT_BUILD_DIR/bin-wrappers" 812 if ! test -x "$git_bin_dir/git" 813 then 814 if test -z "$with_dashes" 815 then 816 say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH" 817 fi 818 with_dashes=t 819 fi 820 PATH="$git_bin_dir:$PATH" 821 GIT_EXEC_PATH=$GIT_BUILD_DIR 822 if test -n "$with_dashes" 823 then 824 PATH="$GIT_BUILD_DIR:$PATH" 825 fi 826fi 827GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt 828GIT_CONFIG_NOSYSTEM=1 829GIT_ATTR_NOSYSTEM=1 830export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM 831 832if test -z "$GIT_TEST_CMP" 833then 834 if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT" 835 then 836 GIT_TEST_CMP="$DIFF -c" 837 else 838 GIT_TEST_CMP="$DIFF -u" 839 fi 840fi 841 842GITPERLLIB="$GIT_BUILD_DIR"/perl/blib/lib:"$GIT_BUILD_DIR"/perl/blib/arch/auto/Git 843export GITPERLLIB 844test -d "$GIT_BUILD_DIR"/templates/blt || { 845 error "You haven't built things yet, have you?" 846} 847 848if ! test -x "$GIT_BUILD_DIR"/test-chmtime 849then 850 echo >&2 'You need to build test-chmtime:' 851 echo >&2 'Run "make test-chmtime" in the source (toplevel) directory' 852 exit 1 853fi 854 855# Test repository 856TRASH_DIRECTORY="trash directory.$(basename "$0" .sh)" 857test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY" 858case "$TRASH_DIRECTORY" in 859/*) ;; # absolute path is good 860 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;; 861esac 862test ! -z "$debug" || remove_trash=$TRASH_DIRECTORY 863rm -fr "$TRASH_DIRECTORY" || { 864 GIT_EXIT_OK=t 865 echo >&5 "FATAL: Cannot prepare test area" 866 exit 1 867} 868 869HOME="$TRASH_DIRECTORY" 870GNUPGHOME="$HOME/gnupg-home-not-used" 871export HOME GNUPGHOME 872 873if test -z "$TEST_NO_CREATE_REPO" 874then 875 test_create_repo "$TRASH_DIRECTORY" 876else 877 mkdir -p "$TRASH_DIRECTORY" 878fi 879# Use -P to resolve symlinks in our working directory so that the cwd 880# in subprocesses like git equals our $PWD (for pathname comparisons). 881cd -P "$TRASH_DIRECTORY" || exit 1 882 883this_test=${0##*/} 884this_test=${this_test%%-*} 885if match_pattern_list "$this_test" $GIT_SKIP_TESTS 886then 887 say_color info >&3 "skipping test $this_test altogether" 888 skip_all="skip all tests in $this_test" 889 test_done 890fi 891 892# Provide an implementation of the 'yes' utility 893yes () { 894 if test $# = 0 895 then 896 y=y 897 else 898 y="$*" 899 fi 900 901 while echo "$y" 902 do 903 : 904 done 905} 906 907# Fix some commands on Windows 908case $(uname -s) in 909*MINGW*) 910 # Windows has its own (incompatible) sort and find 911 sort () { 912 /usr/bin/sort "$@" 913 } 914 find () { 915 /usr/bin/find "$@" 916 } 917 sum () { 918 md5sum "$@" 919 } 920 # git sees Windows-style pwd 921 pwd () { 922 builtin pwd -W 923 } 924 # no POSIX permissions 925 # backslashes in pathspec are converted to '/' 926 # exec does not inherit the PID 927 test_set_prereq MINGW 928 test_set_prereq NATIVE_CRLF 929 test_set_prereq SED_STRIPS_CR 930 test_set_prereq GREP_STRIPS_CR 931 GIT_TEST_CMP=mingw_test_cmp 932 ;; 933*CYGWIN*) 934 test_set_prereq POSIXPERM 935 test_set_prereq EXECKEEPSPID 936 test_set_prereq CYGWIN 937 test_set_prereq SED_STRIPS_CR 938 test_set_prereq GREP_STRIPS_CR 939 ;; 940*) 941 test_set_prereq POSIXPERM 942 test_set_prereq BSLASHPSPEC 943 test_set_prereq EXECKEEPSPID 944 ;; 945esac 946 947( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_1 948test -z "$NO_PERL" && test_set_prereq PERL 949test -z "$NO_PYTHON" && test_set_prereq PYTHON 950test -n "$USE_LIBPCRE" && test_set_prereq LIBPCRE 951test -z "$NO_GETTEXT" && test_set_prereq GETTEXT 952 953# Can we rely on git's output in the C locale? 954if test -n "$GETTEXT_POISON" 955then 956 GIT_GETTEXT_POISON=YesPlease 957 export GIT_GETTEXT_POISON 958 test_set_prereq GETTEXT_POISON 959else 960 test_set_prereq C_LOCALE_OUTPUT 961fi 962 963# Use this instead of test_cmp to compare files that contain expected and 964# actual output from git commands that can be translated. When running 965# under GETTEXT_POISON this pretends that the command produced expected 966# results. 967test_i18ncmp () { 968 test -n "$GETTEXT_POISON" || test_cmp "$@" 969} 970 971# Use this instead of "grep expected-string actual" to see if the 972# output from a git command that can be translated either contains an 973# expected string, or does not contain an unwanted one. When running 974# under GETTEXT_POISON this pretends that the command produced expected 975# results. 976test_i18ngrep () { 977 if test -n "$GETTEXT_POISON" 978 then 979 : # pretend success 980 elif test "x!" = "x$1" 981 then 982 shift 983 ! grep "$@" 984 else 985 grep "$@" 986 fi 987} 988 989test_lazy_prereq PIPE ' 990 # test whether the filesystem supports FIFOs 991 case $(uname -s) in 992 CYGWIN*) 993 false 994 ;; 995 *) 996 rm -f testfifo && mkfifo testfifo 997 ;; 998 esac 999'10001001test_lazy_prereq SYMLINKS '1002 # test whether the filesystem supports symbolic links1003 ln -s x y && test -h y1004'10051006test_lazy_prereq FILEMODE '1007 test "$(git config --bool core.filemode)" = true1008'10091010test_lazy_prereq CASE_INSENSITIVE_FS '1011 echo good >CamelCase &&1012 echo bad >camelcase &&1013 test "$(cat CamelCase)" != good1014'10151016test_lazy_prereq UTF8_NFD_TO_NFC '1017 # check whether FS converts nfd unicode to nfc1018 auml=$(printf "\303\244")1019 aumlcdiar=$(printf "\141\314\210")1020 >"$auml" &&1021 case "$(echo *)" in1022 "$aumlcdiar")1023 true ;;1024 *)1025 false ;;1026 esac1027'10281029test_lazy_prereq AUTOIDENT '1030 sane_unset GIT_AUTHOR_NAME &&1031 sane_unset GIT_AUTHOR_EMAIL &&1032 git var GIT_AUTHOR_IDENT1033'10341035test_lazy_prereq EXPENSIVE '1036 test -n "$GIT_TEST_LONG"1037'10381039test_lazy_prereq USR_BIN_TIME '1040 test -x /usr/bin/time1041'10421043test_lazy_prereq NOT_ROOT '1044 uid=$(id -u) &&1045 test "$uid" != 01046'10471048# On a filesystem that lacks SANITY, a file can be deleted even if1049# the containing directory doesn't have write permissions, or a file1050# can be accessed even if the containing directory doesn't have read1051# or execute permissions, causing our tests that validate that Git1052# works sensibly in such situations.1053test_lazy_prereq SANITY '1054 mkdir SANETESTD.1 SANETESTD.2 &&10551056 chmod +w SANETESTD.1 SANETESTD.2 &&1057 >SANETESTD.1/x 2>SANETESTD.2/x &&1058 chmod -w SANETESTD.1 &&1059 chmod -rx SANETESTD.2 ||1060 error "bug in test sript: cannot prepare SANETESTD"10611062 ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x1063 status=$?10641065 chmod +rwx SANETESTD.1 SANETESTD.2 &&1066 rm -rf SANETESTD.1 SANETESTD.2 ||1067 error "bug in test sript: cannot clean SANETESTD"1068 return $status1069'10701071GIT_UNZIP=${GIT_UNZIP:-unzip}1072test_lazy_prereq UNZIP '1073 "$GIT_UNZIP" -v1074 test $? -ne 1271075'10761077run_with_limited_cmdline () {1078 (ulimit -s 128 && "$@")1079}10801081test_lazy_prereq CMDLINE_LIMIT 'run_with_limited_cmdline true'