Merge git://git.kernel.org/pub/scm/gitk/gitk
[git] / t / test-lib.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2005 Junio C Hamano
4 #
5
6 # if --tee was passed, write the output not only to the terminal, but
7 # additionally to the file test-results/$BASENAME.out, too.
8 case "$GIT_TEST_TEE_STARTED, $* " in
9 done,*)
10         # do not redirect again
11         ;;
12 *' --tee '*|*' --va'*)
13         mkdir -p test-results
14         BASE=test-results/$(basename "$0" .sh)
15         (GIT_TEST_TEE_STARTED=done ${SHELL-sh} "$0" "$@" 2>&1;
16          echo $? > $BASE.exit) | tee $BASE.out
17         test "$(cat $BASE.exit)" = 0
18         exit
19         ;;
20 esac
21
22 # Keep the original TERM for say_color
23 ORIGINAL_TERM=$TERM
24
25 # For repeatability, reset the environment to known value.
26 LANG=C
27 LC_ALL=C
28 PAGER=cat
29 TZ=UTC
30 TERM=dumb
31 export LANG LC_ALL PAGER TERM TZ
32 EDITOR=:
33 unset VISUAL
34 unset GIT_EDITOR
35 unset AUTHOR_DATE
36 unset AUTHOR_EMAIL
37 unset AUTHOR_NAME
38 unset COMMIT_AUTHOR_EMAIL
39 unset COMMIT_AUTHOR_NAME
40 unset EMAIL
41 unset GIT_ALTERNATE_OBJECT_DIRECTORIES
42 unset GIT_AUTHOR_DATE
43 GIT_AUTHOR_EMAIL=author@example.com
44 GIT_AUTHOR_NAME='A U Thor'
45 unset GIT_COMMITTER_DATE
46 GIT_COMMITTER_EMAIL=committer@example.com
47 GIT_COMMITTER_NAME='C O Mitter'
48 unset GIT_DIFF_OPTS
49 unset GIT_DIR
50 unset GIT_WORK_TREE
51 unset GIT_EXTERNAL_DIFF
52 unset GIT_INDEX_FILE
53 unset GIT_OBJECT_DIRECTORY
54 unset GIT_CEILING_DIRECTORIES
55 unset SHA1_FILE_DIRECTORIES
56 unset SHA1_FILE_DIRECTORY
57 unset GIT_NOTES_REF
58 unset GIT_NOTES_DISPLAY_REF
59 unset GIT_NOTES_REWRITE_REF
60 unset GIT_NOTES_REWRITE_MODE
61 GIT_MERGE_VERBOSITY=5
62 export GIT_MERGE_VERBOSITY
63 export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME
64 export GIT_COMMITTER_EMAIL GIT_COMMITTER_NAME
65 export EDITOR
66 GIT_TEST_CMP=${GIT_TEST_CMP:-diff -u}
67
68 # Protect ourselves from common misconfiguration to export
69 # CDPATH into the environment
70 unset CDPATH
71
72 unset GREP_OPTIONS
73
74 case $(echo $GIT_TRACE |tr "[A-Z]" "[a-z]") in
75         1|2|true)
76                 echo "* warning: Some tests will not work if GIT_TRACE" \
77                         "is set as to trace on STDERR ! *"
78                 echo "* warning: Please set GIT_TRACE to something" \
79                         "other than 1, 2 or true ! *"
80                 ;;
81 esac
82
83 # Convenience
84 #
85 # A regexp to match 5 and 40 hexdigits
86 _x05='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
87 _x40="$_x05$_x05$_x05$_x05$_x05$_x05$_x05$_x05"
88
89 # Each test should start with something like this, after copyright notices:
90 #
91 # test_description='Description of this test...
92 # This test checks if command xyzzy does the right thing...
93 # '
94 # . ./test-lib.sh
95 [ "x$ORIGINAL_TERM" != "xdumb" ] && (
96                 TERM=$ORIGINAL_TERM &&
97                 export TERM &&
98                 [ -t 1 ] &&
99                 tput bold >/dev/null 2>&1 &&
100                 tput setaf 1 >/dev/null 2>&1 &&
101                 tput sgr0 >/dev/null 2>&1
102         ) &&
103         color=t
104
105 while test "$#" -ne 0
106 do
107         case "$1" in
108         -d|--d|--de|--deb|--debu|--debug)
109                 debug=t; shift ;;
110         -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate)
111                 immediate=t; shift ;;
112         -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests)
113                 GIT_TEST_LONG=t; export GIT_TEST_LONG; shift ;;
114         -h|--h|--he|--hel|--help)
115                 help=t; shift ;;
116         -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose)
117                 verbose=t; shift ;;
118         -q|--q|--qu|--qui|--quie|--quiet)
119                 quiet=t; shift ;;
120         --with-dashes)
121                 with_dashes=t; shift ;;
122         --no-color)
123                 color=; shift ;;
124         --no-python)
125                 # noop now...
126                 shift ;;
127         --va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind)
128                 valgrind=t; verbose=t; shift ;;
129         --tee)
130                 shift ;; # was handled already
131         --root=*)
132                 root=$(expr "z$1" : 'z[^=]*=\(.*\)')
133                 shift ;;
134         *)
135                 echo "error: unknown test option '$1'" >&2; exit 1 ;;
136         esac
137 done
138
139 if test -n "$color"; then
140         say_color () {
141                 (
142                 TERM=$ORIGINAL_TERM
143                 export TERM
144                 case "$1" in
145                         error) tput bold; tput setaf 1;; # bold red
146                         skip)  tput bold; tput setaf 2;; # bold green
147                         pass)  tput setaf 2;;            # green
148                         info)  tput setaf 3;;            # brown
149                         *) test -n "$quiet" && return;;
150                 esac
151                 shift
152                 printf "* %s" "$*"
153                 tput sgr0
154                 echo
155                 )
156         }
157 else
158         say_color() {
159                 test -z "$1" && test -n "$quiet" && return
160                 shift
161                 echo "* $*"
162         }
163 fi
164
165 error () {
166         say_color error "error: $*"
167         GIT_EXIT_OK=t
168         exit 1
169 }
170
171 say () {
172         say_color info "$*"
173 }
174
175 test "${test_description}" != "" ||
176 error "Test script did not set test_description."
177
178 if test "$help" = "t"
179 then
180         echo "$test_description"
181         exit 0
182 fi
183
184 exec 5>&1
185 if test "$verbose" = "t"
186 then
187         exec 4>&2 3>&1
188 else
189         exec 4>/dev/null 3>/dev/null
190 fi
191
192 test_failure=0
193 test_count=0
194 test_fixed=0
195 test_broken=0
196 test_success=0
197
198 die () {
199         code=$?
200         if test -n "$GIT_EXIT_OK"
201         then
202                 exit $code
203         else
204                 echo >&5 "FATAL: Unexpected exit with code $code"
205                 exit 1
206         fi
207 }
208
209 GIT_EXIT_OK=
210 trap 'die' EXIT
211
212 # The semantics of the editor variables are that of invoking
213 # sh -c "$EDITOR \"$@\"" files ...
214 #
215 # If our trash directory contains shell metacharacters, they will be
216 # interpreted if we just set $EDITOR directly, so do a little dance with
217 # environment variables to work around this.
218 #
219 # In particular, quoting isn't enough, as the path may contain the same quote
220 # that we're using.
221 test_set_editor () {
222         FAKE_EDITOR="$1"
223         export FAKE_EDITOR
224         EDITOR='"$FAKE_EDITOR"'
225         export EDITOR
226 }
227
228 test_decode_color () {
229         sed     -e 's/.\[1m/<WHITE>/g' \
230                 -e 's/.\[31m/<RED>/g' \
231                 -e 's/.\[32m/<GREEN>/g' \
232                 -e 's/.\[33m/<YELLOW>/g' \
233                 -e 's/.\[34m/<BLUE>/g' \
234                 -e 's/.\[35m/<MAGENTA>/g' \
235                 -e 's/.\[36m/<CYAN>/g' \
236                 -e 's/.\[m/<RESET>/g'
237 }
238
239 q_to_nul () {
240         perl -pe 'y/Q/\000/'
241 }
242
243 q_to_cr () {
244         tr Q '\015'
245 }
246
247 append_cr () {
248         sed -e 's/$/Q/' | tr Q '\015'
249 }
250
251 remove_cr () {
252         tr '\015' Q | sed -e 's/Q$//'
253 }
254
255 test_tick () {
256         if test -z "${test_tick+set}"
257         then
258                 test_tick=1112911993
259         else
260                 test_tick=$(($test_tick + 60))
261         fi
262         GIT_COMMITTER_DATE="$test_tick -0700"
263         GIT_AUTHOR_DATE="$test_tick -0700"
264         export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
265 }
266
267 # Call test_commit with the arguments "<message> [<file> [<contents>]]"
268 #
269 # This will commit a file with the given contents and the given commit
270 # message.  It will also add a tag with <message> as name.
271 #
272 # Both <file> and <contents> default to <message>.
273
274 test_commit () {
275         file=${2:-"$1.t"}
276         echo "${3-$1}" > "$file" &&
277         git add "$file" &&
278         test_tick &&
279         git commit -m "$1" &&
280         git tag "$1"
281 }
282
283 # Call test_merge with the arguments "<message> <commit>", where <commit>
284 # can be a tag pointing to the commit-to-merge.
285
286 test_merge () {
287         test_tick &&
288         git merge -m "$1" "$2" &&
289         git tag "$1"
290 }
291
292 # This function helps systems where core.filemode=false is set.
293 # Use it instead of plain 'chmod +x' to set or unset the executable bit
294 # of a file in the working directory and add it to the index.
295
296 test_chmod () {
297         chmod "$@" &&
298         git update-index --add "--chmod=$@"
299 }
300
301 # Use test_set_prereq to tell that a particular prerequisite is available.
302 # The prerequisite can later be checked for in two ways:
303 #
304 # - Explicitly using test_have_prereq.
305 #
306 # - Implicitly by specifying the prerequisite tag in the calls to
307 #   test_expect_{success,failure,code}.
308 #
309 # The single parameter is the prerequisite tag (a simple word, in all
310 # capital letters by convention).
311
312 test_set_prereq () {
313         satisfied="$satisfied$1 "
314 }
315 satisfied=" "
316
317 test_have_prereq () {
318         case $satisfied in
319         *" $1 "*)
320                 : yes, have it ;;
321         *)
322                 ! : nope ;;
323         esac
324 }
325
326 # You are not expected to call test_ok_ and test_failure_ directly, use
327 # the text_expect_* functions instead.
328
329 test_ok_ () {
330         test_success=$(($test_success + 1))
331         say_color "" "  ok $test_count: $@"
332 }
333
334 test_failure_ () {
335         test_failure=$(($test_failure + 1))
336         say_color error "FAIL $test_count: $1"
337         shift
338         echo "$@" | sed -e 's/^/        /'
339         test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; }
340 }
341
342 test_known_broken_ok_ () {
343         test_fixed=$(($test_fixed+1))
344         say_color "" "  FIXED $test_count: $@"
345 }
346
347 test_known_broken_failure_ () {
348         test_broken=$(($test_broken+1))
349         say_color skip "  still broken $test_count: $@"
350 }
351
352 test_debug () {
353         test "$debug" = "" || eval "$1"
354 }
355
356 test_run_ () {
357         eval >&3 2>&4 "$1"
358         eval_ret="$?"
359         return 0
360 }
361
362 test_skip () {
363         test_count=$(($test_count+1))
364         to_skip=
365         for skp in $GIT_SKIP_TESTS
366         do
367                 case $this_test.$test_count in
368                 $skp)
369                         to_skip=t
370                 esac
371         done
372         if test -z "$to_skip" && test -n "$prereq" &&
373            ! test_have_prereq "$prereq"
374         then
375                 to_skip=t
376         fi
377         case "$to_skip" in
378         t)
379                 say_color skip >&3 "skipping test: $@"
380                 say_color skip "skip $test_count: $1"
381                 : true
382                 ;;
383         *)
384                 false
385                 ;;
386         esac
387 }
388
389 test_expect_failure () {
390         test "$#" = 3 && { prereq=$1; shift; } || prereq=
391         test "$#" = 2 ||
392         error "bug in the test script: not 2 or 3 parameters to test-expect-failure"
393         if ! test_skip "$@"
394         then
395                 say >&3 "checking known breakage: $2"
396                 test_run_ "$2"
397                 if [ "$?" = 0 -a "$eval_ret" = 0 ]
398                 then
399                         test_known_broken_ok_ "$1"
400                 else
401                         test_known_broken_failure_ "$1"
402                 fi
403         fi
404         echo >&3 ""
405 }
406
407 test_expect_success () {
408         test "$#" = 3 && { prereq=$1; shift; } || prereq=
409         test "$#" = 2 ||
410         error "bug in the test script: not 2 or 3 parameters to test-expect-success"
411         if ! test_skip "$@"
412         then
413                 say >&3 "expecting success: $2"
414                 test_run_ "$2"
415                 if [ "$?" = 0 -a "$eval_ret" = 0 ]
416                 then
417                         test_ok_ "$1"
418                 else
419                         test_failure_ "$@"
420                 fi
421         fi
422         echo >&3 ""
423 }
424
425 test_expect_code () {
426         test "$#" = 4 && { prereq=$1; shift; } || prereq=
427         test "$#" = 3 ||
428         error "bug in the test script: not 3 or 4 parameters to test-expect-code"
429         if ! test_skip "$@"
430         then
431                 say >&3 "expecting exit code $1: $3"
432                 test_run_ "$3"
433                 if [ "$?" = 0 -a "$eval_ret" = "$1" ]
434                 then
435                         test_ok_ "$2"
436                 else
437                         test_failure_ "$@"
438                 fi
439         fi
440         echo >&3 ""
441 }
442
443 # test_external runs external test scripts that provide continuous
444 # test output about their progress, and succeeds/fails on
445 # zero/non-zero exit code.  It outputs the test output on stdout even
446 # in non-verbose mode, and announces the external script with "* run
447 # <n>: ..." before running it.  When providing relative paths, keep in
448 # mind that all scripts run in "trash directory".
449 # Usage: test_external description command arguments...
450 # Example: test_external 'Perl API' perl ../path/to/test.pl
451 test_external () {
452         test "$#" = 4 && { prereq=$1; shift; } || prereq=
453         test "$#" = 3 ||
454         error >&5 "bug in the test script: not 3 or 4 parameters to test_external"
455         descr="$1"
456         shift
457         if ! test_skip "$descr" "$@"
458         then
459                 # Announce the script to reduce confusion about the
460                 # test output that follows.
461                 say_color "" " run $test_count: $descr ($*)"
462                 # Run command; redirect its stderr to &4 as in
463                 # test_run_, but keep its stdout on our stdout even in
464                 # non-verbose mode.
465                 "$@" 2>&4
466                 if [ "$?" = 0 ]
467                 then
468                         test_ok_ "$descr"
469                 else
470                         test_failure_ "$descr" "$@"
471                 fi
472         fi
473 }
474
475 # Like test_external, but in addition tests that the command generated
476 # no output on stderr.
477 test_external_without_stderr () {
478         # The temporary file has no (and must have no) security
479         # implications.
480         tmp="$TMPDIR"; if [ -z "$tmp" ]; then tmp=/tmp; fi
481         stderr="$tmp/git-external-stderr.$$.tmp"
482         test_external "$@" 4> "$stderr"
483         [ -f "$stderr" ] || error "Internal error: $stderr disappeared."
484         descr="no stderr: $1"
485         shift
486         say >&3 "expecting no stderr from previous command"
487         if [ ! -s "$stderr" ]; then
488                 rm "$stderr"
489                 test_ok_ "$descr"
490         else
491                 if [ "$verbose" = t ]; then
492                         output=`echo; echo Stderr is:; cat "$stderr"`
493                 else
494                         output=
495                 fi
496                 # rm first in case test_failure exits.
497                 rm "$stderr"
498                 test_failure_ "$descr" "$@" "$output"
499         fi
500 }
501
502 # This is not among top-level (test_expect_success | test_expect_failure)
503 # but is a prefix that can be used in the test script, like:
504 #
505 #       test_expect_success 'complain and die' '
506 #           do something &&
507 #           do something else &&
508 #           test_must_fail git checkout ../outerspace
509 #       '
510 #
511 # Writing this as "! git checkout ../outerspace" is wrong, because
512 # the failure could be due to a segv.  We want a controlled failure.
513
514 test_must_fail () {
515         "$@"
516         test $? -gt 0 -a $? -le 129 -o $? -gt 192
517 }
518
519 # test_cmp is a helper function to compare actual and expected output.
520 # You can use it like:
521 #
522 #       test_expect_success 'foo works' '
523 #               echo expected >expected &&
524 #               foo >actual &&
525 #               test_cmp expected actual
526 #       '
527 #
528 # This could be written as either "cmp" or "diff -u", but:
529 # - cmp's output is not nearly as easy to read as diff -u
530 # - not all diff versions understand "-u"
531
532 test_cmp() {
533         $GIT_TEST_CMP "$@"
534 }
535
536 # Most tests can use the created repository, but some may need to create more.
537 # Usage: test_create_repo <directory>
538 test_create_repo () {
539         test "$#" = 1 ||
540         error "bug in the test script: not 1 parameter to test-create-repo"
541         owd=`pwd`
542         repo="$1"
543         mkdir -p "$repo"
544         cd "$repo" || error "Cannot setup test environment"
545         "$GIT_EXEC_PATH/git-init" "--template=$TEST_DIRECTORY/../templates/blt/" >&3 2>&4 ||
546         error "cannot run git init -- have you built things yet?"
547         mv .git/hooks .git/hooks-disabled
548         cd "$owd"
549 }
550
551 test_done () {
552         GIT_EXIT_OK=t
553         test_results_dir="$TEST_DIRECTORY/test-results"
554         mkdir -p "$test_results_dir"
555         test_results_path="$test_results_dir/${0%.sh}-$$"
556
557         echo "total $test_count" >> $test_results_path
558         echo "success $test_success" >> $test_results_path
559         echo "fixed $test_fixed" >> $test_results_path
560         echo "broken $test_broken" >> $test_results_path
561         echo "failed $test_failure" >> $test_results_path
562         echo "" >> $test_results_path
563
564         if test "$test_fixed" != 0
565         then
566                 say_color pass "fixed $test_fixed known breakage(s)"
567         fi
568         if test "$test_broken" != 0
569         then
570                 say_color error "still have $test_broken known breakage(s)"
571                 msg="remaining $(($test_count-$test_broken)) test(s)"
572         else
573                 msg="$test_count test(s)"
574         fi
575         case "$test_failure" in
576         0)
577                 say_color pass "passed all $msg"
578
579                 test -d "$remove_trash" &&
580                 cd "$(dirname "$remove_trash")" &&
581                 rm -rf "$(basename "$remove_trash")"
582
583                 exit 0 ;;
584
585         *)
586                 say_color error "failed $test_failure among $msg"
587                 exit 1 ;;
588
589         esac
590 }
591
592 # Test the binaries we have just built.  The tests are kept in
593 # t/ subdirectory and are run in 'trash directory' subdirectory.
594 TEST_DIRECTORY=$(pwd)
595 if test -n "$valgrind"
596 then
597         make_symlink () {
598                 test -h "$2" &&
599                 test "$1" = "$(readlink "$2")" || {
600                         # be super paranoid
601                         if mkdir "$2".lock
602                         then
603                                 rm -f "$2" &&
604                                 ln -s "$1" "$2" &&
605                                 rm -r "$2".lock
606                         else
607                                 while test -d "$2".lock
608                                 do
609                                         say "Waiting for lock on $2."
610                                         sleep 1
611                                 done
612                         fi
613                 }
614         }
615
616         make_valgrind_symlink () {
617                 # handle only executables
618                 test -x "$1" || return
619
620                 base=$(basename "$1")
621                 symlink_target=$TEST_DIRECTORY/../$base
622                 # do not override scripts
623                 if test -x "$symlink_target" &&
624                     test ! -d "$symlink_target" &&
625                     test "#!" != "$(head -c 2 < "$symlink_target")"
626                 then
627                         symlink_target=../valgrind.sh
628                 fi
629                 case "$base" in
630                 *.sh|*.perl)
631                         symlink_target=../unprocessed-script
632                 esac
633                 # create the link, or replace it if it is out of date
634                 make_symlink "$symlink_target" "$GIT_VALGRIND/bin/$base" || exit
635         }
636
637         # override all git executables in TEST_DIRECTORY/..
638         GIT_VALGRIND=$TEST_DIRECTORY/valgrind
639         mkdir -p "$GIT_VALGRIND"/bin
640         for file in $TEST_DIRECTORY/../git* $TEST_DIRECTORY/../test-*
641         do
642                 make_valgrind_symlink $file
643         done
644         OLDIFS=$IFS
645         IFS=:
646         for path in $PATH
647         do
648                 ls "$path"/git-* 2> /dev/null |
649                 while read file
650                 do
651                         make_valgrind_symlink "$file"
652                 done
653         done
654         IFS=$OLDIFS
655         PATH=$GIT_VALGRIND/bin:$PATH
656         GIT_EXEC_PATH=$GIT_VALGRIND/bin
657         export GIT_VALGRIND
658 elif test -n "$GIT_TEST_INSTALLED" ; then
659         GIT_EXEC_PATH=$($GIT_TEST_INSTALLED/git --exec-path)  ||
660         error "Cannot run git from $GIT_TEST_INSTALLED."
661         PATH=$GIT_TEST_INSTALLED:$TEST_DIRECTORY/..:$PATH
662         GIT_EXEC_PATH=${GIT_TEST_EXEC_PATH:-$GIT_EXEC_PATH}
663 else # normal case, use ../bin-wrappers only unless $with_dashes:
664         git_bin_dir="$TEST_DIRECTORY/../bin-wrappers"
665         if ! test -x "$git_bin_dir/git" ; then
666                 if test -z "$with_dashes" ; then
667                         say "$git_bin_dir/git is not executable; using GIT_EXEC_PATH"
668                 fi
669                 with_dashes=t
670         fi
671         PATH="$git_bin_dir:$PATH"
672         GIT_EXEC_PATH=$TEST_DIRECTORY/..
673         if test -n "$with_dashes" ; then
674                 PATH="$TEST_DIRECTORY/..:$PATH"
675         fi
676 fi
677 GIT_TEMPLATE_DIR=$(pwd)/../templates/blt
678 unset GIT_CONFIG
679 GIT_CONFIG_NOSYSTEM=1
680 GIT_CONFIG_NOGLOBAL=1
681 export PATH GIT_EXEC_PATH GIT_TEMPLATE_DIR GIT_CONFIG_NOSYSTEM GIT_CONFIG_NOGLOBAL
682
683 . ../GIT-BUILD-OPTIONS
684
685 GITPERLLIB=$(pwd)/../perl/blib/lib:$(pwd)/../perl/blib/arch/auto/Git
686 export GITPERLLIB
687 test -d ../templates/blt || {
688         error "You haven't built things yet, have you?"
689 }
690
691 if test -z "$GIT_TEST_INSTALLED" && test -z "$NO_PYTHON"
692 then
693         GITPYTHONLIB="$(pwd)/../git_remote_helpers/build/lib"
694         export GITPYTHONLIB
695         test -d ../git_remote_helpers/build || {
696                 error "You haven't built git_remote_helpers yet, have you?"
697         }
698 fi
699
700 if ! test -x ../test-chmtime; then
701         echo >&2 'You need to build test-chmtime:'
702         echo >&2 'Run "make test-chmtime" in the source (toplevel) directory'
703         exit 1
704 fi
705
706 # Test repository
707 test="trash directory.$(basename "$0" .sh)"
708 test -n "$root" && test="$root/$test"
709 case "$test" in
710 /*) TRASH_DIRECTORY="$test" ;;
711  *) TRASH_DIRECTORY="$TEST_DIRECTORY/$test" ;;
712 esac
713 test ! -z "$debug" || remove_trash=$TRASH_DIRECTORY
714 rm -fr "$test" || {
715         GIT_EXIT_OK=t
716         echo >&5 "FATAL: Cannot prepare test area"
717         exit 1
718 }
719
720 test_create_repo "$test"
721 # Use -P to resolve symlinks in our working directory so that the cwd
722 # in subprocesses like git equals our $PWD (for pathname comparisons).
723 cd -P "$test" || exit 1
724
725 this_test=${0##*/}
726 this_test=${this_test%%-*}
727 for skp in $GIT_SKIP_TESTS
728 do
729         to_skip=
730         for skp in $GIT_SKIP_TESTS
731         do
732                 case "$this_test" in
733                 $skp)
734                         to_skip=t
735                 esac
736         done
737         case "$to_skip" in
738         t)
739                 say_color skip >&3 "skipping test $this_test altogether"
740                 say_color skip "skip all tests in $this_test"
741                 test_done
742         esac
743 done
744
745 # Provide an implementation of the 'yes' utility
746 yes () {
747         if test $# = 0
748         then
749                 y=y
750         else
751                 y="$*"
752         fi
753
754         while echo "$y"
755         do
756                 :
757         done
758 }
759
760 # Fix some commands on Windows
761 case $(uname -s) in
762 *MINGW*)
763         # Windows has its own (incompatible) sort and find
764         sort () {
765                 /usr/bin/sort "$@"
766         }
767         find () {
768                 /usr/bin/find "$@"
769         }
770         sum () {
771                 md5sum "$@"
772         }
773         # git sees Windows-style pwd
774         pwd () {
775                 builtin pwd -W
776         }
777         # no POSIX permissions
778         # backslashes in pathspec are converted to '/'
779         # exec does not inherit the PID
780         ;;
781 *)
782         test_set_prereq POSIXPERM
783         test_set_prereq BSLASHPSPEC
784         test_set_prereq EXECKEEPSPID
785         ;;
786 esac
787
788 test -z "$NO_PERL" && test_set_prereq PERL
789 test -z "$NO_PYTHON" && test_set_prereq PYTHON
790
791 # test whether the filesystem supports symbolic links
792 ln -s x y 2>/dev/null && test -h y 2>/dev/null && test_set_prereq SYMLINKS
793 rm -f y