t / test-lib.shon commit t4014: drop unnecessary blank lines from test cases (fe49814)
   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
  52if test ! -f "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS
  53then
  54        echo >&2 'error: GIT-BUILD-OPTIONS missing (has Git been built?).'
  55        exit 1
  56fi
  57. "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS
  58export PERL_PATH SHELL_PATH
  59
  60# Disallow the use of abbreviated options in the test suite by default
  61if test -z "${GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS}"
  62then
  63        GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS=true
  64        export GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS
  65fi
  66
  67################################################################
  68# It appears that people try to run tests without building...
  69"${GIT_TEST_INSTALLED:-$GIT_BUILD_DIR}/git$X" >/dev/null
  70if test $? != 1
  71then
  72        if test -n "$GIT_TEST_INSTALLED"
  73        then
  74                echo >&2 "error: there is no working Git at '$GIT_TEST_INSTALLED'"
  75        else
  76                echo >&2 'error: you do not seem to have built git yet.'
  77        fi
  78        exit 1
  79fi
  80
  81# Parse options while taking care to leave $@ intact, so we will still
  82# have all the original command line options when executing the test
  83# script again for '--tee' and '--verbose-log' below.
  84store_arg_to=
  85prev_opt=
  86for opt
  87do
  88        if test -n "$store_arg_to"
  89        then
  90                eval $store_arg_to=\$opt
  91                store_arg_to=
  92                prev_opt=
  93                continue
  94        fi
  95
  96        case "$opt" in
  97        -d|--d|--de|--deb|--debu|--debug)
  98                debug=t ;;
  99        -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate)
 100                immediate=t ;;
 101        -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests)
 102                GIT_TEST_LONG=t; export GIT_TEST_LONG ;;
 103        -r)
 104                store_arg_to=run_list
 105                ;;
 106        --run=*)
 107                run_list=${opt#--*=} ;;
 108        -h|--h|--he|--hel|--help)
 109                help=t ;;
 110        -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose)
 111                verbose=t ;;
 112        --verbose-only=*)
 113                verbose_only=${opt#--*=}
 114                ;;
 115        -q|--q|--qu|--qui|--quie|--quiet)
 116                # Ignore --quiet under a TAP::Harness. Saying how many tests
 117                # passed without the ok/not ok details is always an error.
 118                test -z "$HARNESS_ACTIVE" && quiet=t ;;
 119        --with-dashes)
 120                with_dashes=t ;;
 121        --no-bin-wrappers)
 122                no_bin_wrappers=t ;;
 123        --no-color)
 124                color= ;;
 125        --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind)
 126                valgrind=memcheck
 127                tee=t
 128                ;;
 129        --valgrind=*)
 130                valgrind=${opt#--*=}
 131                tee=t
 132                ;;
 133        --valgrind-only=*)
 134                valgrind_only=${opt#--*=}
 135                tee=t
 136                ;;
 137        --tee)
 138                tee=t ;;
 139        --root=*)
 140                root=${opt#--*=} ;;
 141        --chain-lint)
 142                GIT_TEST_CHAIN_LINT=1 ;;
 143        --no-chain-lint)
 144                GIT_TEST_CHAIN_LINT=0 ;;
 145        -x)
 146                trace=t ;;
 147        -V|--verbose-log)
 148                verbose_log=t
 149                tee=t
 150                ;;
 151        --write-junit-xml)
 152                write_junit_xml=t
 153                ;;
 154        --stress)
 155                stress=t ;;
 156        --stress=*)
 157                echo "error: --stress does not accept an argument: '$opt'" >&2
 158                echo "did you mean --stress-jobs=${opt#*=} or --stress-limit=${opt#*=}?" >&2
 159                exit 1
 160                ;;
 161        --stress-jobs=*)
 162                stress=t;
 163                stress=${opt#--*=}
 164                case "$stress" in
 165                *[!0-9]*|0*|"")
 166                        echo "error: --stress-jobs=<N> requires the number of jobs to run" >&2
 167                        exit 1
 168                        ;;
 169                *)      # Good.
 170                        ;;
 171                esac
 172                ;;
 173        --stress-limit=*)
 174                stress=t;
 175                stress_limit=${opt#--*=}
 176                case "$stress_limit" in
 177                *[!0-9]*|0*|"")
 178                        echo "error: --stress-limit=<N> requires the number of repetitions" >&2
 179                        exit 1
 180                        ;;
 181                *)      # Good.
 182                        ;;
 183                esac
 184                ;;
 185        *)
 186                echo "error: unknown test option '$opt'" >&2; exit 1 ;;
 187        esac
 188
 189        prev_opt=$opt
 190done
 191if test -n "$store_arg_to"
 192then
 193        echo "error: $prev_opt requires an argument" >&2
 194        exit 1
 195fi
 196
 197if test -n "$valgrind_only"
 198then
 199        test -z "$valgrind" && valgrind=memcheck
 200        test -z "$verbose" && verbose_only="$valgrind_only"
 201elif test -n "$valgrind"
 202then
 203        test -z "$verbose_log" && verbose=t
 204fi
 205
 206if test -n "$stress"
 207then
 208        verbose=t
 209        trace=t
 210        immediate=t
 211fi
 212
 213TEST_STRESS_JOB_SFX="${GIT_TEST_STRESS_JOB_NR:+.stress-$GIT_TEST_STRESS_JOB_NR}"
 214TEST_NAME="$(basename "$0" .sh)"
 215TEST_RESULTS_DIR="$TEST_OUTPUT_DIRECTORY/test-results"
 216TEST_RESULTS_BASE="$TEST_RESULTS_DIR/$TEST_NAME$TEST_STRESS_JOB_SFX"
 217TRASH_DIRECTORY="trash directory.$TEST_NAME$TEST_STRESS_JOB_SFX"
 218test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY"
 219case "$TRASH_DIRECTORY" in
 220/*) ;; # absolute path is good
 221 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;;
 222esac
 223
 224# If --stress was passed, run this test repeatedly in several parallel loops.
 225if test "$GIT_TEST_STRESS_STARTED" = "done"
 226then
 227        : # Don't stress test again.
 228elif test -n "$stress"
 229then
 230        if test "$stress" != t
 231        then
 232                job_count=$stress
 233        elif test -n "$GIT_TEST_STRESS_LOAD"
 234        then
 235                job_count="$GIT_TEST_STRESS_LOAD"
 236        elif job_count=$(getconf _NPROCESSORS_ONLN 2>/dev/null) &&
 237             test -n "$job_count"
 238        then
 239                job_count=$((2 * $job_count))
 240        else
 241                job_count=8
 242        fi
 243
 244        mkdir -p "$TEST_RESULTS_DIR"
 245        stressfail="$TEST_RESULTS_BASE.stress-failed"
 246        rm -f "$stressfail"
 247
 248        stress_exit=0
 249        trap '
 250                kill $job_pids 2>/dev/null
 251                wait
 252                stress_exit=1
 253        ' TERM INT HUP
 254
 255        job_pids=
 256        job_nr=0
 257        while test $job_nr -lt "$job_count"
 258        do
 259                (
 260                        GIT_TEST_STRESS_STARTED=done
 261                        GIT_TEST_STRESS_JOB_NR=$job_nr
 262                        export GIT_TEST_STRESS_STARTED GIT_TEST_STRESS_JOB_NR
 263
 264                        trap '
 265                                kill $test_pid 2>/dev/null
 266                                wait
 267                                exit 1
 268                        ' TERM INT
 269
 270                        cnt=1
 271                        while ! test -e "$stressfail" &&
 272                              { test -z "$stress_limit" ||
 273                                test $cnt -le $stress_limit ; }
 274                        do
 275                                $TEST_SHELL_PATH "$0" "$@" >"$TEST_RESULTS_BASE.stress-$job_nr.out" 2>&1 &
 276                                test_pid=$!
 277
 278                                if wait $test_pid
 279                                then
 280                                        printf "OK   %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt
 281                                else
 282                                        echo $GIT_TEST_STRESS_JOB_NR >>"$stressfail"
 283                                        printf "FAIL %2d.%d\n" $GIT_TEST_STRESS_JOB_NR $cnt
 284                                fi
 285                                cnt=$(($cnt + 1))
 286                        done
 287                ) &
 288                job_pids="$job_pids $!"
 289                job_nr=$(($job_nr + 1))
 290        done
 291
 292        wait
 293
 294        if test -f "$stressfail"
 295        then
 296                stress_exit=1
 297                echo "Log(s) of failed test run(s):"
 298                for failed_job_nr in $(sort -n "$stressfail")
 299                do
 300                        echo "Contents of '$TEST_RESULTS_BASE.stress-$failed_job_nr.out':"
 301                        cat "$TEST_RESULTS_BASE.stress-$failed_job_nr.out"
 302                done
 303                rm -rf "$TRASH_DIRECTORY.stress-failed"
 304                # Move the last one.
 305                mv "$TRASH_DIRECTORY.stress-$failed_job_nr" "$TRASH_DIRECTORY.stress-failed"
 306        fi
 307
 308        exit $stress_exit
 309fi
 310
 311# if --tee was passed, write the output not only to the terminal, but
 312# additionally to the file test-results/$BASENAME.out, too.
 313if test "$GIT_TEST_TEE_STARTED" = "done"
 314then
 315        : # do not redirect again
 316elif test -n "$tee"
 317then
 318        mkdir -p "$TEST_RESULTS_DIR"
 319
 320        # Make this filename available to the sub-process in case it is using
 321        # --verbose-log.
 322        GIT_TEST_TEE_OUTPUT_FILE=$TEST_RESULTS_BASE.out
 323        export GIT_TEST_TEE_OUTPUT_FILE
 324
 325        # Truncate before calling "tee -a" to get rid of the results
 326        # from any previous runs.
 327        >"$GIT_TEST_TEE_OUTPUT_FILE"
 328
 329        (GIT_TEST_TEE_STARTED=done ${TEST_SHELL_PATH} "$0" "$@" 2>&1;
 330         echo $? >"$TEST_RESULTS_BASE.exit") | tee -a "$GIT_TEST_TEE_OUTPUT_FILE"
 331        test "$(cat "$TEST_RESULTS_BASE.exit")" = 0
 332        exit
 333fi
 334
 335if test -n "$trace" && test -n "$test_untraceable"
 336then
 337        # '-x' tracing requested, but this test script can't be reliably
 338        # traced, unless it is run with a Bash version supporting
 339        # BASH_XTRACEFD (introduced in Bash v4.1).
 340        #
 341        # Perform this version check _after_ the test script was
 342        # potentially re-executed with $TEST_SHELL_PATH for '--tee' or
 343        # '--verbose-log', so the right shell is checked and the
 344        # warning is issued only once.
 345        if test -n "$BASH_VERSION" && eval '
 346             test ${BASH_VERSINFO[0]} -gt 4 || {
 347               test ${BASH_VERSINFO[0]} -eq 4 &&
 348               test ${BASH_VERSINFO[1]} -ge 1
 349             }
 350           '
 351        then
 352                : Executed by a Bash version supporting BASH_XTRACEFD.  Good.
 353        else
 354                echo >&2 "warning: ignoring -x; '$0' is untraceable without BASH_XTRACEFD"
 355                trace=
 356        fi
 357fi
 358if test -n "$trace" && test -z "$verbose_log"
 359then
 360        verbose=t
 361fi
 362
 363# For repeatability, reset the environment to known value.
 364# TERM is sanitized below, after saving color control sequences.
 365LANG=C
 366LC_ALL=C
 367PAGER=cat
 368TZ=UTC
 369export LANG LC_ALL PAGER TZ
 370EDITOR=:
 371
 372# GIT_TEST_GETTEXT_POISON should not influence git commands executed
 373# during initialization of test-lib and the test repo. Back it up,
 374# unset and then restore after initialization is finished.
 375if test -n "$GIT_TEST_GETTEXT_POISON"
 376then
 377        GIT_TEST_GETTEXT_POISON_ORIG=$GIT_TEST_GETTEXT_POISON
 378        unset GIT_TEST_GETTEXT_POISON
 379fi
 380
 381# A call to "unset" with no arguments causes at least Solaris 10
 382# /usr/xpg4/bin/sh and /bin/ksh to bail out.  So keep the unsets
 383# deriving from the command substitution clustered with the other
 384# ones.
 385unset VISUAL EMAIL LANGUAGE COLUMNS $("$PERL_PATH" -e '
 386        my @env = keys %ENV;
 387        my $ok = join("|", qw(
 388                TRACE
 389                DEBUG
 390                TEST
 391                .*_TEST
 392                PROVE
 393                VALGRIND
 394                UNZIP
 395                PERF_
 396                CURL_VERBOSE
 397                TRACE_CURL
 398        ));
 399        my @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env);
 400        print join("\n", @vars);
 401')
 402unset XDG_CACHE_HOME
 403unset XDG_CONFIG_HOME
 404unset GITPERLLIB
 405GIT_AUTHOR_EMAIL=author@example.com
 406GIT_AUTHOR_NAME='A U Thor'
 407GIT_COMMITTER_EMAIL=committer@example.com
 408GIT_COMMITTER_NAME='C O Mitter'
 409GIT_MERGE_VERBOSITY=5
 410GIT_MERGE_AUTOEDIT=no
 411export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT
 412export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME
 413export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME
 414export EDITOR
 415
 416# Tests using GIT_TRACE typically don't want <timestamp> <file>:<line> output
 417GIT_TRACE_BARE=1
 418export GIT_TRACE_BARE
 419
 420check_var_migration () {
 421        # the warnings and hints given from this helper depends
 422        # on end-user settings, which will disrupt the self-test
 423        # done on the test framework itself.
 424        case "$GIT_TEST_FRAMEWORK_SELFTEST" in
 425        t)      return ;;
 426        esac
 427
 428        old_name=$1 new_name=$2
 429        eval "old_isset=\${${old_name}:+isset}"
 430        eval "new_isset=\${${new_name}:+isset}"
 431
 432        case "$old_isset,$new_isset" in
 433        isset,)
 434                echo >&2 "warning: $old_name is now $new_name"
 435                echo >&2 "hint: set $new_name too during the transition period"
 436                eval "$new_name=\$$old_name"
 437                ;;
 438        isset,isset)
 439                # do this later
 440                # echo >&2 "warning: $old_name is now $new_name"
 441                # echo >&2 "hint: remove $old_name"
 442                ;;
 443        esac
 444}
 445
 446check_var_migration GIT_FSMONITOR_TEST GIT_TEST_FSMONITOR
 447check_var_migration TEST_GIT_INDEX_VERSION GIT_TEST_INDEX_VERSION
 448check_var_migration GIT_FORCE_PRELOAD_TEST GIT_TEST_PRELOAD_INDEX
 449
 450# Use specific version of the index file format
 451if test -n "${GIT_TEST_INDEX_VERSION:+isset}"
 452then
 453        GIT_INDEX_VERSION="$GIT_TEST_INDEX_VERSION"
 454        export GIT_INDEX_VERSION
 455fi
 456
 457# Add libc MALLOC and MALLOC_PERTURB test
 458# only if we are not executing the test with valgrind
 459if test -n "$valgrind" ||
 460   test -n "$TEST_NO_MALLOC_CHECK"
 461then
 462        setup_malloc_check () {
 463                : nothing
 464        }
 465        teardown_malloc_check () {
 466                : nothing
 467        }
 468else
 469        setup_malloc_check () {
 470                MALLOC_CHECK_=3 MALLOC_PERTURB_=165
 471                export MALLOC_CHECK_ MALLOC_PERTURB_
 472        }
 473        teardown_malloc_check () {
 474                unset MALLOC_CHECK_ MALLOC_PERTURB_
 475        }
 476fi
 477
 478# Protect ourselves from common misconfiguration to export
 479# CDPATH into the environment
 480unset CDPATH
 481
 482unset GREP_OPTIONS
 483unset UNZIP
 484
 485case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in
 4861|2|true)
 487        GIT_TRACE=4
 488        ;;
 489esac
 490
 491# Convenience
 492#
 493# A regexp to match 5, 35 and 40 hexdigits
 494_x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
 495_x35="$_x05$_x05$_x05$_x05$_x05$_x05$_x05"
 496_x40="$_x35$_x05"
 497
 498# Zero SHA-1
 499_z40=0000000000000000000000000000000000000000
 500
 501OID_REGEX="$_x40"
 502ZERO_OID=$_z40
 503EMPTY_TREE=4b825dc642cb6eb9a060e54bf8d69288fbee4904
 504EMPTY_BLOB=e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
 505
 506# Line feed
 507LF='
 508'
 509
 510# UTF-8 ZERO WIDTH NON-JOINER, which HFS+ ignores
 511# when case-folding filenames
 512u200c=$(printf '\342\200\214')
 513
 514export _x05 _x35 _x40 _z40 LF u200c EMPTY_TREE EMPTY_BLOB ZERO_OID OID_REGEX
 515
 516# Each test should start with something like this, after copyright notices:
 517#
 518# test_description='Description of this test...
 519# This test checks if command xyzzy does the right thing...
 520# '
 521# . ./test-lib.sh
 522test "x$TERM" != "xdumb" && (
 523                test -t 1 &&
 524                tput bold >/dev/null 2>&1 &&
 525                tput setaf 1 >/dev/null 2>&1 &&
 526                tput sgr0 >/dev/null 2>&1
 527        ) &&
 528        color=t
 529
 530if test -n "$color"
 531then
 532        # Save the color control sequences now rather than run tput
 533        # each time say_color() is called.  This is done for two
 534        # reasons:
 535        #   * TERM will be changed to dumb
 536        #   * HOME will be changed to a temporary directory and tput
 537        #     might need to read ~/.terminfo from the original HOME
 538        #     directory to get the control sequences
 539        # Note:  This approach assumes the control sequences don't end
 540        # in a newline for any terminal of interest (command
 541        # substitutions strip trailing newlines).  Given that most
 542        # (all?) terminals in common use are related to ECMA-48, this
 543        # shouldn't be a problem.
 544        say_color_error=$(tput bold; tput setaf 1) # bold red
 545        say_color_skip=$(tput setaf 4) # blue
 546        say_color_warn=$(tput setaf 3) # brown/yellow
 547        say_color_pass=$(tput setaf 2) # green
 548        say_color_info=$(tput setaf 6) # cyan
 549        say_color_reset=$(tput sgr0)
 550        say_color_="" # no formatting for normal text
 551        say_color () {
 552                test -z "$1" && test -n "$quiet" && return
 553                eval "say_color_color=\$say_color_$1"
 554                shift
 555                printf "%s\\n" "$say_color_color$*$say_color_reset"
 556        }
 557else
 558        say_color() {
 559                test -z "$1" && test -n "$quiet" && return
 560                shift
 561                printf "%s\n" "$*"
 562        }
 563fi
 564
 565TERM=dumb
 566export TERM
 567
 568error () {
 569        say_color error "error: $*"
 570        GIT_EXIT_OK=t
 571        exit 1
 572}
 573
 574BUG () {
 575        error >&7 "bug in the test script: $*"
 576}
 577
 578say () {
 579        say_color info "$*"
 580}
 581
 582if test -n "$HARNESS_ACTIVE"
 583then
 584        if test "$verbose" = t || test -n "$verbose_only"
 585        then
 586                printf 'Bail out! %s\n' \
 587                 'verbose mode forbidden under TAP harness; try --verbose-log'
 588                exit 1
 589        fi
 590fi
 591
 592test "${test_description}" != "" ||
 593error "Test script did not set test_description."
 594
 595if test "$help" = "t"
 596then
 597        printf '%s\n' "$test_description"
 598        exit 0
 599fi
 600
 601exec 5>&1
 602exec 6<&0
 603exec 7>&2
 604if test "$verbose_log" = "t"
 605then
 606        exec 3>>"$GIT_TEST_TEE_OUTPUT_FILE" 4>&3
 607elif test "$verbose" = "t"
 608then
 609        exec 4>&2 3>&1
 610else
 611        exec 4>/dev/null 3>/dev/null
 612fi
 613
 614# Send any "-x" output directly to stderr to avoid polluting tests
 615# which capture stderr. We can do this unconditionally since it
 616# has no effect if tracing isn't turned on.
 617#
 618# Note that this sets up the trace fd as soon as we assign the variable, so it
 619# must come after the creation of descriptor 4 above. Likewise, we must never
 620# unset this, as it has the side effect of closing descriptor 4, which we
 621# use to show verbose tests to the user.
 622#
 623# Note also that we don't need or want to export it. The tracing is local to
 624# this shell, and we would not want to influence any shells we exec.
 625BASH_XTRACEFD=4
 626
 627test_failure=0
 628test_count=0
 629test_fixed=0
 630test_broken=0
 631test_success=0
 632
 633test_external_has_tap=0
 634
 635die () {
 636        code=$?
 637        # This is responsible for running the atexit commands even when a
 638        # test script run with '--immediate' fails, or when the user hits
 639        # ctrl-C, i.e. when 'test_done' is not invoked at all.
 640        test_atexit_handler || code=$?
 641        if test -n "$GIT_EXIT_OK"
 642        then
 643                exit $code
 644        else
 645                echo >&5 "FATAL: Unexpected exit with code $code"
 646                exit 1
 647        fi
 648}
 649
 650GIT_EXIT_OK=
 651trap 'die' EXIT
 652# Disable '-x' tracing, because with some shells, notably dash, it
 653# prevents running the cleanup commands when a test script run with
 654# '--verbose-log -x' is interrupted.
 655trap '{ code=$?; set +x; } 2>/dev/null; exit $code' INT TERM HUP
 656
 657# The user-facing functions are loaded from a separate file so that
 658# test_perf subshells can have them too
 659. "$TEST_DIRECTORY/test-lib-functions.sh"
 660
 661# You are not expected to call test_ok_ and test_failure_ directly, use
 662# the test_expect_* functions instead.
 663
 664test_ok_ () {
 665        if test -n "$write_junit_xml"
 666        then
 667                write_junit_xml_testcase "$*"
 668        fi
 669        test_success=$(($test_success + 1))
 670        say_color "" "ok $test_count - $@"
 671}
 672
 673test_failure_ () {
 674        if test -n "$write_junit_xml"
 675        then
 676                junit_insert="<failure message=\"not ok $test_count -"
 677                junit_insert="$junit_insert $(xml_attr_encode "$1")\">"
 678                junit_insert="$junit_insert $(xml_attr_encode \
 679                        "$(if test -n "$GIT_TEST_TEE_OUTPUT_FILE"
 680                           then
 681                                test-tool path-utils skip-n-bytes \
 682                                        "$GIT_TEST_TEE_OUTPUT_FILE" $GIT_TEST_TEE_OFFSET
 683                           else
 684                                printf '%s\n' "$@" | sed 1d
 685                           fi)")"
 686                junit_insert="$junit_insert</failure>"
 687                if test -n "$GIT_TEST_TEE_OUTPUT_FILE"
 688                then
 689                        junit_insert="$junit_insert<system-err>$(xml_attr_encode \
 690                                "$(cat "$GIT_TEST_TEE_OUTPUT_FILE")")</system-err>"
 691                fi
 692                write_junit_xml_testcase "$1" "      $junit_insert"
 693        fi
 694        test_failure=$(($test_failure + 1))
 695        say_color error "not ok $test_count - $1"
 696        shift
 697        printf '%s\n' "$*" | sed -e 's/^/#      /'
 698        test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; }
 699}
 700
 701test_known_broken_ok_ () {
 702        if test -n "$write_junit_xml"
 703        then
 704                write_junit_xml_testcase "$* (breakage fixed)"
 705        fi
 706        test_fixed=$(($test_fixed+1))
 707        say_color error "ok $test_count - $@ # TODO known breakage vanished"
 708}
 709
 710test_known_broken_failure_ () {
 711        if test -n "$write_junit_xml"
 712        then
 713                write_junit_xml_testcase "$* (known breakage)"
 714        fi
 715        test_broken=$(($test_broken+1))
 716        say_color warn "not ok $test_count - $@ # TODO known breakage"
 717}
 718
 719test_debug () {
 720        test "$debug" = "" || eval "$1"
 721}
 722
 723match_pattern_list () {
 724        arg="$1"
 725        shift
 726        test -z "$*" && return 1
 727        for pattern_
 728        do
 729                case "$arg" in
 730                $pattern_)
 731                        return 0
 732                esac
 733        done
 734        return 1
 735}
 736
 737match_test_selector_list () {
 738        title="$1"
 739        shift
 740        arg="$1"
 741        shift
 742        test -z "$1" && return 0
 743
 744        # Both commas and whitespace are accepted as separators.
 745        OLDIFS=$IFS
 746        IFS='   ,'
 747        set -- $1
 748        IFS=$OLDIFS
 749
 750        # If the first selector is negative we include by default.
 751        include=
 752        case "$1" in
 753                !*) include=t ;;
 754        esac
 755
 756        for selector
 757        do
 758                orig_selector=$selector
 759
 760                positive=t
 761                case "$selector" in
 762                        !*)
 763                                positive=
 764                                selector=${selector##?}
 765                                ;;
 766                esac
 767
 768                test -z "$selector" && continue
 769
 770                case "$selector" in
 771                        *-*)
 772                                if expr "z${selector%%-*}" : "z[0-9]*[^0-9]" >/dev/null
 773                                then
 774                                        echo "error: $title: invalid non-numeric in range" \
 775                                                "start: '$orig_selector'" >&2
 776                                        exit 1
 777                                fi
 778                                if expr "z${selector#*-}" : "z[0-9]*[^0-9]" >/dev/null
 779                                then
 780                                        echo "error: $title: invalid non-numeric in range" \
 781                                                "end: '$orig_selector'" >&2
 782                                        exit 1
 783                                fi
 784                                ;;
 785                        *)
 786                                if expr "z$selector" : "z[0-9]*[^0-9]" >/dev/null
 787                                then
 788                                        echo "error: $title: invalid non-numeric in test" \
 789                                                "selector: '$orig_selector'" >&2
 790                                        exit 1
 791                                fi
 792                esac
 793
 794                # Short cut for "obvious" cases
 795                test -z "$include" && test -z "$positive" && continue
 796                test -n "$include" && test -n "$positive" && continue
 797
 798                case "$selector" in
 799                        -*)
 800                                if test $arg -le ${selector#-}
 801                                then
 802                                        include=$positive
 803                                fi
 804                                ;;
 805                        *-)
 806                                if test $arg -ge ${selector%-}
 807                                then
 808                                        include=$positive
 809                                fi
 810                                ;;
 811                        *-*)
 812                                if test ${selector%%-*} -le $arg \
 813                                        && test $arg -le ${selector#*-}
 814                                then
 815                                        include=$positive
 816                                fi
 817                                ;;
 818                        *)
 819                                if test $arg -eq $selector
 820                                then
 821                                        include=$positive
 822                                fi
 823                                ;;
 824                esac
 825        done
 826
 827        test -n "$include"
 828}
 829
 830maybe_teardown_verbose () {
 831        test -z "$verbose_only" && return
 832        exec 4>/dev/null 3>/dev/null
 833        verbose=
 834}
 835
 836last_verbose=t
 837maybe_setup_verbose () {
 838        test -z "$verbose_only" && return
 839        if match_pattern_list $test_count $verbose_only
 840        then
 841                exec 4>&2 3>&1
 842                # Emit a delimiting blank line when going from
 843                # non-verbose to verbose.  Within verbose mode the
 844                # delimiter is printed by test_expect_*.  The choice
 845                # of the initial $last_verbose is such that before
 846                # test 1, we do not print it.
 847                test -z "$last_verbose" && echo >&3 ""
 848                verbose=t
 849        else
 850                exec 4>/dev/null 3>/dev/null
 851                verbose=
 852        fi
 853        last_verbose=$verbose
 854}
 855
 856maybe_teardown_valgrind () {
 857        test -z "$GIT_VALGRIND" && return
 858        GIT_VALGRIND_ENABLED=
 859}
 860
 861maybe_setup_valgrind () {
 862        test -z "$GIT_VALGRIND" && return
 863        if test -z "$valgrind_only"
 864        then
 865                GIT_VALGRIND_ENABLED=t
 866                return
 867        fi
 868        GIT_VALGRIND_ENABLED=
 869        if match_pattern_list $test_count $valgrind_only
 870        then
 871                GIT_VALGRIND_ENABLED=t
 872        fi
 873}
 874
 875want_trace () {
 876        test "$trace" = t && {
 877                test "$verbose" = t || test "$verbose_log" = t
 878        }
 879}
 880
 881# This is a separate function because some tests use
 882# "return" to end a test_expect_success block early
 883# (and we want to make sure we run any cleanup like
 884# "set +x").
 885test_eval_inner_ () {
 886        # Do not add anything extra (including LF) after '$*'
 887        eval "
 888                want_trace && set -x
 889                $*"
 890}
 891
 892test_eval_ () {
 893        # If "-x" tracing is in effect, then we want to avoid polluting stderr
 894        # with non-test commands. But once in "set -x" mode, we cannot prevent
 895        # the shell from printing the "set +x" to turn it off (nor the saving
 896        # of $? before that). But we can make sure that the output goes to
 897        # /dev/null.
 898        #
 899        # There are a few subtleties here:
 900        #
 901        #   - we have to redirect descriptor 4 in addition to 2, to cover
 902        #     BASH_XTRACEFD
 903        #
 904        #   - the actual eval has to come before the redirection block (since
 905        #     it needs to see descriptor 4 to set up its stderr)
 906        #
 907        #   - likewise, any error message we print must be outside the block to
 908        #     access descriptor 4
 909        #
 910        #   - checking $? has to come immediately after the eval, but it must
 911        #     be _inside_ the block to avoid polluting the "set -x" output
 912        #
 913
 914        test_eval_inner_ "$@" </dev/null >&3 2>&4
 915        {
 916                test_eval_ret_=$?
 917                if want_trace
 918                then
 919                        set +x
 920                fi
 921        } 2>/dev/null 4>&2
 922
 923        if test "$test_eval_ret_" != 0 && want_trace
 924        then
 925                say_color error >&4 "error: last command exited with \$?=$test_eval_ret_"
 926        fi
 927        return $test_eval_ret_
 928}
 929
 930test_run_ () {
 931        test_cleanup=:
 932        expecting_failure=$2
 933
 934        if test "${GIT_TEST_CHAIN_LINT:-1}" != 0; then
 935                # turn off tracing for this test-eval, as it simply creates
 936                # confusing noise in the "-x" output
 937                trace_tmp=$trace
 938                trace=
 939                # 117 is magic because it is unlikely to match the exit
 940                # code of other programs
 941                if $(printf '%s\n' "$1" | sed -f "$GIT_BUILD_DIR/t/chainlint.sed" | grep -q '?![A-Z][A-Z]*?!') ||
 942                        test "OK-117" != "$(test_eval_ "(exit 117) && $1${LF}${LF}echo OK-\$?" 3>&1)"
 943                then
 944                        BUG "broken &&-chain or run-away HERE-DOC: $1"
 945                fi
 946                trace=$trace_tmp
 947        fi
 948
 949        setup_malloc_check
 950        test_eval_ "$1"
 951        eval_ret=$?
 952        teardown_malloc_check
 953
 954        if test -z "$immediate" || test $eval_ret = 0 ||
 955           test -n "$expecting_failure" && test "$test_cleanup" != ":"
 956        then
 957                setup_malloc_check
 958                test_eval_ "$test_cleanup"
 959                teardown_malloc_check
 960        fi
 961        if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE"
 962        then
 963                echo ""
 964        fi
 965        return "$eval_ret"
 966}
 967
 968test_start_ () {
 969        test_count=$(($test_count+1))
 970        maybe_setup_verbose
 971        maybe_setup_valgrind
 972        if test -n "$write_junit_xml"
 973        then
 974                junit_start=$(test-tool date getnanos)
 975        fi
 976}
 977
 978test_finish_ () {
 979        echo >&3 ""
 980        maybe_teardown_valgrind
 981        maybe_teardown_verbose
 982        if test -n "$GIT_TEST_TEE_OFFSET"
 983        then
 984                GIT_TEST_TEE_OFFSET=$(test-tool path-utils file-size \
 985                        "$GIT_TEST_TEE_OUTPUT_FILE")
 986        fi
 987}
 988
 989test_skip () {
 990        to_skip=
 991        skipped_reason=
 992        if match_pattern_list $this_test.$test_count $GIT_SKIP_TESTS
 993        then
 994                to_skip=t
 995                skipped_reason="GIT_SKIP_TESTS"
 996        fi
 997        if test -z "$to_skip" && test -n "$test_prereq" &&
 998           ! test_have_prereq "$test_prereq"
 999        then
1000                to_skip=t
1001
1002                of_prereq=
1003                if test "$missing_prereq" != "$test_prereq"
1004                then
1005                        of_prereq=" of $test_prereq"
1006                fi
1007                skipped_reason="missing $missing_prereq${of_prereq}"
1008        fi
1009        if test -z "$to_skip" && test -n "$run_list" &&
1010                ! match_test_selector_list '--run' $test_count "$run_list"
1011        then
1012                to_skip=t
1013                skipped_reason="--run"
1014        fi
1015
1016        case "$to_skip" in
1017        t)
1018                if test -n "$write_junit_xml"
1019                then
1020                        message="$(xml_attr_encode "$skipped_reason")"
1021                        write_junit_xml_testcase "$1" \
1022                                "      <skipped message=\"$message\" />"
1023                fi
1024
1025                say_color skip >&3 "skipping test: $@"
1026                say_color skip "ok $test_count # skip $1 ($skipped_reason)"
1027                : true
1028                ;;
1029        *)
1030                false
1031                ;;
1032        esac
1033}
1034
1035# stub; perf-lib overrides it
1036test_at_end_hook_ () {
1037        :
1038}
1039
1040write_junit_xml () {
1041        case "$1" in
1042        --truncate)
1043                >"$junit_xml_path"
1044                junit_have_testcase=
1045                shift
1046                ;;
1047        esac
1048        printf '%s\n' "$@" >>"$junit_xml_path"
1049}
1050
1051xml_attr_encode () {
1052        printf '%s\n' "$@" | test-tool xml-encode
1053}
1054
1055write_junit_xml_testcase () {
1056        junit_attrs="name=\"$(xml_attr_encode "$this_test.$test_count $1")\""
1057        shift
1058        junit_attrs="$junit_attrs classname=\"$this_test\""
1059        junit_attrs="$junit_attrs time=\"$(test-tool \
1060                date getnanos $junit_start)\""
1061        write_junit_xml "$(printf '%s\n' \
1062                "    <testcase $junit_attrs>" "$@" "    </testcase>")"
1063        junit_have_testcase=t
1064}
1065
1066test_atexit_cleanup=:
1067test_atexit_handler () {
1068        # In a succeeding test script 'test_atexit_handler' is invoked
1069        # twice: first from 'test_done', then from 'die' in the trap on
1070        # EXIT.
1071        # This condition and resetting 'test_atexit_cleanup' below makes
1072        # sure that the registered cleanup commands are run only once.
1073        test : != "$test_atexit_cleanup" || return 0
1074
1075        setup_malloc_check
1076        test_eval_ "$test_atexit_cleanup"
1077        test_atexit_cleanup=:
1078        teardown_malloc_check
1079}
1080
1081test_done () {
1082        GIT_EXIT_OK=t
1083
1084        # Run the atexit commands _before_ the trash directory is
1085        # removed, so the commands can access pidfiles and socket files.
1086        test_atexit_handler
1087
1088        if test -n "$write_junit_xml" && test -n "$junit_xml_path"
1089        then
1090                test -n "$junit_have_testcase" || {
1091                        junit_start=$(test-tool date getnanos)
1092                        write_junit_xml_testcase "all tests skipped"
1093                }
1094
1095                # adjust the overall time
1096                junit_time=$(test-tool date getnanos $junit_suite_start)
1097                sed "s/<testsuite [^>]*/& time=\"$junit_time\"/" \
1098                        <"$junit_xml_path" >"$junit_xml_path.new"
1099                mv "$junit_xml_path.new" "$junit_xml_path"
1100
1101                write_junit_xml "  </testsuite>" "</testsuites>"
1102        fi
1103
1104        if test -z "$HARNESS_ACTIVE"
1105        then
1106                mkdir -p "$TEST_RESULTS_DIR"
1107
1108                cat >"$TEST_RESULTS_BASE.counts" <<-EOF
1109                total $test_count
1110                success $test_success
1111                fixed $test_fixed
1112                broken $test_broken
1113                failed $test_failure
1114
1115                EOF
1116        fi
1117
1118        if test "$test_fixed" != 0
1119        then
1120                say_color error "# $test_fixed known breakage(s) vanished; please update test(s)"
1121        fi
1122        if test "$test_broken" != 0
1123        then
1124                say_color warn "# still have $test_broken known breakage(s)"
1125        fi
1126        if test "$test_broken" != 0 || test "$test_fixed" != 0
1127        then
1128                test_remaining=$(( $test_count - $test_broken - $test_fixed ))
1129                msg="remaining $test_remaining test(s)"
1130        else
1131                test_remaining=$test_count
1132                msg="$test_count test(s)"
1133        fi
1134        case "$test_failure" in
1135        0)
1136                if test $test_external_has_tap -eq 0
1137                then
1138                        if test $test_remaining -gt 0
1139                        then
1140                                say_color pass "# passed all $msg"
1141                        fi
1142
1143                        # Maybe print SKIP message
1144                        test -z "$skip_all" || skip_all="# SKIP $skip_all"
1145                        case "$test_count" in
1146                        0)
1147                                say "1..$test_count${skip_all:+ $skip_all}"
1148                                ;;
1149                        *)
1150                                test -z "$skip_all" ||
1151                                say_color warn "$skip_all"
1152                                say "1..$test_count"
1153                                ;;
1154                        esac
1155                fi
1156
1157                if test -z "$debug"
1158                then
1159                        test -d "$TRASH_DIRECTORY" ||
1160                        error "Tests passed but trash directory already removed before test cleanup; aborting"
1161
1162                        cd "$TRASH_DIRECTORY/.." &&
1163                        rm -fr "$TRASH_DIRECTORY" || {
1164                                # try again in a bit
1165                                sleep 5;
1166                                rm -fr "$TRASH_DIRECTORY"
1167                        } ||
1168                        error "Tests passed but test cleanup failed; aborting"
1169                fi
1170                test_at_end_hook_
1171
1172                exit 0 ;;
1173
1174        *)
1175                if test $test_external_has_tap -eq 0
1176                then
1177                        say_color error "# failed $test_failure among $msg"
1178                        say "1..$test_count"
1179                fi
1180
1181                exit 1 ;;
1182
1183        esac
1184}
1185
1186if test -n "$valgrind"
1187then
1188        make_symlink () {
1189                test -h "$2" &&
1190                test "$1" = "$(readlink "$2")" || {
1191                        # be super paranoid
1192                        if mkdir "$2".lock
1193                        then
1194                                rm -f "$2" &&
1195                                ln -s "$1" "$2" &&
1196                                rm -r "$2".lock
1197                        else
1198                                while test -d "$2".lock
1199                                do
1200                                        say "Waiting for lock on $2."
1201                                        sleep 1
1202                                done
1203                        fi
1204                }
1205        }
1206
1207        make_valgrind_symlink () {
1208                # handle only executables, unless they are shell libraries that
1209                # need to be in the exec-path.
1210                test -x "$1" ||
1211                test "# " = "$(test_copy_bytes 2 <"$1")" ||
1212                return;
1213
1214                base=$(basename "$1")
1215                case "$base" in
1216                test-*)
1217                        symlink_target="$GIT_BUILD_DIR/t/helper/$base"
1218                        ;;
1219                *)
1220                        symlink_target="$GIT_BUILD_DIR/$base"
1221                        ;;
1222                esac
1223                # do not override scripts
1224                if test -x "$symlink_target" &&
1225                    test ! -d "$symlink_target" &&
1226                    test "#!" != "$(test_copy_bytes 2 <"$symlink_target")"
1227                then
1228                        symlink_target=../valgrind.sh
1229                fi
1230                case "$base" in
1231                *.sh|*.perl)
1232                        symlink_target=../unprocessed-script
1233                esac
1234                # create the link, or replace it if it is out of date
1235                make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit
1236        }
1237
1238        # override all git executables in TEST_DIRECTORY/..
1239        GIT_VALGRIND=$TEST_DIRECTORY/valgrind
1240        mkdir -p "$GIT_VALGRIND"/bin
1241        for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/t/helper/test-*
1242        do
1243                make_valgrind_symlink $file
1244        done
1245        # special-case the mergetools loadables
1246        make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools"
1247        OLDIFS=$IFS
1248        IFS=:
1249        for path in $PATH
1250        do
1251                ls "$path"/git-* 2> /dev/null |
1252                while read file
1253                do
1254                        make_valgrind_symlink "$file"
1255                done
1256        done
1257        IFS=$OLDIFS
1258        PATH=$GIT_VALGRIND/bin:$PATH
1259        GIT_EXEC_PATH=$GIT_VALGRIND/bin
1260        export GIT_VALGRIND
1261        GIT_VALGRIND_MODE="$valgrind"
1262        export GIT_VALGRIND_MODE
1263        GIT_VALGRIND_ENABLED=t
1264        test -n "$valgrind_only" && GIT_VALGRIND_ENABLED=
1265        export GIT_VALGRIND_ENABLED
1266elif test -n "$GIT_TEST_INSTALLED"
1267then
1268        GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path)  ||
1269        error "Cannot run git from $GIT_TEST_INSTALLED."
1270        PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR/t/helper:$PATH
1271        GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH}
1272else # normal case, use ../bin-wrappers only unless $with_dashes:
1273        if test -n "$no_bin_wrappers"
1274        then
1275                with_dashes=t
1276        else
1277                git_bin_dir="$GIT_BUILD_DIR/bin-wrappers"
1278                if ! test -x "$git_bin_dir/git"
1279                then
1280                        if test -z "$with_dashes"
1281                        then
1282                                say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH"
1283                        fi
1284                        with_dashes=t
1285                fi
1286                PATH="$git_bin_dir:$PATH"
1287        fi
1288        GIT_EXEC_PATH=$GIT_BUILD_DIR
1289        if test -n "$with_dashes"
1290        then
1291                PATH="$GIT_BUILD_DIR:$GIT_BUILD_DIR/t/helper:$PATH"
1292        fi
1293fi
1294GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt
1295GIT_CONFIG_NOSYSTEM=1
1296GIT_ATTR_NOSYSTEM=1
1297export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM
1298
1299if test -z "$GIT_TEST_CMP"
1300then
1301        if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT"
1302        then
1303                GIT_TEST_CMP="$DIFF -c"
1304        else
1305                GIT_TEST_CMP="$DIFF -u"
1306        fi
1307fi
1308
1309GITPERLLIB="$GIT_BUILD_DIR"/perl/build/lib
1310export GITPERLLIB
1311test -d "$GIT_BUILD_DIR"/templates/blt || {
1312        error "You haven't built things yet, have you?"
1313}
1314
1315if ! test -x "$GIT_BUILD_DIR"/t/helper/test-tool$X
1316then
1317        echo >&2 'You need to build test-tool:'
1318        echo >&2 'Run "make t/helper/test-tool" in the source (toplevel) directory'
1319        exit 1
1320fi
1321
1322# Test repository
1323rm -fr "$TRASH_DIRECTORY" || {
1324        GIT_EXIT_OK=t
1325        echo >&5 "FATAL: Cannot prepare test area"
1326        exit 1
1327}
1328
1329HOME="$TRASH_DIRECTORY"
1330GNUPGHOME="$HOME/gnupg-home-not-used"
1331export HOME GNUPGHOME
1332
1333if test -z "$TEST_NO_CREATE_REPO"
1334then
1335        test_create_repo "$TRASH_DIRECTORY"
1336else
1337        mkdir -p "$TRASH_DIRECTORY"
1338fi
1339
1340# Use -P to resolve symlinks in our working directory so that the cwd
1341# in subprocesses like git equals our $PWD (for pathname comparisons).
1342cd -P "$TRASH_DIRECTORY" || exit 1
1343
1344this_test=${0##*/}
1345this_test=${this_test%%-*}
1346if match_pattern_list "$this_test" $GIT_SKIP_TESTS
1347then
1348        say_color info >&3 "skipping test $this_test altogether"
1349        skip_all="skip all tests in $this_test"
1350        test_done
1351fi
1352
1353if test -n "$write_junit_xml"
1354then
1355        junit_xml_dir="$TEST_OUTPUT_DIRECTORY/out"
1356        mkdir -p "$junit_xml_dir"
1357        junit_xml_base=${0##*/}
1358        junit_xml_path="$junit_xml_dir/TEST-${junit_xml_base%.sh}.xml"
1359        junit_attrs="name=\"${junit_xml_base%.sh}\""
1360        junit_attrs="$junit_attrs timestamp=\"$(TZ=UTC \
1361                date +%Y-%m-%dT%H:%M:%S)\""
1362        write_junit_xml --truncate "<testsuites>" "  <testsuite $junit_attrs>"
1363        junit_suite_start=$(test-tool date getnanos)
1364        if test -n "$GIT_TEST_TEE_OUTPUT_FILE"
1365        then
1366                GIT_TEST_TEE_OFFSET=0
1367        fi
1368fi
1369
1370# Provide an implementation of the 'yes' utility; the upper bound
1371# limit is there to help Windows that cannot stop this loop from
1372# wasting cycles when the downstream stops reading, so do not be
1373# tempted to turn it into an infinite loop. cf. 6129c930 ("test-lib:
1374# limit the output of the yes utility", 2016-02-02)
1375yes () {
1376        if test $# = 0
1377        then
1378                y=y
1379        else
1380                y="$*"
1381        fi
1382
1383        i=0
1384        while test $i -lt 99
1385        do
1386                echo "$y"
1387                i=$(($i+1))
1388        done
1389}
1390
1391# The GIT_TEST_FAIL_PREREQS code hooks into test_set_prereq(), and
1392# thus needs to be set up really early, and set an internal variable
1393# for convenience so the hot test_set_prereq() codepath doesn't need
1394# to call "git env--helper". Only do that work if needed by seeing if
1395# GIT_TEST_FAIL_PREREQS is set at all.
1396GIT_TEST_FAIL_PREREQS_INTERNAL=
1397if test -n "$GIT_TEST_FAIL_PREREQS"
1398then
1399        if git env--helper --type=bool --default=0 --exit-code GIT_TEST_FAIL_PREREQS
1400        then
1401                GIT_TEST_FAIL_PREREQS_INTERNAL=true
1402                test_set_prereq FAIL_PREREQS
1403        fi
1404else
1405        test_lazy_prereq FAIL_PREREQS '
1406                git env--helper --type=bool --default=0 --exit-code GIT_TEST_FAIL_PREREQS
1407        '
1408fi
1409
1410# Fix some commands on Windows
1411uname_s=$(uname -s)
1412case $uname_s in
1413*MINGW*)
1414        # Windows has its own (incompatible) sort and find
1415        sort () {
1416                /usr/bin/sort "$@"
1417        }
1418        find () {
1419                /usr/bin/find "$@"
1420        }
1421        # git sees Windows-style pwd
1422        pwd () {
1423                builtin pwd -W
1424        }
1425        # no POSIX permissions
1426        # backslashes in pathspec are converted to '/'
1427        # exec does not inherit the PID
1428        test_set_prereq MINGW
1429        test_set_prereq NATIVE_CRLF
1430        test_set_prereq SED_STRIPS_CR
1431        test_set_prereq GREP_STRIPS_CR
1432        GIT_TEST_CMP=mingw_test_cmp
1433        ;;
1434*CYGWIN*)
1435        test_set_prereq POSIXPERM
1436        test_set_prereq EXECKEEPSPID
1437        test_set_prereq CYGWIN
1438        test_set_prereq SED_STRIPS_CR
1439        test_set_prereq GREP_STRIPS_CR
1440        ;;
1441*)
1442        test_set_prereq POSIXPERM
1443        test_set_prereq BSLASHPSPEC
1444        test_set_prereq EXECKEEPSPID
1445        ;;
1446esac
1447
1448( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_1
1449test -z "$NO_PERL" && test_set_prereq PERL
1450test -z "$NO_PTHREADS" && test_set_prereq PTHREADS
1451test -z "$NO_PYTHON" && test_set_prereq PYTHON
1452test -n "$USE_LIBPCRE1$USE_LIBPCRE2" && test_set_prereq PCRE
1453test -n "$USE_LIBPCRE1" && test_set_prereq LIBPCRE1
1454test -n "$USE_LIBPCRE2" && test_set_prereq LIBPCRE2
1455test -z "$NO_GETTEXT" && test_set_prereq GETTEXT
1456
1457if test -n "$GIT_TEST_GETTEXT_POISON_ORIG"
1458then
1459        GIT_TEST_GETTEXT_POISON=$GIT_TEST_GETTEXT_POISON_ORIG
1460        export GIT_TEST_GETTEXT_POISON
1461        unset GIT_TEST_GETTEXT_POISON_ORIG
1462fi
1463
1464test_lazy_prereq C_LOCALE_OUTPUT '
1465        ! git env--helper --type=bool --default=0 --exit-code GIT_TEST_GETTEXT_POISON
1466'
1467
1468if test -z "$GIT_TEST_CHECK_CACHE_TREE"
1469then
1470        GIT_TEST_CHECK_CACHE_TREE=true
1471        export GIT_TEST_CHECK_CACHE_TREE
1472fi
1473
1474test_lazy_prereq PIPE '
1475        # test whether the filesystem supports FIFOs
1476        test_have_prereq !MINGW,!CYGWIN &&
1477        rm -f testfifo && mkfifo testfifo
1478'
1479
1480test_lazy_prereq SYMLINKS '
1481        # test whether the filesystem supports symbolic links
1482        ln -s x y && test -h y
1483'
1484
1485test_lazy_prereq FILEMODE '
1486        test "$(git config --bool core.filemode)" = true
1487'
1488
1489test_lazy_prereq CASE_INSENSITIVE_FS '
1490        echo good >CamelCase &&
1491        echo bad >camelcase &&
1492        test "$(cat CamelCase)" != good
1493'
1494
1495test_lazy_prereq FUNNYNAMES '
1496        test_have_prereq !MINGW &&
1497        touch -- \
1498                "FUNNYNAMES tab embedded" \
1499                "FUNNYNAMES \"quote embedded\"" \
1500                "FUNNYNAMES newline
1501embedded" 2>/dev/null &&
1502        rm -- \
1503                "FUNNYNAMES tab embedded" \
1504                "FUNNYNAMES \"quote embedded\"" \
1505                "FUNNYNAMES newline
1506embedded" 2>/dev/null
1507'
1508
1509test_lazy_prereq UTF8_NFD_TO_NFC '
1510        # check whether FS converts nfd unicode to nfc
1511        auml=$(printf "\303\244")
1512        aumlcdiar=$(printf "\141\314\210")
1513        >"$auml" &&
1514        test -f "$aumlcdiar"
1515'
1516
1517test_lazy_prereq AUTOIDENT '
1518        sane_unset GIT_AUTHOR_NAME &&
1519        sane_unset GIT_AUTHOR_EMAIL &&
1520        git var GIT_AUTHOR_IDENT
1521'
1522
1523test_lazy_prereq EXPENSIVE '
1524        test -n "$GIT_TEST_LONG"
1525'
1526
1527test_lazy_prereq EXPENSIVE_ON_WINDOWS '
1528        test_have_prereq EXPENSIVE || test_have_prereq !MINGW,!CYGWIN
1529'
1530
1531test_lazy_prereq USR_BIN_TIME '
1532        test -x /usr/bin/time
1533'
1534
1535test_lazy_prereq NOT_ROOT '
1536        uid=$(id -u) &&
1537        test "$uid" != 0
1538'
1539
1540test_lazy_prereq JGIT '
1541        jgit --version
1542'
1543
1544# SANITY is about "can you correctly predict what the filesystem would
1545# do by only looking at the permission bits of the files and
1546# directories?"  A typical example of !SANITY is running the test
1547# suite as root, where a test may expect "chmod -r file && cat file"
1548# to fail because file is supposed to be unreadable after a successful
1549# chmod.  In an environment (i.e. combination of what filesystem is
1550# being used and who is running the tests) that lacks SANITY, you may
1551# be able to delete or create a file when the containing directory
1552# doesn't have write permissions, or access a file even if the
1553# containing directory doesn't have read or execute permissions.
1554
1555test_lazy_prereq SANITY '
1556        mkdir SANETESTD.1 SANETESTD.2 &&
1557
1558        chmod +w SANETESTD.1 SANETESTD.2 &&
1559        >SANETESTD.1/x 2>SANETESTD.2/x &&
1560        chmod -w SANETESTD.1 &&
1561        chmod -r SANETESTD.1/x &&
1562        chmod -rx SANETESTD.2 ||
1563        BUG "cannot prepare SANETESTD"
1564
1565        ! test -r SANETESTD.1/x &&
1566        ! rm SANETESTD.1/x && ! test -f SANETESTD.2/x
1567        status=$?
1568
1569        chmod +rwx SANETESTD.1 SANETESTD.2 &&
1570        rm -rf SANETESTD.1 SANETESTD.2 ||
1571        BUG "cannot clean SANETESTD"
1572        return $status
1573'
1574
1575test FreeBSD != $uname_s || GIT_UNZIP=${GIT_UNZIP:-/usr/local/bin/unzip}
1576GIT_UNZIP=${GIT_UNZIP:-unzip}
1577test_lazy_prereq UNZIP '
1578        "$GIT_UNZIP" -v
1579        test $? -ne 127
1580'
1581
1582run_with_limited_cmdline () {
1583        (ulimit -s 128 && "$@")
1584}
1585
1586test_lazy_prereq CMDLINE_LIMIT '
1587        test_have_prereq !MINGW,!CYGWIN &&
1588        run_with_limited_cmdline true
1589'
1590
1591run_with_limited_stack () {
1592        (ulimit -s 128 && "$@")
1593}
1594
1595test_lazy_prereq ULIMIT_STACK_SIZE '
1596        test_have_prereq !MINGW,!CYGWIN &&
1597        run_with_limited_stack true
1598'
1599
1600build_option () {
1601        git version --build-options |
1602        sed -ne "s/^$1: //p"
1603}
1604
1605test_lazy_prereq LONG_IS_64BIT '
1606        test 8 -le "$(build_option sizeof-long)"
1607'
1608
1609test_lazy_prereq TIME_IS_64BIT 'test-tool date is64bit'
1610test_lazy_prereq TIME_T_IS_64BIT 'test-tool date time_t-is64bit'
1611
1612test_lazy_prereq CURL '
1613        curl --version
1614'
1615
1616# SHA1 is a test if the hash algorithm in use is SHA-1.  This is both for tests
1617# which will not work with other hash algorithms and tests that work but don't
1618# test anything meaningful (e.g. special values which cause short collisions).
1619test_lazy_prereq SHA1 '
1620        test $(git hash-object /dev/null) = e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
1621'
1622
1623test_lazy_prereq REBASE_P '
1624        test -z "$GIT_TEST_SKIP_REBASE_P"
1625'