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 534want_trace () { 535 test "$trace" = t && test "$verbose" = t 536} 537 538# This is a separate function because some tests use 539# "return" to end a test_expect_success block early 540# (and we want to make sure we run any cleanup like 541# "set +x"). 542test_eval_inner_ () { 543 # Do not add anything extra (including LF) after '$*' 544 eval " 545 want_trace && set -x 546 $*" 547} 548 549test_eval_ () { 550 # We run this block with stderr redirected to avoid extra cruft 551 # during a "-x" trace. Once in "set -x" mode, we cannot prevent 552 # the shell from printing the "set +x" to turn it off (nor the saving 553 # of $? before that). But we can make sure that the output goes to 554 # /dev/null. 555 # 556 # The test itself is run with stderr put back to &4 (so either to 557 # /dev/null, or to the original stderr if --verbose was used). 558 { 559 test_eval_inner_ "$@" </dev/null >&3 2>&4 560 test_eval_ret_=$? 561 if want_trace 562 then 563 set +x 564 if test "$test_eval_ret_" != 0 565 then 566 say_color error >&4 "error: last command exited with \$?=$test_eval_ret_" 567 fi 568 fi 569 } 2>/dev/null 570 return $test_eval_ret_ 571} 572 573test_run_ () { 574 test_cleanup=: 575 expecting_failure=$2 576 577 if test "${GIT_TEST_CHAIN_LINT:-1}" != 0; then 578 # turn off tracing for this test-eval, as it simply creates 579 # confusing noise in the "-x" output 580 trace_tmp=$trace 581 trace= 582 # 117 is magic because it is unlikely to match the exit 583 # code of other programs 584 test_eval_ "(exit 117) && $1" 585 if test "$?" != 117; then 586 error "bug in the test script: broken &&-chain: $1" 587 fi 588 trace=$trace_tmp 589 fi 590 591 setup_malloc_check 592 test_eval_ "$1" 593 eval_ret=$? 594 teardown_malloc_check 595 596 if test -z "$immediate" || test $eval_ret = 0 || 597 test -n "$expecting_failure" && test "$test_cleanup" != ":" 598 then 599 setup_malloc_check 600 test_eval_ "$test_cleanup" 601 teardown_malloc_check 602 fi 603 if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE" 604 then 605 echo "" 606 fi 607 return "$eval_ret" 608} 609 610test_start_ () { 611 test_count=$(($test_count+1)) 612 maybe_setup_verbose 613 maybe_setup_valgrind 614} 615 616test_finish_ () { 617 echo >&3 "" 618 maybe_teardown_valgrind 619 maybe_teardown_verbose 620} 621 622test_skip () { 623 to_skip= 624 skipped_reason= 625 if match_pattern_list $this_test.$test_count $GIT_SKIP_TESTS 626 then 627 to_skip=t 628 skipped_reason="GIT_SKIP_TESTS" 629 fi 630 if test -z "$to_skip" && test -n "$test_prereq" && 631 ! test_have_prereq "$test_prereq" 632 then 633 to_skip=t 634 635 of_prereq= 636 if test "$missing_prereq" != "$test_prereq" 637 then 638 of_prereq=" of $test_prereq" 639 fi 640 skipped_reason="missing $missing_prereq${of_prereq}" 641 fi 642 if test -z "$to_skip" && test -n "$run_list" && 643 ! match_test_selector_list '--run' $test_count "$run_list" 644 then 645 to_skip=t 646 skipped_reason="--run" 647 fi 648 649 case "$to_skip" in 650 t) 651 say_color skip >&3 "skipping test: $@" 652 say_color skip "ok $test_count # skip $1 ($skipped_reason)" 653 : true 654 ;; 655 *) 656 false 657 ;; 658 esac 659} 660 661# stub; perf-lib overrides it 662test_at_end_hook_ () { 663 : 664} 665 666test_done () { 667 GIT_EXIT_OK=t 668 669 if test -z "$HARNESS_ACTIVE" 670 then 671 test_results_dir="$TEST_OUTPUT_DIRECTORY/test-results" 672 mkdir -p "$test_results_dir" 673 base=${0##*/} 674 test_results_path="$test_results_dir/${base%.sh}-$$.counts" 675 676 cat >>"$test_results_path" <<-EOF 677 total $test_count 678 success $test_success 679 fixed $test_fixed 680 broken $test_broken 681 failed $test_failure 682 683 EOF 684 fi 685 686 if test "$test_fixed" != 0 687 then 688 say_color error "# $test_fixed known breakage(s) vanished; please update test(s)" 689 fi 690 if test "$test_broken" != 0 691 then 692 say_color warn "# still have $test_broken known breakage(s)" 693 fi 694 if test "$test_broken" != 0 || test "$test_fixed" != 0 695 then 696 test_remaining=$(( $test_count - $test_broken - $test_fixed )) 697 msg="remaining $test_remaining test(s)" 698 else 699 test_remaining=$test_count 700 msg="$test_count test(s)" 701 fi 702 case "$test_failure" in 703 0) 704 # Maybe print SKIP message 705 if test -n "$skip_all" && test $test_count -gt 0 706 then 707 error "Can't use skip_all after running some tests" 708 fi 709 test -z "$skip_all" || skip_all=" # SKIP $skip_all" 710 711 if test $test_external_has_tap -eq 0 712 then 713 if test $test_remaining -gt 0 714 then 715 say_color pass "# passed all $msg" 716 fi 717 say "1..$test_count$skip_all" 718 fi 719 720 test -d "$remove_trash" && 721 cd "$(dirname "$remove_trash")" && 722 rm -rf "$(basename "$remove_trash")" 723 724 test_at_end_hook_ 725 726 exit 0 ;; 727 728 *) 729 if test $test_external_has_tap -eq 0 730 then 731 say_color error "# failed $test_failure among $msg" 732 say "1..$test_count" 733 fi 734 735 exit 1 ;; 736 737 esac 738} 739 740if test -n "$valgrind" 741then 742 make_symlink () { 743 test -h "$2" && 744 test "$1" = "$(readlink "$2")" || { 745 # be super paranoid 746 if mkdir "$2".lock 747 then 748 rm -f "$2" && 749 ln -s "$1" "$2" && 750 rm -r "$2".lock 751 else 752 while test -d "$2".lock 753 do 754 say "Waiting for lock on $2." 755 sleep 1 756 done 757 fi 758 } 759 } 760 761 make_valgrind_symlink () { 762 # handle only executables, unless they are shell libraries that 763 # need to be in the exec-path. 764 test -x "$1" || 765 test "# " = "$(head -c 2 <"$1")" || 766 return; 767 768 base=$(basename "$1") 769 symlink_target=$GIT_BUILD_DIR/$base 770 # do not override scripts 771 if test -x "$symlink_target" && 772 test ! -d "$symlink_target" && 773 test "#!" != "$(head -c 2 < "$symlink_target")" 774 then 775 symlink_target=../valgrind.sh 776 fi 777 case "$base" in 778 *.sh|*.perl) 779 symlink_target=../unprocessed-script 780 esac 781 # create the link, or replace it if it is out of date 782 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit 783 } 784 785 # override all git executables in TEST_DIRECTORY/.. 786 GIT_VALGRIND=$TEST_DIRECTORY/valgrind 787 mkdir -p "$GIT_VALGRIND"/bin 788 for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/test-* 789 do 790 make_valgrind_symlink $file 791 done 792 # special-case the mergetools loadables 793 make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools" 794 OLDIFS=$IFS 795 IFS=: 796 for path in $PATH 797 do 798 ls "$path"/git-* 2> /dev/null | 799 while read file 800 do 801 make_valgrind_symlink "$file" 802 done 803 done 804 IFS=$OLDIFS 805 PATH=$GIT_VALGRIND/bin:$PATH 806 GIT_EXEC_PATH=$GIT_VALGRIND/bin 807 export GIT_VALGRIND 808 GIT_VALGRIND_MODE="$valgrind" 809 export GIT_VALGRIND_MODE 810 GIT_VALGRIND_ENABLED=t 811 test -n "$valgrind_only" && GIT_VALGRIND_ENABLED= 812 export GIT_VALGRIND_ENABLED 813elif test -n "$GIT_TEST_INSTALLED" 814then 815 GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path) || 816 error "Cannot run git from $GIT_TEST_INSTALLED." 817 PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR:$PATH 818 GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH} 819else # normal case, use ../bin-wrappers only unless $with_dashes: 820 git_bin_dir="$GIT_BUILD_DIR/bin-wrappers" 821 if ! test -x "$git_bin_dir/git" 822 then 823 if test -z "$with_dashes" 824 then 825 say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH" 826 fi 827 with_dashes=t 828 fi 829 PATH="$git_bin_dir:$PATH" 830 GIT_EXEC_PATH=$GIT_BUILD_DIR 831 if test -n "$with_dashes" 832 then 833 PATH="$GIT_BUILD_DIR:$PATH" 834 fi 835fi 836GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt 837GIT_CONFIG_NOSYSTEM=1 838GIT_ATTR_NOSYSTEM=1 839export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM 840 841if test -z "$GIT_TEST_CMP" 842then 843 if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT" 844 then 845 GIT_TEST_CMP="$DIFF -c" 846 else 847 GIT_TEST_CMP="$DIFF -u" 848 fi 849fi 850 851GITPERLLIB="$GIT_BUILD_DIR"/perl/blib/lib:"$GIT_BUILD_DIR"/perl/blib/arch/auto/Git 852export GITPERLLIB 853test -d "$GIT_BUILD_DIR"/templates/blt || { 854 error "You haven't built things yet, have you?" 855} 856 857if ! test -x "$GIT_BUILD_DIR"/t/helper/test-chmtime 858then 859 echo >&2 'You need to build test-chmtime:' 860 echo >&2 'Run "make t/helper/test-chmtime" in the source (toplevel) directory' 861 exit 1 862fi 863 864# Test repository 865TRASH_DIRECTORY="trash directory.$(basename "$0" .sh)" 866test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY" 867case "$TRASH_DIRECTORY" in 868/*) ;; # absolute path is good 869 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;; 870esac 871test ! -z "$debug" || remove_trash=$TRASH_DIRECTORY 872rm -fr "$TRASH_DIRECTORY" || { 873 GIT_EXIT_OK=t 874 echo >&5 "FATAL: Cannot prepare test area" 875 exit 1 876} 877 878HOME="$TRASH_DIRECTORY" 879GNUPGHOME="$HOME/gnupg-home-not-used" 880export HOME GNUPGHOME 881 882if test -z "$TEST_NO_CREATE_REPO" 883then 884 test_create_repo "$TRASH_DIRECTORY" 885else 886 mkdir -p "$TRASH_DIRECTORY" 887fi 888# Use -P to resolve symlinks in our working directory so that the cwd 889# in subprocesses like git equals our $PWD (for pathname comparisons). 890cd -P "$TRASH_DIRECTORY" || exit 1 891 892this_test=${0##*/} 893this_test=${this_test%%-*} 894if match_pattern_list "$this_test" $GIT_SKIP_TESTS 895then 896 say_color info >&3 "skipping test $this_test altogether" 897 skip_all="skip all tests in $this_test" 898 test_done 899fi 900 901# Provide an implementation of the 'yes' utility 902yes () { 903 if test $# = 0 904 then 905 y=y 906 else 907 y="$*" 908 fi 909 910 i=0 911 while test $i -lt 99 912 do 913 echo "$y" 914 i=$(($i+1)) 915 done 916} 917 918# Fix some commands on Windows 919case $(uname -s) in 920*MINGW*) 921 # Windows has its own (incompatible) sort and find 922 sort () { 923 /usr/bin/sort "$@" 924 } 925 find () { 926 /usr/bin/find "$@" 927 } 928 sum () { 929 md5sum "$@" 930 } 931 # git sees Windows-style pwd 932 pwd () { 933 builtin pwd -W 934 } 935 # no POSIX permissions 936 # backslashes in pathspec are converted to '/' 937 # exec does not inherit the PID 938 test_set_prereq MINGW 939 test_set_prereq NATIVE_CRLF 940 test_set_prereq SED_STRIPS_CR 941 test_set_prereq GREP_STRIPS_CR 942 GIT_TEST_CMP=mingw_test_cmp 943 ;; 944*CYGWIN*) 945 test_set_prereq POSIXPERM 946 test_set_prereq EXECKEEPSPID 947 test_set_prereq CYGWIN 948 test_set_prereq SED_STRIPS_CR 949 test_set_prereq GREP_STRIPS_CR 950 ;; 951*) 952 test_set_prereq POSIXPERM 953 test_set_prereq BSLASHPSPEC 954 test_set_prereq EXECKEEPSPID 955 ;; 956esac 957 958( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_1 959test -z "$NO_PERL" && test_set_prereq PERL 960test -z "$NO_PYTHON" && test_set_prereq PYTHON 961test -n "$USE_LIBPCRE" && test_set_prereq LIBPCRE 962test -z "$NO_GETTEXT" && test_set_prereq GETTEXT 963 964# Can we rely on git's output in the C locale? 965if test -n "$GETTEXT_POISON" 966then 967 GIT_GETTEXT_POISON=YesPlease 968 export GIT_GETTEXT_POISON 969 test_set_prereq GETTEXT_POISON 970else 971 test_set_prereq C_LOCALE_OUTPUT 972fi 973 974# Use this instead of test_cmp to compare files that contain expected and 975# actual output from git commands that can be translated. When running 976# under GETTEXT_POISON this pretends that the command produced expected 977# results. 978test_i18ncmp () { 979 test -n "$GETTEXT_POISON" || test_cmp "$@" 980} 981 982# Use this instead of "grep expected-string actual" to see if the 983# output from a git command that can be translated either contains an 984# expected string, or does not contain an unwanted one. When running 985# under GETTEXT_POISON this pretends that the command produced expected 986# results. 987test_i18ngrep () { 988 if test -n "$GETTEXT_POISON" 989 then 990 : # pretend success 991 elif test "x!" = "x$1" 992 then 993 shift 994 ! grep "$@" 995 else 996 grep "$@" 997 fi 998} 9991000test_lazy_prereq PIPE '1001 # test whether the filesystem supports FIFOs1002 case $(uname -s) in1003 CYGWIN*|MINGW*)1004 false1005 ;;1006 *)1007 rm -f testfifo && mkfifo testfifo1008 ;;1009 esac1010'10111012test_lazy_prereq SYMLINKS '1013 # test whether the filesystem supports symbolic links1014 ln -s x y && test -h y1015'10161017test_lazy_prereq FILEMODE '1018 test "$(git config --bool core.filemode)" = true1019'10201021test_lazy_prereq CASE_INSENSITIVE_FS '1022 echo good >CamelCase &&1023 echo bad >camelcase &&1024 test "$(cat CamelCase)" != good1025'10261027test_lazy_prereq UTF8_NFD_TO_NFC '1028 # check whether FS converts nfd unicode to nfc1029 auml=$(printf "\303\244")1030 aumlcdiar=$(printf "\141\314\210")1031 >"$auml" &&1032 case "$(echo *)" in1033 "$aumlcdiar")1034 true ;;1035 *)1036 false ;;1037 esac1038'10391040test_lazy_prereq AUTOIDENT '1041 sane_unset GIT_AUTHOR_NAME &&1042 sane_unset GIT_AUTHOR_EMAIL &&1043 git var GIT_AUTHOR_IDENT1044'10451046test_lazy_prereq EXPENSIVE '1047 test -n "$GIT_TEST_LONG"1048'10491050test_lazy_prereq USR_BIN_TIME '1051 test -x /usr/bin/time1052'10531054test_lazy_prereq NOT_ROOT '1055 uid=$(id -u) &&1056 test "$uid" != 01057'10581059# SANITY is about "can you correctly predict what the filesystem would1060# do by only looking at the permission bits of the files and1061# directories?" A typical example of !SANITY is running the test1062# suite as root, where a test may expect "chmod -r file && cat file"1063# to fail because file is supposed to be unreadable after a successful1064# chmod. In an environment (i.e. combination of what filesystem is1065# being used and who is running the tests) that lacks SANITY, you may1066# be able to delete or create a file when the containing directory1067# doesn't have write permissions, or access a file even if the1068# containing directory doesn't have read or execute permissions.10691070test_lazy_prereq SANITY '1071 mkdir SANETESTD.1 SANETESTD.2 &&10721073 chmod +w SANETESTD.1 SANETESTD.2 &&1074 >SANETESTD.1/x 2>SANETESTD.2/x &&1075 chmod -w SANETESTD.1 &&1076 chmod -r SANETESTD.1/x &&1077 chmod -rx SANETESTD.2 ||1078 error "bug in test sript: cannot prepare SANETESTD"10791080 ! test -r SANETESTD.1/x &&1081 ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x1082 status=$?10831084 chmod +rwx SANETESTD.1 SANETESTD.2 &&1085 rm -rf SANETESTD.1 SANETESTD.2 ||1086 error "bug in test sript: cannot clean SANETESTD"1087 return $status1088'10891090GIT_UNZIP=${GIT_UNZIP:-unzip}1091test_lazy_prereq UNZIP '1092 "$GIT_UNZIP" -v1093 test $? -ne 1271094'10951096run_with_limited_cmdline () {1097 (ulimit -s 128 && "$@")1098}10991100test_lazy_prereq CMDLINE_LIMIT 'run_with_limited_cmdline true'