Andrew's git / gitweb.git / t/test-lib.sh
?
t / test-lib.shon commit wrap-for-bin: make bin-wrappers chainable (8bade1e)
   1#!/bin/sh
   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# Keep the original TERM for say_color
  19ORIGINAL_TERM=$TERM
  20
  21# Test the binaries we have just built.  The tests are kept in
  22# t/ subdirectory and are run in 'trash directory' subdirectory.
  23if test -z "$TEST_DIRECTORY"
  24then
  25        # We allow tests to override this, in case they want to run tests
  26        # outside of t/, e.g. for running tests on the test library
  27        # itself.
  28        TEST_DIRECTORY=$(pwd)
  29fi
  30if test -z "$TEST_OUTPUT_DIRECTORY"
  31then
  32        # Similarly, override this to store the test-results subdir
  33        # elsewhere
  34        TEST_OUTPUT_DIRECTORY=$TEST_DIRECTORY
  35fi
  36GIT_BUILD_DIR="$TEST_DIRECTORY"/..
  37
  38################################################################
  39# It appears that people try to run tests without building...
  40"$GIT_BUILD_DIR/git" >/dev/null
  41if test $? != 1
  42then
  43        echo >&2 'error: you do not seem to have built git yet.'
  44        exit 1
  45fi
  46
  47. "$GIT_BUILD_DIR"/GIT-BUILD-OPTIONS
  48export PERL_PATH SHELL_PATH
  49
  50# if --tee was passed, write the output not only to the terminal, but
  51# additionally to the file test-results/$BASENAME.out, too.
  52case "$GIT_TEST_TEE_STARTED, $* " in
  53done,*)
  54        # do not redirect again
  55        ;;
  56*' --tee '*|*' --va'*)
  57        mkdir -p "$TEST_OUTPUT_DIRECTORY/test-results"
  58        BASE="$TEST_OUTPUT_DIRECTORY/test-results/$(basename "$0" .sh)"
  59        (GIT_TEST_TEE_STARTED=done ${SHELL_PATH} "$0" "$@" 2>&1;
  60         echo $? > $BASE.exit) | tee $BASE.out
  61        test "$(cat $BASE.exit)" = 0
  62        exit
  63        ;;
  64esac
  65
  66# For repeatability, reset the environment to known value.
  67LANG=C
  68LC_ALL=C
  69PAGER=cat
  70TZ=UTC
  71TERM=dumb
  72export LANG LC_ALL PAGER TERM TZ
  73EDITOR=:
  74# A call to "unset" with no arguments causes at least Solaris 10
  75# /usr/xpg4/bin/sh and /bin/ksh to bail out.  So keep the unsets
  76# deriving from the command substitution clustered with the other
  77# ones.
  78unset VISUAL EMAIL LANGUAGE COLUMNS $("$PERL_PATH" -e '
  79        my @env = keys %ENV;
  80        my $ok = join("|", qw(
  81                TRACE
  82                DEBUG
  83                USE_LOOKUP
  84                TEST
  85                .*_TEST
  86                PROVE
  87                VALGRIND
  88                UNZIP
  89                PERF_
  90        ));
  91        my @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env);
  92        print join("\n", @vars);
  93')
  94unset XDG_CONFIG_HOME
  95unset GITPERLLIB
  96GIT_AUTHOR_EMAIL=author@example.com
  97GIT_AUTHOR_NAME='A U Thor'
  98GIT_COMMITTER_EMAIL=committer@example.com
  99GIT_COMMITTER_NAME='C O Mitter'
 100GIT_MERGE_VERBOSITY=5
 101GIT_MERGE_AUTOEDIT=no
 102export GIT_MERGE_VERBOSITY GIT_MERGE_AUTOEDIT
 103export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME
 104export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME
 105export EDITOR
 106
 107# Add libc MALLOC and MALLOC_PERTURB test
 108# only if we are not executing the test with valgrind
 109if expr " $GIT_TEST_OPTS " : ".* --valgrind " >/dev/null ||
 110   test -n "$TEST_NO_MALLOC_CHECK"
 111then
 112        setup_malloc_check () {
 113                : nothing
 114        }
 115        teardown_malloc_check () {
 116                : nothing
 117        }
 118else
 119        setup_malloc_check () {
 120                MALLOC_CHECK_=3 MALLOC_PERTURB_=165
 121                export MALLOC_CHECK_ MALLOC_PERTURB_
 122        }
 123        teardown_malloc_check () {
 124                unset MALLOC_CHECK_ MALLOC_PERTURB_
 125        }
 126fi
 127
 128# Protect ourselves from common misconfiguration to export
 129# CDPATH into the environment
 130unset CDPATH
 131
 132unset GREP_OPTIONS
 133unset UNZIP
 134
 135case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in
 1361|2|true)
 137        echo "* warning: Some tests will not work if GIT_TRACE" \
 138                "is set as to trace on STDERR ! *"
 139        echo "* warning: Please set GIT_TRACE to something" \
 140                "other than 1, 2 or true ! *"
 141        ;;
 142esac
 143
 144# Convenience
 145#
 146# A regexp to match 5 and 40 hexdigits
 147_x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
 148_x40="$_x05$_x05$_x05$_x05$_x05$_x05$_x05$_x05"
 149
 150# Zero SHA-1
 151_z40=0000000000000000000000000000000000000000
 152
 153# Line feed
 154LF='
 155'
 156
 157export _x05 _x40 _z40 LF
 158
 159# Each test should start with something like this, after copyright notices:
 160#
 161# test_description='Description of this test...
 162# This test checks if command xyzzy does the right thing...
 163# '
 164# . ./test-lib.sh
 165[ "x$ORIGINAL_TERM" != "xdumb" ] && (
 166                TERM=$ORIGINAL_TERM &&
 167                export TERM &&
 168                [ -t 1 ] &&
 169                tput bold >/dev/null 2>&1 &&
 170                tput setaf 1 >/dev/null 2>&1 &&
 171                tput sgr0 >/dev/null 2>&1
 172        ) &&
 173        color=t
 174
 175while test "$#" -ne 0
 176do
 177        case "$1" in
 178        -d|--d|--de|--deb|--debu|--debug)
 179                debug=t; shift ;;
 180        -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate)
 181                immediate=t; shift ;;
 182        -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests)
 183                GIT_TEST_LONG=t; export GIT_TEST_LONG; shift ;;
 184        -h|--h|--he|--hel|--help)
 185                help=t; shift ;;
 186        -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose)
 187                verbose=t; shift ;;
 188        -q|--q|--qu|--qui|--quie|--quiet)
 189                # Ignore --quiet under a TAP::Harness. Saying how many tests
 190                # passed without the ok/not ok details is always an error.
 191                test -z "$HARNESS_ACTIVE" && quiet=t; shift ;;
 192        --with-dashes)
 193                with_dashes=t; shift ;;
 194        --no-color)
 195                color=; shift ;;
 196        --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind)
 197                valgrind=memcheck
 198                shift ;;
 199        --valgrind=*)
 200                valgrind=$(expr "z$1" : 'z[^=]*=\(.*\)')
 201                shift ;;
 202        --tee)
 203                shift ;; # was handled already
 204        --root=*)
 205                root=$(expr "z$1" : 'z[^=]*=\(.*\)')
 206                shift ;;
 207        *)
 208                echo "error: unknown test option '$1'" >&2; exit 1 ;;
 209        esac
 210done
 211
 212test -n "$valgrind" && verbose=t
 213
 214if test -n "$color"
 215then
 216        say_color () {
 217                (
 218                TERM=$ORIGINAL_TERM
 219                export TERM
 220                case "$1" in
 221                error)
 222                        tput bold; tput setaf 1;; # bold red
 223                skip)
 224                        tput setaf 4;; # blue
 225                warn)
 226                        tput setaf 3;; # brown/yellow
 227                pass)
 228                        tput setaf 2;; # green
 229                info)
 230                        tput setaf 6;; # cyan
 231                *)
 232                        test -n "$quiet" && return;;
 233                esac
 234                shift
 235                printf "%s" "$*"
 236                tput sgr0
 237                echo
 238                )
 239        }
 240else
 241        say_color() {
 242                test -z "$1" && test -n "$quiet" && return
 243                shift
 244                printf "%s\n" "$*"
 245        }
 246fi
 247
 248error () {
 249        say_color error "error: $*"
 250        GIT_EXIT_OK=t
 251        exit 1
 252}
 253
 254say () {
 255        say_color info "$*"
 256}
 257
 258test "${test_description}" != "" ||
 259error "Test script did not set test_description."
 260
 261if test "$help" = "t"
 262then
 263        echo "$test_description"
 264        exit 0
 265fi
 266
 267exec 5>&1
 268exec 6<&0
 269if test "$verbose" = "t"
 270then
 271        exec 4>&2 3>&1
 272else
 273        exec 4>/dev/null 3>/dev/null
 274fi
 275
 276test_failure=0
 277test_count=0
 278test_fixed=0
 279test_broken=0
 280test_success=0
 281
 282test_external_has_tap=0
 283
 284die () {
 285        code=$?
 286        if test -n "$GIT_EXIT_OK"
 287        then
 288                exit $code
 289        else
 290                echo >&5 "FATAL: Unexpected exit with code $code"
 291                exit 1
 292        fi
 293}
 294
 295GIT_EXIT_OK=
 296trap 'die' EXIT
 297
 298# The user-facing functions are loaded from a separate file so that
 299# test_perf subshells can have them too
 300. "$TEST_DIRECTORY/test-lib-functions.sh"
 301
 302# You are not expected to call test_ok_ and test_failure_ directly, use
 303# the text_expect_* functions instead.
 304
 305test_ok_ () {
 306        test_success=$(($test_success + 1))
 307        say_color "" "ok $test_count - $@"
 308}
 309
 310test_failure_ () {
 311        test_failure=$(($test_failure + 1))
 312        say_color error "not ok $test_count - $1"
 313        shift
 314        echo "$@" | sed -e 's/^/#       /'
 315        test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; }
 316}
 317
 318test_known_broken_ok_ () {
 319        test_fixed=$(($test_fixed+1))
 320        say_color error "ok $test_count - $@ # TODO known breakage vanished"
 321}
 322
 323test_known_broken_failure_ () {
 324        test_broken=$(($test_broken+1))
 325        say_color warn "not ok $test_count - $@ # TODO known breakage"
 326}
 327
 328test_debug () {
 329        test "$debug" = "" || eval "$1"
 330}
 331
 332test_eval_ () {
 333        # This is a separate function because some tests use
 334        # "return" to end a test_expect_success block early.
 335        eval </dev/null >&3 2>&4 "$*"
 336}
 337
 338test_run_ () {
 339        test_cleanup=:
 340        expecting_failure=$2
 341        test_eval_ "$1"
 342        eval_ret=$?
 343
 344        if test -z "$immediate" || test $eval_ret = 0 || test -n "$expecting_failure"
 345        then
 346                setup_malloc_check
 347                test_eval_ "$test_cleanup"
 348                teardown_malloc_check
 349        fi
 350        if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE"
 351        then
 352                echo ""
 353        fi
 354        return "$eval_ret"
 355}
 356
 357test_skip () {
 358        test_count=$(($test_count+1))
 359        to_skip=
 360        for skp in $GIT_SKIP_TESTS
 361        do
 362                case $this_test.$test_count in
 363                $skp)
 364                        to_skip=t
 365                        break
 366                esac
 367        done
 368        if test -z "$to_skip" && test -n "$test_prereq" &&
 369           ! test_have_prereq "$test_prereq"
 370        then
 371                to_skip=t
 372        fi
 373        case "$to_skip" in
 374        t)
 375                of_prereq=
 376                if test "$missing_prereq" != "$test_prereq"
 377                then
 378                        of_prereq=" of $test_prereq"
 379                fi
 380
 381                say_color skip >&3 "skipping test: $@"
 382                say_color skip "ok $test_count # skip $1 (missing $missing_prereq${of_prereq})"
 383                : true
 384                ;;
 385        *)
 386                false
 387                ;;
 388        esac
 389}
 390
 391# stub; perf-lib overrides it
 392test_at_end_hook_ () {
 393        :
 394}
 395
 396test_done () {
 397        GIT_EXIT_OK=t
 398
 399        if test -z "$HARNESS_ACTIVE"
 400        then
 401                test_results_dir="$TEST_OUTPUT_DIRECTORY/test-results"
 402                mkdir -p "$test_results_dir"
 403                base=${0##*/}
 404                test_results_path="$test_results_dir/${base%.sh}-$$.counts"
 405
 406                cat >>"$test_results_path" <<-EOF
 407                total $test_count
 408                success $test_success
 409                fixed $test_fixed
 410                broken $test_broken
 411                failed $test_failure
 412
 413                EOF
 414        fi
 415
 416        if test "$test_fixed" != 0
 417        then
 418                say_color error "# $test_fixed known breakage(s) vanished; please update test(s)"
 419        fi
 420        if test "$test_broken" != 0
 421        then
 422                say_color warn "# still have $test_broken known breakage(s)"
 423        fi
 424        if test "$test_broken" != 0 || test "$test_fixed" != 0
 425        then
 426                test_remaining=$(( $test_count - $test_broken - $test_fixed ))
 427                msg="remaining $test_remaining test(s)"
 428        else
 429                test_remaining=$test_count
 430                msg="$test_count test(s)"
 431        fi
 432        case "$test_failure" in
 433        0)
 434                # Maybe print SKIP message
 435                if test -n "$skip_all" && test $test_count -gt 0
 436                then
 437                        error "Can't use skip_all after running some tests"
 438                fi
 439                [ -z "$skip_all" ] || skip_all=" # SKIP $skip_all"
 440
 441                if test $test_external_has_tap -eq 0
 442                then
 443                        if test $test_remaining -gt 0
 444                        then
 445                                say_color pass "# passed all $msg"
 446                        fi
 447                        say "1..$test_count$skip_all"
 448                fi
 449
 450                test -d "$remove_trash" &&
 451                cd "$(dirname "$remove_trash")" &&
 452                rm -rf "$(basename "$remove_trash")"
 453
 454                test_at_end_hook_
 455
 456                exit 0 ;;
 457
 458        *)
 459                if test $test_external_has_tap -eq 0
 460                then
 461                        say_color error "# failed $test_failure among $msg"
 462                        say "1..$test_count"
 463                fi
 464
 465                exit 1 ;;
 466
 467        esac
 468}
 469
 470if test -n "$valgrind"
 471then
 472        make_symlink () {
 473                test -h "$2" &&
 474                test "$1" = "$(readlink "$2")" || {
 475                        # be super paranoid
 476                        if mkdir "$2".lock
 477                        then
 478                                rm -f "$2" &&
 479                                ln -s "$1" "$2" &&
 480                                rm -r "$2".lock
 481                        else
 482                                while test -d "$2".lock
 483                                do
 484                                        say "Waiting for lock on $2."
 485                                        sleep 1
 486                                done
 487                        fi
 488                }
 489        }
 490
 491        make_valgrind_symlink () {
 492                # handle only executables, unless they are shell libraries that
 493                # need to be in the exec-path.  We will just use "#!" as a
 494                # guess for a shell-script, since we have no idea what the user
 495                # may have configured as the shell path.
 496                test -x "$1" ||
 497                test "#!" = "$(head -c 2 <"$1")" ||
 498                return;
 499
 500                base=$(basename "$1")
 501                symlink_target=$GIT_BUILD_DIR/$base
 502                # do not override scripts
 503                if test -x "$symlink_target" &&
 504                    test ! -d "$symlink_target" &&
 505                    test "#!" != "$(head -c 2 < "$symlink_target")"
 506                then
 507                        symlink_target=../valgrind.sh
 508                fi
 509                case "$base" in
 510                *.sh|*.perl)
 511                        symlink_target=../unprocessed-script
 512                esac
 513                # create the link, or replace it if it is out of date
 514                make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit
 515        }
 516
 517        # override all git executables in TEST_DIRECTORY/..
 518        GIT_VALGRIND=$TEST_DIRECTORY/valgrind
 519        mkdir -p "$GIT_VALGRIND"/bin
 520        for file in $GIT_BUILD_DIR/git* $GIT_BUILD_DIR/test-*
 521        do
 522                make_valgrind_symlink $file
 523        done
 524        # special-case the mergetools loadables
 525        make_symlink "$GIT_BUILD_DIR"/mergetools "$GIT_VALGRIND/bin/mergetools"
 526        OLDIFS=$IFS
 527        IFS=:
 528        for path in $PATH
 529        do
 530                ls "$path"/git-* 2> /dev/null |
 531                while read file
 532                do
 533                        make_valgrind_symlink "$file"
 534                done
 535        done
 536        IFS=$OLDIFS
 537        PATH=$GIT_VALGRIND/bin:$PATH
 538        GIT_EXEC_PATH=$GIT_VALGRIND/bin
 539        export GIT_VALGRIND
 540        GIT_VALGRIND_MODE="$valgrind"
 541        export GIT_VALGRIND_MODE
 542elif test -n "$GIT_TEST_INSTALLED"
 543then
 544        GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path)  ||
 545        error "Cannot run git from $GIT_TEST_INSTALLED."
 546        PATH=$GIT_TEST_INSTALLED:$GIT_BUILD_DIR:$PATH
 547        GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH}
 548else # normal case, use ../bin-wrappers only unless $with_dashes:
 549        git_bin_dir="$GIT_BUILD_DIR/bin-wrappers"
 550        if ! test -x "$git_bin_dir/git"
 551        then
 552                if test -z "$with_dashes"
 553                then
 554                        say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH"
 555                fi
 556                with_dashes=t
 557        fi
 558        PATH="$git_bin_dir:$PATH"
 559        GIT_EXEC_PATH=$GIT_BUILD_DIR
 560        if test -n "$with_dashes"
 561        then
 562                PATH="$GIT_BUILD_DIR:$PATH"
 563        fi
 564fi
 565GIT_TEMPLATE_DIR="$GIT_BUILD_DIR"/templates/blt
 566unset GIT_CONFIG
 567GIT_CONFIG_NOSYSTEM=1
 568GIT_ATTR_NOSYSTEM=1
 569export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_ATTR_NOSYSTEM
 570
 571if test -z "$GIT_TEST_CMP"
 572then
 573        if test -n "$GIT_TEST_CMP_USE_COPIED_CONTEXT"
 574        then
 575                GIT_TEST_CMP="$DIFF -c"
 576        else
 577                GIT_TEST_CMP="$DIFF -u"
 578        fi
 579fi
 580
 581GITPERLLIB="$GIT_BUILD_DIR"/perl/blib/lib:"$GIT_BUILD_DIR"/perl/blib/arch/auto/Git
 582export GITPERLLIB
 583test -d "$GIT_BUILD_DIR"/templates/blt || {
 584        error "You haven't built things yet, have you?"
 585}
 586
 587if test -z "$GIT_TEST_INSTALLED" && test -z "$NO_PYTHON"
 588then
 589        GITPYTHONLIB="$GIT_BUILD_DIR/git_remote_helpers/build/lib"
 590        export GITPYTHONLIB
 591        test -d "$GIT_BUILD_DIR"/git_remote_helpers/build || {
 592                error "You haven't built git_remote_helpers yet, have you?"
 593        }
 594fi
 595
 596if ! test -x "$GIT_BUILD_DIR"/test-chmtime
 597then
 598        echo >&2 'You need to build test-chmtime:'
 599        echo >&2 'Run "make test-chmtime" in the source (toplevel) directory'
 600        exit 1
 601fi
 602
 603# Test repository
 604TRASH_DIRECTORY="trash directory.$(basename "$0" .sh)"
 605test -n "$root" && TRASH_DIRECTORY="$root/$TRASH_DIRECTORY"
 606case "$TRASH_DIRECTORY" in
 607/*) ;; # absolute path is good
 608 *) TRASH_DIRECTORY="$TEST_OUTPUT_DIRECTORY/$TRASH_DIRECTORY" ;;
 609esac
 610test ! -z "$debug" || remove_trash=$TRASH_DIRECTORY
 611rm -fr "$TRASH_DIRECTORY" || {
 612        GIT_EXIT_OK=t
 613        echo >&5 "FATAL: Cannot prepare test area"
 614        exit 1
 615}
 616
 617HOME="$TRASH_DIRECTORY"
 618export HOME
 619
 620if test -z "$TEST_NO_CREATE_REPO"
 621then
 622        test_create_repo "$TRASH_DIRECTORY"
 623else
 624        mkdir -p "$TRASH_DIRECTORY"
 625fi
 626# Use -P to resolve symlinks in our working directory so that the cwd
 627# in subprocesses like git equals our $PWD (for pathname comparisons).
 628cd -P "$TRASH_DIRECTORY" || exit 1
 629
 630this_test=${0##*/}
 631this_test=${this_test%%-*}
 632for skp in $GIT_SKIP_TESTS
 633do
 634        case "$this_test" in
 635        $skp)
 636                say_color info >&3 "skipping test $this_test altogether"
 637                skip_all="skip all tests in $this_test"
 638                test_done
 639        esac
 640done
 641
 642# Provide an implementation of the 'yes' utility
 643yes () {
 644        if test $# = 0
 645        then
 646                y=y
 647        else
 648                y="$*"
 649        fi
 650
 651        while echo "$y"
 652        do
 653                :
 654        done
 655}
 656
 657# Fix some commands on Windows
 658case $(uname -s) in
 659*MINGW*)
 660        # Windows has its own (incompatible) sort and find
 661        sort () {
 662                /usr/bin/sort "$@"
 663        }
 664        find () {
 665                /usr/bin/find "$@"
 666        }
 667        sum () {
 668                md5sum "$@"
 669        }
 670        # git sees Windows-style pwd
 671        pwd () {
 672                builtin pwd -W
 673        }
 674        # no POSIX permissions
 675        # backslashes in pathspec are converted to '/'
 676        # exec does not inherit the PID
 677        test_set_prereq MINGW
 678        test_set_prereq NOT_CYGWIN
 679        test_set_prereq SED_STRIPS_CR
 680        ;;
 681*CYGWIN*)
 682        test_set_prereq POSIXPERM
 683        test_set_prereq EXECKEEPSPID
 684        test_set_prereq NOT_MINGW
 685        test_set_prereq CYGWIN
 686        test_set_prereq SED_STRIPS_CR
 687        ;;
 688*)
 689        test_set_prereq POSIXPERM
 690        test_set_prereq BSLASHPSPEC
 691        test_set_prereq EXECKEEPSPID
 692        test_set_prereq NOT_MINGW
 693        test_set_prereq NOT_CYGWIN
 694        ;;
 695esac
 696
 697( COLUMNS=1 && test $COLUMNS = 1 ) && test_set_prereq COLUMNS_CAN_BE_1
 698test -z "$NO_PERL" && test_set_prereq PERL
 699test -z "$NO_PYTHON" && test_set_prereq PYTHON
 700test -n "$USE_LIBPCRE" && test_set_prereq LIBPCRE
 701test -z "$NO_GETTEXT" && test_set_prereq GETTEXT
 702
 703# Can we rely on git's output in the C locale?
 704if test -n "$GETTEXT_POISON"
 705then
 706        GIT_GETTEXT_POISON=YesPlease
 707        export GIT_GETTEXT_POISON
 708        test_set_prereq GETTEXT_POISON
 709else
 710        test_set_prereq C_LOCALE_OUTPUT
 711fi
 712
 713# Use this instead of test_cmp to compare files that contain expected and
 714# actual output from git commands that can be translated.  When running
 715# under GETTEXT_POISON this pretends that the command produced expected
 716# results.
 717test_i18ncmp () {
 718        test -n "$GETTEXT_POISON" || test_cmp "$@"
 719}
 720
 721# Use this instead of "grep expected-string actual" to see if the
 722# output from a git command that can be translated either contains an
 723# expected string, or does not contain an unwanted one.  When running
 724# under GETTEXT_POISON this pretends that the command produced expected
 725# results.
 726test_i18ngrep () {
 727        if test -n "$GETTEXT_POISON"
 728        then
 729            : # pretend success
 730        elif test "x!" = "x$1"
 731        then
 732                shift
 733                ! grep "$@"
 734        else
 735                grep "$@"
 736        fi
 737}
 738
 739test_lazy_prereq PIPE '
 740        # test whether the filesystem supports FIFOs
 741        rm -f testfifo && mkfifo testfifo
 742'
 743
 744test_lazy_prereq SYMLINKS '
 745        # test whether the filesystem supports symbolic links
 746        ln -s x y && test -h y
 747'
 748
 749test_lazy_prereq CASE_INSENSITIVE_FS '
 750        echo good >CamelCase &&
 751        echo bad >camelcase &&
 752        test "$(cat CamelCase)" != good
 753'
 754
 755test_lazy_prereq UTF8_NFD_TO_NFC '
 756        # check whether FS converts nfd unicode to nfc
 757        auml=$(printf "\303\244")
 758        aumlcdiar=$(printf "\141\314\210")
 759        >"$auml" &&
 760        case "$(echo *)" in
 761        "$aumlcdiar")
 762                true ;;
 763        *)
 764                false ;;
 765        esac
 766'
 767
 768test_lazy_prereq AUTOIDENT '
 769        sane_unset GIT_AUTHOR_NAME &&
 770        sane_unset GIT_AUTHOR_EMAIL &&
 771        git var GIT_AUTHOR_IDENT
 772'
 773
 774# When the tests are run as root, permission tests will report that
 775# things are writable when they shouldn't be.
 776test -w / || test_set_prereq SANITY
 777
 778GIT_UNZIP=${GIT_UNZIP:-unzip}
 779test_lazy_prereq UNZIP '
 780        "$GIT_UNZIP" -v
 781        test $? -ne 127
 782'