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