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