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