t/test-lib-functions.sh

   1 # Library of functions shared by all tests scripts, included by
   2 # test-lib.sh.
   3 #
   4 # Copyright (c) 2005 Junio C Hamano
   5 #
   6 # This program is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see http://www.gnu.org/licenses/ .
  18
  19 # The semantics of the editor variables are that of invoking
  20 # sh -c "$EDITOR \"$@\"" files ...
  21 #
  22 # If our trash directory contains shell metacharacters, they will be
  23 # interpreted if we just set $EDITOR directly, so do a little dance with
  24 # environment variables to work around this.
  25 #
  26 # In particular, quoting isn't enough, as the path may contain the same quote
  27 # that we're using.
  28 test_set_editor () {
  29         FAKE_EDITOR="$1"
  30         export FAKE_EDITOR
  31         EDITOR='"$FAKE_EDITOR"'
  32         export EDITOR
  33 }
  34
  35 test_decode_color () {
  36         awk '
  37                 function name(n) {
  38                         if (n == 0) return "RESET";
  39                         if (n == 1) return "BOLD";
  40                         if (n == 2) return "FAINT";
  41                         if (n == 3) return "ITALIC";
  42                         if (n == 7) return "REVERSE";
  43                         if (n == 30) return "BLACK";
  44                         if (n == 31) return "RED";
  45                         if (n == 32) return "GREEN";
  46                         if (n == 33) return "YELLOW";
  47                         if (n == 34) return "BLUE";
  48                         if (n == 35) return "MAGENTA";
  49                         if (n == 36) return "CYAN";
  50                         if (n == 37) return "WHITE";
  51                         if (n == 40) return "BLACK";
  52                         if (n == 41) return "BRED";
  53                         if (n == 42) return "BGREEN";
  54                         if (n == 43) return "BYELLOW";
  55                         if (n == 44) return "BBLUE";
  56                         if (n == 45) return "BMAGENTA";
  57                         if (n == 46) return "BCYAN";
  58                         if (n == 47) return "BWHITE";
  59                 }
  60                 {
  61                         while (match($0, /\033\[[0-9;]*m/) != 0) {
  62                                 printf "%s<", substr($0, 1, RSTART-1);
  63                                 codes = substr($0, RSTART+2, RLENGTH-3);
  64                                 if (length(codes) == 0)
  65                                         printf "%s", name(0)
  66                                 else {
  67                                         n = split(codes, ary, ";");
  68                                         sep = "";
  69                                         for (i = 1; i <= n; i++) {
  70                                                 printf "%s%s", sep, name(ary[i]);
  71                                                 sep = ";"
  72                                         }
  73                                 }
  74                                 printf ">";
  75                                 $0 = substr($0, RSTART + RLENGTH, length($0) - RSTART - RLENGTH + 1);
  76                         }
  77                         print
  78                 }
  79         '
  80 }
  81
  82 lf_to_nul () {
  83         perl -pe 'y/\012/\000/'
  84 }
  85
  86 nul_to_q () {
  87         perl -pe 'y/\000/Q/'
  88 }
  89
  90 q_to_nul () {
  91         perl -pe 'y/Q/\000/'
  92 }
  93
  94 q_to_cr () {
  95         tr Q '\015'
  96 }
  97
  98 q_to_tab () {
  99         tr Q '\011'
 100 }
 101
 102 qz_to_tab_space () {
 103         tr QZ '\011\040'
 104 }
 105
 106 append_cr () {
 107         sed -e 's/$/Q/' | tr Q '\015'
 108 }
 109
 110 remove_cr () {
 111         tr '\015' Q | sed -e 's/Q$//'
 112 }
 113
 114 # In some bourne shell implementations, the "unset" builtin returns
 115 # nonzero status when a variable to be unset was not set in the first
 116 # place.
 117 #
 118 # Use sane_unset when that should not be considered an error.
 119
 120 sane_unset () {
 121         unset "$@"
 122         return 0
 123 }
 124
 125 test_tick () {
 126         if test -z "${test_tick+set}"
 127         then
 128                 test_tick=1112911993
 129         else
 130                 test_tick=$(($test_tick + 60))
 131         fi
 132         GIT_COMMITTER_DATE="$test_tick -0700"
 133         GIT_AUTHOR_DATE="$test_tick -0700"
 134         export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
 135 }
 136
 137 # Stop execution and start a shell. This is useful for debugging tests.
 138 #
 139 # Be sure to remove all invocations of this command before submitting.
 140
 141 test_pause () {
 142         "$SHELL_PATH" <&6 >&5 2>&7
 143 }
 144
 145 # Wrap git with a debugger. Adding this to a command can make it easier
 146 # to understand what is going on in a failing test.
 147 #
 148 # Examples:
 149 #     debug git checkout master
 150 #     debug --debugger=nemiver git $ARGS
 151 #     debug -d "valgrind --tool=memcheck --track-origins=yes" git $ARGS
 152 debug () {
 153         case "$1" in
 154         -d)
 155                 GIT_DEBUGGER="$2" &&
 156                 shift 2
 157                 ;;
 158         --debugger=*)
 159                 GIT_DEBUGGER="${1#*=}" &&
 160                 shift 1
 161                 ;;
 162         *)
 163                 GIT_DEBUGGER=1
 164                 ;;
 165         esac &&
 166         GIT_DEBUGGER="${GIT_DEBUGGER}" "$@" <&6 >&5 2>&7
 167 }
 168
 169 # Usage: test_commit [options] <message> [<file> [<contents> [<tag>]]]
 170 #   -C <dir>:
 171 #       Run all git commands in directory <dir>
 172 #   --notick
 173 #       Do not call test_tick before making a commit
 174 #   --append
 175 #       Use "echo >>" instead of "echo >" when writing "<contents>" to
 176 #       "<file>"
 177 #   --signoff
 178 #       Invoke "git commit" with --signoff
 179 #   --author <author>
 180 #       Invoke "git commit" with --author <author>
 181 #
 182 # This will commit a file with the given contents and the given commit
 183 # message, and tag the resulting commit with the given tag name.
 184 #
 185 # <file>, <contents>, and <tag> all default to <message>.
 186
 187 test_commit () {
 188         notick= &&
 189         append= &&
 190         author= &&
 191         signoff= &&
 192         indir= &&
 193         no_tag= &&
 194         while test $# != 0
 195         do
 196                 case "$1" in
 197                 --notick)
 198                         notick=yes
 199                         ;;
 200                 --append)
 201                         append=yes
 202                         ;;
 203                 --author)
 204                         author="$2"
 205                         shift
 206                         ;;
 207                 --signoff)
 208                         signoff="$1"
 209                         ;;
 210                 --date)
 211                         notick=yes
 212                         GIT_COMMITTER_DATE="$2"
 213                         GIT_AUTHOR_DATE="$2"
 214                         shift
 215                         ;;
 216                 -C)
 217                         indir="$2"
 218                         shift
 219                         ;;
 220                 --no-tag)
 221                         no_tag=yes
 222                         ;;
 223                 *)
 224                         break
 225                         ;;
 226                 esac
 227                 shift
 228         done &&
 229         indir=${indir:+"$indir"/} &&
 230         file=${2:-"$1.t"} &&
 231         if test -n "$append"
 232         then
 233                 echo "${3-$1}" >>"$indir$file"
 234         else
 235                 echo "${3-$1}" >"$indir$file"
 236         fi &&
 237         git ${indir:+ -C "$indir"} add "$file" &&
 238         if test -z "$notick"
 239         then
 240                 test_tick
 241         fi &&
 242         git ${indir:+ -C "$indir"} commit \
 243             ${author:+ --author "$author"} \
 244             $signoff -m "$1" &&
 245         if test -z "$no_tag"
 246         then
 247                 git ${indir:+ -C "$indir"} tag "${4:-$1}"
 248         fi
 249 }
 250
 251 # Call test_merge with the arguments "<message> <commit>", where <commit>
 252 # can be a tag pointing to the commit-to-merge.
 253
 254 test_merge () {
 255         label="$1" &&
 256         shift &&
 257         test_tick &&
 258         git merge -m "$label" "$@" &&
 259         git tag "$label"
 260 }
 261
 262 # Efficiently create <nr> commits, each with a unique number (from 1 to <nr>
 263 # by default) in the commit message.
 264 #
 265 # Usage: test_commit_bulk [options] <nr>
 266 #   -C <dir>:
 267 #       Run all git commands in directory <dir>
 268 #   --ref=<n>:
 269 #       ref on which to create commits (default: HEAD)
 270 #   --start=<n>:
 271 #       number commit messages from <n> (default: 1)
 272 #   --message=<msg>:
 273 #       use <msg> as the commit mesasge (default: "commit %s")
 274 #   --filename=<fn>:
 275 #       modify <fn> in each commit (default: %s.t)
 276 #   --contents=<string>:
 277 #       place <string> in each file (default: "content %s")
 278 #   --id=<string>:
 279 #       shorthand to use <string> and %s in message, filename, and contents
 280 #
 281 # The message, filename, and contents strings are evaluated by printf, with the
 282 # first "%s" replaced by the current commit number. So you can do:
 283 #
 284 #   test_commit_bulk --filename=file --contents="modification %s"
 285 #
 286 # to have every commit touch the same file, but with unique content.
 287 #
 288 test_commit_bulk () {
 289         tmpfile=.bulk-commit.input
 290         indir=.
 291         ref=HEAD
 292         n=1
 293         message='commit %s'
 294         filename='%s.t'
 295         contents='content %s'
 296         while test $# -gt 0
 297         do
 298                 case "$1" in
 299                 -C)
 300                         indir=$2
 301                         shift
 302                         ;;
 303                 --ref=*)
 304                         ref=${1#--*=}
 305                         ;;
 306                 --start=*)
 307                         n=${1#--*=}
 308                         ;;
 309                 --message=*)
 310                         message=${1#--*=}
 311                         ;;
 312                 --filename=*)
 313                         filename=${1#--*=}
 314                         ;;
 315                 --contents=*)
 316                         contents=${1#--*=}
 317                         ;;
 318                 --id=*)
 319                         message="${1#--*=} %s"
 320                         filename="${1#--*=}-%s.t"
 321                         contents="${1#--*=} %s"
 322                         ;;
 323                 -*)
 324                         BUG "invalid test_commit_bulk option: $1"
 325                         ;;
 326                 *)
 327                         break
 328                         ;;
 329                 esac
 330                 shift
 331         done
 332         total=$1
 333
 334         add_from=
 335         if git -C "$indir" rev-parse --quiet --verify "$ref"
 336         then
 337                 add_from=t
 338         fi
 339
 340         while test "$total" -gt 0
 341         do
 342                 test_tick &&
 343                 echo "commit $ref"
 344                 printf 'author %s <%s> %s\n' \
 345                         "$GIT_AUTHOR_NAME" \
 346                         "$GIT_AUTHOR_EMAIL" \
 347                         "$GIT_AUTHOR_DATE"
 348                 printf 'committer %s <%s> %s\n' \
 349                         "$GIT_COMMITTER_NAME" \
 350                         "$GIT_COMMITTER_EMAIL" \
 351                         "$GIT_COMMITTER_DATE"
 352                 echo "data <<EOF"
 353                 printf "$message\n" $n
 354                 echo "EOF"
 355                 if test -n "$add_from"
 356                 then
 357                         echo "from $ref^0"
 358                         add_from=
 359                 fi
 360                 printf "M 644 inline $filename\n" $n
 361                 echo "data <<EOF"
 362                 printf "$contents\n" $n
 363                 echo "EOF"
 364                 echo
 365                 n=$((n + 1))
 366                 total=$((total - 1))
 367         done >"$tmpfile"
 368
 369         git -C "$indir" \
 370             -c fastimport.unpacklimit=0 \
 371             fast-import <"$tmpfile" || return 1
 372
 373         # This will be left in place on failure, which may aid debugging.
 374         rm -f "$tmpfile"
 375
 376         # If we updated HEAD, then be nice and update the index and working
 377         # tree, too.
 378         if test "$ref" = "HEAD"
 379         then
 380                 git -C "$indir" checkout -f HEAD || return 1
 381         fi
 382
 383 }
 384
 385 # This function helps systems where core.filemode=false is set.
 386 # Use it instead of plain 'chmod +x' to set or unset the executable bit
 387 # of a file in the working directory and add it to the index.
 388
 389 test_chmod () {
 390         chmod "$@" &&
 391         git update-index --add "--chmod=$@"
 392 }
 393
 394 # Get the modebits from a file or directory, ignoring the setgid bit (g+s).
 395 # This bit is inherited by subdirectories at their creation. So we remove it
 396 # from the returning string to prevent callers from having to worry about the
 397 # state of the bit in the test directory.
 398 #
 399 test_modebits () {
 400         ls -ld "$1" | sed -e 's|^\(..........\).*|\1|' \
 401                           -e 's|^\(......\)S|\1-|' -e 's|^\(......\)s|\1x|'
 402 }
 403
 404 # Unset a configuration variable, but don't fail if it doesn't exist.
 405 test_unconfig () {
 406         config_dir=
 407         if test "$1" = -C
 408         then
 409                 shift
 410                 config_dir=$1
 411                 shift
 412         fi
 413         git ${config_dir:+-C "$config_dir"} config --unset-all "$@"
 414         config_status=$?
 415         case "$config_status" in
 416         5) # ok, nothing to unset
 417                 config_status=0
 418                 ;;
 419         esac
 420         return $config_status
 421 }
 422
 423 # Set git config, automatically unsetting it after the test is over.
 424 test_config () {
 425         config_dir=
 426         if test "$1" = -C
 427         then
 428                 shift
 429                 config_dir=$1
 430                 shift
 431         fi
 432         test_when_finished "test_unconfig ${config_dir:+-C '$config_dir'} '$1'" &&
 433         git ${config_dir:+-C "$config_dir"} config "$@"
 434 }
 435
 436 test_config_global () {
 437         test_when_finished "test_unconfig --global '$1'" &&
 438         git config --global "$@"
 439 }
 440
 441 write_script () {
 442         {
 443                 echo "#!${2-"$SHELL_PATH"}" &&
 444                 cat
 445         } >"$1" &&
 446         chmod +x "$1"
 447 }
 448
 449 # Use test_set_prereq to tell that a particular prerequisite is available.
 450 # The prerequisite can later be checked for in two ways:
 451 #
 452 # - Explicitly using test_have_prereq.
 453 #
 454 # - Implicitly by specifying the prerequisite tag in the calls to
 455 #   test_expect_{success,failure} and test_external{,_without_stderr}.
 456 #
 457 # The single parameter is the prerequisite tag (a simple word, in all
 458 # capital letters by convention).
 459
 460 test_unset_prereq () {
 461         ! test_have_prereq "$1" ||
 462         satisfied_prereq="${satisfied_prereq% $1 *} ${satisfied_prereq#* $1 }"
 463 }
 464
 465 test_set_prereq () {
 466         if test -n "$GIT_TEST_FAIL_PREREQS_INTERNAL"
 467         then
 468                 case "$1" in
 469                 # The "!" case is handled below with
 470                 # test_unset_prereq()
 471                 !*)
 472                         ;;
 473                 # (Temporary?) whitelist of things we can't easily
 474                 # pretend not to support
 475                 SYMLINKS)
 476                         ;;
 477                 # Inspecting whether GIT_TEST_FAIL_PREREQS is on
 478                 # should be unaffected.
 479                 FAIL_PREREQS)
 480                         ;;
 481                 *)
 482                         return
 483                 esac
 484         fi
 485
 486         case "$1" in
 487         !*)
 488                 test_unset_prereq "${1#!}"
 489                 ;;
 490         *)
 491                 satisfied_prereq="$satisfied_prereq$1 "
 492                 ;;
 493         esac
 494 }
 495 satisfied_prereq=" "
 496 lazily_testable_prereq= lazily_tested_prereq=
 497
 498 # Usage: test_lazy_prereq PREREQ 'script'
 499 test_lazy_prereq () {
 500         lazily_testable_prereq="$lazily_testable_prereq$1 "
 501         eval test_prereq_lazily_$1=\$2
 502 }
 503
 504 test_run_lazy_prereq_ () {
 505         script='
 506 mkdir -p "$TRASH_DIRECTORY/prereq-test-dir-'"$1"'" &&
 507 (
 508         cd "$TRASH_DIRECTORY/prereq-test-dir-'"$1"'" &&'"$2"'
 509 )'
 510         say >&3 "checking prerequisite: $1"
 511         say >&3 "$script"
 512         test_eval_ "$script"
 513         eval_ret=$?
 514         rm -rf "$TRASH_DIRECTORY/prereq-test-dir-$1"
 515         if test "$eval_ret" = 0; then
 516                 say >&3 "prerequisite $1 ok"
 517         else
 518                 say >&3 "prerequisite $1 not satisfied"
 519         fi
 520         return $eval_ret
 521 }
 522
 523 test_have_prereq () {
 524         # prerequisites can be concatenated with ','
 525         save_IFS=$IFS
 526         IFS=,
 527         set -- $*
 528         IFS=$save_IFS
 529
 530         total_prereq=0
 531         ok_prereq=0
 532         missing_prereq=
 533
 534         for prerequisite
 535         do
 536                 case "$prerequisite" in
 537                 !*)
 538                         negative_prereq=t
 539                         prerequisite=${prerequisite#!}
 540                         ;;
 541                 *)
 542                         negative_prereq=
 543                 esac
 544
 545                 case " $lazily_tested_prereq " in
 546                 *" $prerequisite "*)
 547                         ;;
 548                 *)
 549                         case " $lazily_testable_prereq " in
 550                         *" $prerequisite "*)
 551                                 eval "script=\$test_prereq_lazily_$prerequisite" &&
 552                                 if test_run_lazy_prereq_ "$prerequisite" "$script"
 553                                 then
 554                                         test_set_prereq $prerequisite
 555                                 fi
 556                                 lazily_tested_prereq="$lazily_tested_prereq$prerequisite "
 557                         esac
 558                         ;;
 559                 esac
 560
 561                 total_prereq=$(($total_prereq + 1))
 562                 case "$satisfied_prereq" in
 563                 *" $prerequisite "*)
 564                         satisfied_this_prereq=t
 565                         ;;
 566                 *)
 567                         satisfied_this_prereq=
 568                 esac
 569
 570                 case "$satisfied_this_prereq,$negative_prereq" in
 571                 t,|,t)
 572                         ok_prereq=$(($ok_prereq + 1))
 573                         ;;
 574                 *)
 575                         # Keep a list of missing prerequisites; restore
 576                         # the negative marker if necessary.
 577                         prerequisite=${negative_prereq:+!}$prerequisite
 578                         if test -z "$missing_prereq"
 579                         then
 580                                 missing_prereq=$prerequisite
 581                         else
 582                                 missing_prereq="$prerequisite,$missing_prereq"
 583                         fi
 584                 esac
 585         done
 586
 587         test $total_prereq = $ok_prereq
 588 }
 589
 590 test_declared_prereq () {
 591         case ",$test_prereq," in
 592         *,$1,*)
 593                 return 0
 594                 ;;
 595         esac
 596         return 1
 597 }
 598
 599 test_verify_prereq () {
 600         test -z "$test_prereq" ||
 601         expr >/dev/null "$test_prereq" : '[A-Z0-9_,!]*$' ||
 602         BUG "'$test_prereq' does not look like a prereq"
 603 }
 604
 605 test_expect_failure () {
 606         test_start_
 607         test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
 608         test "$#" = 2 ||
 609         BUG "not 2 or 3 parameters to test-expect-failure"
 610         test_verify_prereq
 611         export test_prereq
 612         if ! test_skip "$@"
 613         then
 614                 say >&3 "checking known breakage of $TEST_NUMBER.$test_count '$1': $2"
 615                 if test_run_ "$2" expecting_failure
 616                 then
 617                         test_known_broken_ok_ "$1"
 618                 else
 619                         test_known_broken_failure_ "$1"
 620                 fi
 621         fi
 622         test_finish_
 623 }
 624
 625 test_expect_success () {
 626         test_start_
 627         test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
 628         test "$#" = 2 ||
 629         BUG "not 2 or 3 parameters to test-expect-success"
 630         test_verify_prereq
 631         export test_prereq
 632         if ! test_skip "$@"
 633         then
 634                 say >&3 "expecting success of $TEST_NUMBER.$test_count '$1': $2"
 635                 if test_run_ "$2"
 636                 then
 637                         test_ok_ "$1"
 638                 else
 639                         test_failure_ "$@"
 640                 fi
 641         fi
 642         test_finish_
 643 }
 644
 645 # test_external runs external test scripts that provide continuous
 646 # test output about their progress, and succeeds/fails on
 647 # zero/non-zero exit code.  It outputs the test output on stdout even
 648 # in non-verbose mode, and announces the external script with "# run
 649 # <n>: ..." before running it.  When providing relative paths, keep in
 650 # mind that all scripts run in "trash directory".
 651 # Usage: test_external description command arguments...
 652 # Example: test_external 'Perl API' perl ../path/to/test.pl
 653 test_external () {
 654         test "$#" = 4 && { test_prereq=$1; shift; } || test_prereq=
 655         test "$#" = 3 ||
 656         BUG "not 3 or 4 parameters to test_external"
 657         descr="$1"
 658         shift
 659         test_verify_prereq
 660         export test_prereq
 661         if ! test_skip "$descr" "$@"
 662         then
 663                 # Announce the script to reduce confusion about the
 664                 # test output that follows.
 665                 say_color "" "# run $test_count: $descr ($*)"
 666                 # Export TEST_DIRECTORY, TRASH_DIRECTORY and GIT_TEST_LONG
 667                 # to be able to use them in script
 668                 export TEST_DIRECTORY TRASH_DIRECTORY GIT_TEST_LONG
 669                 # Run command; redirect its stderr to &4 as in
 670                 # test_run_, but keep its stdout on our stdout even in
 671                 # non-verbose mode.
 672                 "$@" 2>&4
 673                 if test "$?" = 0
 674                 then
 675                         if test $test_external_has_tap -eq 0; then
 676                                 test_ok_ "$descr"
 677                         else
 678                                 say_color "" "# test_external test $descr was ok"
 679                                 test_success=$(($test_success + 1))
 680                         fi
 681                 else
 682                         if test $test_external_has_tap -eq 0; then
 683                                 test_failure_ "$descr" "$@"
 684                         else
 685                                 say_color error "# test_external test $descr failed: $@"
 686                                 test_failure=$(($test_failure + 1))
 687                         fi
 688                 fi
 689         fi
 690 }
 691
 692 # Like test_external, but in addition tests that the command generated
 693 # no output on stderr.
 694 test_external_without_stderr () {
 695         # The temporary file has no (and must have no) security
 696         # implications.
 697         tmp=${TMPDIR:-/tmp}
 698         stderr="$tmp/git-external-stderr.$$.tmp"
 699         test_external "$@" 4> "$stderr"
 700         test -f "$stderr" || error "Internal error: $stderr disappeared."
 701         descr="no stderr: $1"
 702         shift
 703         say >&3 "# expecting no stderr from previous command"
 704         if test ! -s "$stderr"
 705         then
 706                 rm "$stderr"
 707
 708                 if test $test_external_has_tap -eq 0; then
 709                         test_ok_ "$descr"
 710                 else
 711                         say_color "" "# test_external_without_stderr test $descr was ok"
 712                         test_success=$(($test_success + 1))
 713                 fi
 714         else
 715                 if test "$verbose" = t
 716                 then
 717                         output=$(echo; echo "# Stderr is:"; cat "$stderr")
 718                 else
 719                         output=
 720                 fi
 721                 # rm first in case test_failure exits.
 722                 rm "$stderr"
 723                 if test $test_external_has_tap -eq 0; then
 724                         test_failure_ "$descr" "$@" "$output"
 725                 else
 726                         say_color error "# test_external_without_stderr test $descr failed: $@: $output"
 727                         test_failure=$(($test_failure + 1))
 728                 fi
 729         fi
 730 }
 731
 732 # debugging-friendly alternatives to "test [-f|-d|-e]"
 733 # The commands test the existence or non-existence of $1
 734 test_path_is_file () {
 735         test "$#" -ne 1 && BUG "1 param"
 736         if ! test -f "$1"
 737         then
 738                 echo "File $1 doesn't exist"
 739                 false
 740         fi
 741 }
 742
 743 test_path_is_dir () {
 744         test "$#" -ne 1 && BUG "1 param"
 745         if ! test -d "$1"
 746         then
 747                 echo "Directory $1 doesn't exist"
 748                 false
 749         fi
 750 }
 751
 752 test_path_exists () {
 753         test "$#" -ne 1 && BUG "1 param"
 754         if ! test -e "$1"
 755         then
 756                 echo "Path $1 doesn't exist"
 757                 false
 758         fi
 759 }
 760
 761 # Check if the directory exists and is empty as expected, barf otherwise.
 762 test_dir_is_empty () {
 763         test "$#" -ne 1 && BUG "1 param"
 764         test_path_is_dir "$1" &&
 765         if test -n "$(ls -a1 "$1" | egrep -v '^\.\.?$')"
 766         then
 767                 echo "Directory '$1' is not empty, it contains:"
 768                 ls -la "$1"
 769                 return 1
 770         fi
 771 }
 772
 773 # Check if the file exists and has a size greater than zero
 774 test_file_not_empty () {
 775         test "$#" = 2 && BUG "2 param"
 776         if ! test -s "$1"
 777         then
 778                 echo "'$1' is not a non-empty file."
 779                 false
 780         fi
 781 }
 782
 783 test_path_is_missing () {
 784         test "$#" -ne 1 && BUG "1 param"
 785         if test -e "$1"
 786         then
 787                 echo "Path exists:"
 788                 ls -ld "$1"
 789                 if test $# -ge 1
 790                 then
 791                         echo "$*"
 792                 fi
 793                 false
 794         fi
 795 }
 796
 797 # test_line_count checks that a file has the number of lines it
 798 # ought to. For example:
 799 #
 800 #       test_expect_success 'produce exactly one line of output' '
 801 #               do something >output &&
 802 #               test_line_count = 1 output
 803 #       '
 804 #
 805 # is like "test $(wc -l <output) = 1" except that it passes the
 806 # output through when the number of lines is wrong.
 807
 808 test_line_count () {
 809         if test $# != 3
 810         then
 811                 BUG "not 3 parameters to test_line_count"
 812         elif ! test $(wc -l <"$3") "$1" "$2"
 813         then
 814                 echo "test_line_count: line count for $3 !$1 $2"
 815                 cat "$3"
 816                 return 1
 817         fi
 818 }
 819
 820 test_file_size () {
 821         test "$#" -ne 1 && BUG "1 param"
 822         test-tool path-utils file-size "$1"
 823 }
 824
 825 # Returns success if a comma separated string of keywords ($1) contains a
 826 # given keyword ($2).
 827 # Examples:
 828 # `list_contains "foo,bar" bar` returns 0
 829 # `list_contains "foo" bar` returns 1
 830
 831 list_contains () {
 832         case ",$1," in
 833         *,$2,*)
 834                 return 0
 835                 ;;
 836         esac
 837         return 1
 838 }
 839
 840 # Returns success if the arguments indicate that a command should be
 841 # accepted by test_must_fail(). If the command is run with env, the env
 842 # and its corresponding variable settings will be stripped before we
 843 # test the command being run.
 844 test_must_fail_acceptable () {
 845         if test "$1" = "env"
 846         then
 847                 shift
 848                 while test $# -gt 0
 849                 do
 850                         case "$1" in
 851                         *?=*)
 852                                 shift
 853                                 ;;
 854                         *)
 855                                 break
 856                                 ;;
 857                         esac
 858                 done
 859         fi
 860
 861         case "$1" in
 862         git|__git*|test-tool|test_terminal)
 863                 return 0
 864                 ;;
 865         *)
 866                 return 1
 867                 ;;
 868         esac
 869 }
 870
 871 # This is not among top-level (test_expect_success | test_expect_failure)
 872 # but is a prefix that can be used in the test script, like:
 873 #
 874 #       test_expect_success 'complain and die' '
 875 #           do something &&
 876 #           do something else &&
 877 #           test_must_fail git checkout ../outerspace
 878 #       '
 879 #
 880 # Writing this as "! git checkout ../outerspace" is wrong, because
 881 # the failure could be due to a segv.  We want a controlled failure.
 882 #
 883 # Accepts the following options:
 884 #
 885 #   ok=<signal-name>[,<...>]:
 886 #     Don't treat an exit caused by the given signal as error.
 887 #     Multiple signals can be specified as a comma separated list.
 888 #     Currently recognized signal names are: sigpipe, success.
 889 #     (Don't use 'success', use 'test_might_fail' instead.)
 890 #
 891 # Do not use this to run anything but "git" and other specific testable
 892 # commands (see test_must_fail_acceptable()).  We are not in the
 893 # business of vetting system supplied commands -- in other words, this
 894 # is wrong:
 895 #
 896 #    test_must_fail grep pattern output
 897 #
 898 # Instead use '!':
 899 #
 900 #    ! grep pattern output
 901
 902 test_must_fail () {
 903         case "$1" in
 904         ok=*)
 905                 _test_ok=${1#ok=}
 906                 shift
 907                 ;;
 908         *)
 909                 _test_ok=
 910                 ;;
 911         esac
 912         if ! test_must_fail_acceptable "$@"
 913         then
 914                 echo >&7 "test_must_fail: only 'git' is allowed: $*"
 915                 return 1
 916         fi
 917         "$@" 2>&7
 918         exit_code=$?
 919         if test $exit_code -eq 0 && ! list_contains "$_test_ok" success
 920         then
 921                 echo >&4 "test_must_fail: command succeeded: $*"
 922                 return 1
 923         elif test_match_signal 13 $exit_code && list_contains "$_test_ok" sigpipe
 924         then
 925                 return 0
 926         elif test $exit_code -gt 129 && test $exit_code -le 192
 927         then
 928                 echo >&4 "test_must_fail: died by signal $(($exit_code - 128)): $*"
 929                 return 1
 930         elif test $exit_code -eq 127
 931         then
 932                 echo >&4 "test_must_fail: command not found: $*"
 933                 return 1
 934         elif test $exit_code -eq 126
 935         then
 936                 echo >&4 "test_must_fail: valgrind error: $*"
 937                 return 1
 938         fi
 939         return 0
 940 } 7>&2 2>&4
 941
 942 # Similar to test_must_fail, but tolerates success, too.  This is
 943 # meant to be used in contexts like:
 944 #
 945 #       test_expect_success 'some command works without configuration' '
 946 #               test_might_fail git config --unset all.configuration &&
 947 #               do something
 948 #       '
 949 #
 950 # Writing "git config --unset all.configuration || :" would be wrong,
 951 # because we want to notice if it fails due to segv.
 952 #
 953 # Accepts the same options as test_must_fail.
 954
 955 test_might_fail () {
 956         test_must_fail ok=success "$@" 2>&7
 957 } 7>&2 2>&4
 958
 959 # Similar to test_must_fail and test_might_fail, but check that a
 960 # given command exited with a given exit code. Meant to be used as:
 961 #
 962 #       test_expect_success 'Merge with d/f conflicts' '
 963 #               test_expect_code 1 git merge "merge msg" B master
 964 #       '
 965
 966 test_expect_code () {
 967         want_code=$1
 968         shift
 969         "$@" 2>&7
 970         exit_code=$?
 971         if test $exit_code = $want_code
 972         then
 973                 return 0
 974         fi
 975
 976         echo >&4 "test_expect_code: command exited with $exit_code, we wanted $want_code $*"
 977         return 1
 978 } 7>&2 2>&4
 979
 980 # test_cmp is a helper function to compare actual and expected output.
 981 # You can use it like:
 982 #
 983 #       test_expect_success 'foo works' '
 984 #               echo expected >expected &&
 985 #               foo >actual &&
 986 #               test_cmp expected actual
 987 #       '
 988 #
 989 # This could be written as either "cmp" or "diff -u", but:
 990 # - cmp's output is not nearly as easy to read as diff -u
 991 # - not all diff versions understand "-u"
 992
 993 test_cmp () {
 994         test "$#" -ne 2 && BUG "2 param"
 995         eval "$GIT_TEST_CMP" '"$@"'
 996 }
 997
 998 # Check that the given config key has the expected value.
 999 #
1000 #    test_cmp_config [-C <dir>] <expected-value>
1001 #                    [<git-config-options>...] <config-key>
1002 #
1003 # for example to check that the value of core.bar is foo
1004 #
1005 #    test_cmp_config foo core.bar
1006 #
1007 test_cmp_config () {
1008         local GD &&
1009         if test "$1" = "-C"
1010         then
1011                 shift &&
1012                 GD="-C $1" &&
1013                 shift
1014         fi &&
1015         printf "%s\n" "$1" >expect.config &&
1016         shift &&
1017         git $GD config "$@" >actual.config &&
1018         test_cmp expect.config actual.config
1019 }
1020
1021 # test_cmp_bin - helper to compare binary files
1022
1023 test_cmp_bin () {
1024         test "$#" -ne 2 && BUG "2 param"
1025         cmp "$@"
1026 }
1027
1028 # Wrapper for test_cmp which used to be used for
1029 # GIT_TEST_GETTEXT_POISON=false. Only here as a shim for other
1030 # in-flight changes. Should not be used and will be removed soon.
1031 test_i18ncmp () {
1032         test_cmp "$@"
1033 }
1034
1035 # Wrapper for grep which used to be used for
1036 # GIT_TEST_GETTEXT_POISON=false. Only here as a shim for other
1037 # in-flight changes. Should not be used and will be removed soon.
1038 test_i18ngrep () {
1039         eval "last_arg=\${$#}"
1040
1041         test -f "$last_arg" ||
1042         BUG "test_i18ngrep requires a file to read as the last parameter"
1043
1044         if test $# -lt 2 ||
1045            { test "x!" = "x$1" && test $# -lt 3 ; }
1046         then
1047                 BUG "too few parameters to test_i18ngrep"
1048         fi
1049
1050         if test "x!" = "x$1"
1051         then
1052                 shift
1053                 ! grep "$@" && return 0
1054
1055                 echo >&4 "error: '! grep $@' did find a match in:"
1056         else
1057                 grep "$@" && return 0
1058
1059                 echo >&4 "error: 'grep $@' didn't find a match in:"
1060         fi
1061
1062         if test -s "$last_arg"
1063         then
1064                 cat >&4 "$last_arg"
1065         else
1066                 echo >&4 "<File '$last_arg' is empty>"
1067         fi
1068
1069         return 1
1070 }
1071
1072 # Call any command "$@" but be more verbose about its
1073 # failure. This is handy for commands like "test" which do
1074 # not output anything when they fail.
1075 verbose () {
1076         "$@" && return 0
1077         echo >&4 "command failed: $(git rev-parse --sq-quote "$@")"
1078         return 1
1079 }
1080
1081 # Check if the file expected to be empty is indeed empty, and barfs
1082 # otherwise.
1083
1084 test_must_be_empty () {
1085         test "$#" -ne 1 && BUG "1 param"
1086         test_path_is_file "$1" &&
1087         if test -s "$1"
1088         then
1089                 echo "'$1' is not empty, it contains:"
1090                 cat "$1"
1091                 return 1
1092         fi
1093 }
1094
1095 # Tests that its two parameters refer to the same revision, or if '!' is
1096 # provided first, that its other two parameters refer to different
1097 # revisions.
1098 test_cmp_rev () {
1099         local op='=' wrong_result=different
1100
1101         if test $# -ge 1 && test "x$1" = 'x!'
1102         then
1103             op='!='
1104             wrong_result='the same'
1105             shift
1106         fi
1107         if test $# != 2
1108         then
1109                 BUG "test_cmp_rev requires two revisions, but got $#"
1110         else
1111                 local r1 r2
1112                 r1=$(git rev-parse --verify "$1") &&
1113                 r2=$(git rev-parse --verify "$2") || return 1
1114
1115                 if ! test "$r1" "$op" "$r2"
1116                 then
1117                         cat >&4 <<-EOF
1118                         error: two revisions point to $wrong_result objects:
1119                           '$1': $r1
1120                           '$2': $r2
1121                         EOF
1122                         return 1
1123                 fi
1124         fi
1125 }
1126
1127 # Compare paths respecting core.ignoreCase
1128 test_cmp_fspath () {
1129         if test "x$1" = "x$2"
1130         then
1131                 return 0
1132         fi
1133
1134         if test true != "$(git config --get --type=bool core.ignorecase)"
1135         then
1136                 return 1
1137         fi
1138
1139         test "x$(echo "$1" | tr A-Z a-z)" =  "x$(echo "$2" | tr A-Z a-z)"
1140 }
1141
1142 # Print a sequence of integers in increasing order, either with
1143 # two arguments (start and end):
1144 #
1145 #     test_seq 1 5 -- outputs 1 2 3 4 5 one line at a time
1146 #
1147 # or with one argument (end), in which case it starts counting
1148 # from 1.
1149
1150 test_seq () {
1151         case $# in
1152         1)      set 1 "$@" ;;
1153         2)      ;;
1154         *)      BUG "not 1 or 2 parameters to test_seq" ;;
1155         esac
1156         test_seq_counter__=$1
1157         while test "$test_seq_counter__" -le "$2"
1158         do
1159                 echo "$test_seq_counter__"
1160                 test_seq_counter__=$(( $test_seq_counter__ + 1 ))
1161         done
1162 }
1163
1164 # This function can be used to schedule some commands to be run
1165 # unconditionally at the end of the test to restore sanity:
1166 #
1167 #       test_expect_success 'test core.capslock' '
1168 #               git config core.capslock true &&
1169 #               test_when_finished "git config --unset core.capslock" &&
1170 #               hello world
1171 #       '
1172 #
1173 # That would be roughly equivalent to
1174 #
1175 #       test_expect_success 'test core.capslock' '
1176 #               git config core.capslock true &&
1177 #               hello world
1178 #               git config --unset core.capslock
1179 #       '
1180 #
1181 # except that the greeting and config --unset must both succeed for
1182 # the test to pass.
1183 #
1184 # Note that under --immediate mode, no clean-up is done to help diagnose
1185 # what went wrong.
1186
1187 test_when_finished () {
1188         # We cannot detect when we are in a subshell in general, but by
1189         # doing so on Bash is better than nothing (the test will
1190         # silently pass on other shells).
1191         test "${BASH_SUBSHELL-0}" = 0 ||
1192         BUG "test_when_finished does nothing in a subshell"
1193         test_cleanup="{ $*
1194                 } && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup"
1195 }
1196
1197 # This function can be used to schedule some commands to be run
1198 # unconditionally at the end of the test script, e.g. to stop a daemon:
1199 #
1200 #       test_expect_success 'test git daemon' '
1201 #               git daemon &
1202 #               daemon_pid=$! &&
1203 #               test_atexit 'kill $daemon_pid' &&
1204 #               hello world
1205 #       '
1206 #
1207 # The commands will be executed before the trash directory is removed,
1208 # i.e. the atexit commands will still be able to access any pidfiles or
1209 # socket files.
1210 #
1211 # Note that these commands will be run even when a test script run
1212 # with '--immediate' fails.  Be careful with your atexit commands to
1213 # minimize any changes to the failed state.
1214
1215 test_atexit () {
1216         # We cannot detect when we are in a subshell in general, but by
1217         # doing so on Bash is better than nothing (the test will
1218         # silently pass on other shells).
1219         test "${BASH_SUBSHELL-0}" = 0 ||
1220         BUG "test_atexit does nothing in a subshell"
1221         test_atexit_cleanup="{ $*
1222                 } && (exit \"\$eval_ret\"); eval_ret=\$?; $test_atexit_cleanup"
1223 }
1224
1225 # Most tests can use the created repository, but some may need to create more.
1226 # Usage: test_create_repo <directory>
1227 test_create_repo () {
1228         test "$#" = 1 ||
1229         BUG "not 1 parameter to test-create-repo"
1230         repo="$1"
1231         mkdir -p "$repo"
1232         (
1233                 cd "$repo" || error "Cannot setup test environment"
1234                 "${GIT_TEST_INSTALLED:-$GIT_EXEC_PATH}/git$X" -c \
1235                         init.defaultBranch="${GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME-master}" \
1236                         init \
1237                         "--template=$GIT_BUILD_DIR/templates/blt/" >&3 2>&4 ||
1238                 error "cannot run git init -- have you built things yet?"
1239                 mv .git/hooks .git/hooks-disabled
1240         ) || exit
1241 }
1242
1243 # This function helps on symlink challenged file systems when it is not
1244 # important that the file system entry is a symbolic link.
1245 # Use test_ln_s_add instead of "ln -s x y && git add y" to add a
1246 # symbolic link entry y to the index.
1247
1248 test_ln_s_add () {
1249         if test_have_prereq SYMLINKS
1250         then
1251                 ln -s "$1" "$2" &&
1252                 git update-index --add "$2"
1253         else
1254                 printf '%s' "$1" >"$2" &&
1255                 ln_s_obj=$(git hash-object -w "$2") &&
1256                 git update-index --add --cacheinfo 120000 $ln_s_obj "$2" &&
1257                 # pick up stat info from the file
1258                 git update-index "$2"
1259         fi
1260 }
1261
1262 # This function writes out its parameters, one per line
1263 test_write_lines () {
1264         printf "%s\n" "$@"
1265 }
1266
1267 perl () {
1268         command "$PERL_PATH" "$@" 2>&7
1269 } 7>&2 2>&4
1270
1271 # Given the name of an environment variable with a bool value, normalize
1272 # its value to a 0 (true) or 1 (false or empty string) return code.
1273 #
1274 #   test_bool_env GIT_TEST_HTTPD <default-value>
1275 #
1276 # Return with code corresponding to the given default value if the variable
1277 # is unset.
1278 # Abort the test script if either the value of the variable or the default
1279 # are not valid bool values.
1280
1281 test_bool_env () {
1282         if test $# != 2
1283         then
1284                 BUG "test_bool_env requires two parameters (variable name and default value)"
1285         fi
1286
1287         git env--helper --type=bool --default="$2" --exit-code "$1"
1288         ret=$?
1289         case $ret in
1290         0|1)    # unset or valid bool value
1291                 ;;
1292         *)      # invalid bool value or something unexpected
1293                 error >&7 "test_bool_env requires bool values both for \$$1 and for the default fallback"
1294                 ;;
1295         esac
1296         return $ret
1297 }
1298
1299 # Exit the test suite, either by skipping all remaining tests or by
1300 # exiting with an error. If our prerequisite variable $1 falls back
1301 # on a default assume we were opportunistically trying to set up some
1302 # tests and we skip. If it is explicitly "true", then we report a failure.
1303 #
1304 # The error/skip message should be given by $2.
1305 #
1306 test_skip_or_die () {
1307         if ! test_bool_env "$1" false
1308         then
1309                 skip_all=$2
1310                 test_done
1311         fi
1312         error "$2"
1313 }
1314
1315 # The following mingw_* functions obey POSIX shell syntax, but are actually
1316 # bash scripts, and are meant to be used only with bash on Windows.
1317
1318 # A test_cmp function that treats LF and CRLF equal and avoids to fork
1319 # diff when possible.
1320 mingw_test_cmp () {
1321         # Read text into shell variables and compare them. If the results
1322         # are different, use regular diff to report the difference.
1323         local test_cmp_a= test_cmp_b=
1324
1325         # When text came from stdin (one argument is '-') we must feed it
1326         # to diff.
1327         local stdin_for_diff=
1328
1329         # Since it is difficult to detect the difference between an
1330         # empty input file and a failure to read the files, we go straight
1331         # to diff if one of the inputs is empty.
1332         if test -s "$1" && test -s "$2"
1333         then
1334                 # regular case: both files non-empty
1335                 mingw_read_file_strip_cr_ test_cmp_a <"$1"
1336                 mingw_read_file_strip_cr_ test_cmp_b <"$2"
1337         elif test -s "$1" && test "$2" = -
1338         then
1339                 # read 2nd file from stdin
1340                 mingw_read_file_strip_cr_ test_cmp_a <"$1"
1341                 mingw_read_file_strip_cr_ test_cmp_b
1342                 stdin_for_diff='<<<"$test_cmp_b"'
1343         elif test "$1" = - && test -s "$2"
1344         then
1345                 # read 1st file from stdin
1346                 mingw_read_file_strip_cr_ test_cmp_a
1347                 mingw_read_file_strip_cr_ test_cmp_b <"$2"
1348                 stdin_for_diff='<<<"$test_cmp_a"'
1349         fi
1350         test -n "$test_cmp_a" &&
1351         test -n "$test_cmp_b" &&
1352         test "$test_cmp_a" = "$test_cmp_b" ||
1353         eval "diff -u \"\$@\" $stdin_for_diff"
1354 }
1355
1356 # $1 is the name of the shell variable to fill in
1357 mingw_read_file_strip_cr_ () {
1358         # Read line-wise using LF as the line separator
1359         # and use IFS to strip CR.
1360         local line
1361         while :
1362         do
1363                 if IFS=$'\r' read -r -d $'\n' line
1364                 then
1365                         # good
1366                         line=$line$'\n'
1367                 else
1368                         # we get here at EOF, but also if the last line
1369                         # was not terminated by LF; in the latter case,
1370                         # some text was read
1371                         if test -z "$line"
1372                         then
1373                                 # EOF, really
1374                                 break
1375                         fi
1376                 fi
1377                 eval "$1=\$$1\$line"
1378         done
1379 }
1380
1381 # Like "env FOO=BAR some-program", but run inside a subshell, which means
1382 # it also works for shell functions (though those functions cannot impact
1383 # the environment outside of the test_env invocation).
1384 test_env () {
1385         (
1386                 while test $# -gt 0
1387                 do
1388                         case "$1" in
1389                         *=*)
1390                                 eval "${1%%=*}=\${1#*=}"
1391                                 eval "export ${1%%=*}"
1392                                 shift
1393                                 ;;
1394                         *)
1395                                 "$@" 2>&7
1396                                 exit
1397                                 ;;
1398                         esac
1399                 done
1400         )
1401 } 7>&2 2>&4
1402
1403 # Returns true if the numeric exit code in "$2" represents the expected signal
1404 # in "$1". Signals should be given numerically.
1405 test_match_signal () {
1406         if test "$2" = "$((128 + $1))"
1407         then
1408                 # POSIX
1409                 return 0
1410         elif test "$2" = "$((256 + $1))"
1411         then
1412                 # ksh
1413                 return 0
1414         fi
1415         return 1
1416 }
1417
1418 # Read up to "$1" bytes (or to EOF) from stdin and write them to stdout.
1419 test_copy_bytes () {
1420         perl -e '
1421                 my $len = $ARGV[1];
1422                 while ($len > 0) {
1423                         my $s;
1424                         my $nread = sysread(STDIN, $s, $len);
1425                         die "cannot read: $!" unless defined($nread);
1426                         last unless $nread;
1427                         print $s;
1428                         $len -= $nread;
1429                 }
1430         ' - "$1"
1431 }
1432
1433 # run "$@" inside a non-git directory
1434 nongit () {
1435         test -d non-repo ||
1436         mkdir non-repo ||
1437         return 1
1438
1439         (
1440                 GIT_CEILING_DIRECTORIES=$(pwd) &&
1441                 export GIT_CEILING_DIRECTORIES &&
1442                 cd non-repo &&
1443                 "$@" 2>&7
1444         )
1445 } 7>&2 2>&4
1446
1447 # convert function arguments or stdin (if not arguments given) to pktline
1448 # representation. If multiple arguments are given, they are separated by
1449 # whitespace and put in a single packet. Note that data containing NULs must be
1450 # given on stdin, and that empty input becomes an empty packet, not a flush
1451 # packet (for that you can just print 0000 yourself).
1452 packetize () {
1453         if test $# -gt 0
1454         then
1455                 packet="$*"
1456                 printf '%04x%s' "$((4 + ${#packet}))" "$packet"
1457         else
1458                 perl -e '
1459                         my $packet = do { local $/; <STDIN> };
1460                         printf "%04x%s", 4 + length($packet), $packet;
1461                 '
1462         fi
1463 }
1464
1465 # Parse the input as a series of pktlines, writing the result to stdout.
1466 # Sideband markers are removed automatically, and the output is routed to
1467 # stderr if appropriate.
1468 #
1469 # NUL bytes are converted to "\\0" for ease of parsing with text tools.
1470 depacketize () {
1471         perl -e '
1472                 while (read(STDIN, $len, 4) == 4) {
1473                         if ($len eq "0000") {
1474                                 print "FLUSH\n";
1475                         } else {
1476                                 read(STDIN, $buf, hex($len) - 4);
1477                                 $buf =~ s/\0/\\0/g;
1478                                 if ($buf =~ s/^[\x2\x3]//) {
1479                                         print STDERR $buf;
1480                                 } else {
1481                                         $buf =~ s/^\x1//;
1482                                         print $buf;
1483                                 }
1484                         }
1485                 }
1486         '
1487 }
1488
1489 # Converts base-16 data into base-8. The output is given as a sequence of
1490 # escaped octals, suitable for consumption by 'printf'.
1491 hex2oct () {
1492         perl -ne 'printf "\\%03o", hex for /../g'
1493 }
1494
1495 # Set the hash algorithm in use to $1.  Only useful when testing the testsuite.
1496 test_set_hash () {
1497         test_hash_algo="$1"
1498 }
1499
1500 # Detect the hash algorithm in use.
1501 test_detect_hash () {
1502         test_hash_algo="${GIT_TEST_DEFAULT_HASH:-sha1}"
1503 }
1504
1505 # Load common hash metadata and common placeholder object IDs for use with
1506 # test_oid.
1507 test_oid_init () {
1508         test -n "$test_hash_algo" || test_detect_hash &&
1509         test_oid_cache <"$TEST_DIRECTORY/oid-info/hash-info" &&
1510         test_oid_cache <"$TEST_DIRECTORY/oid-info/oid"
1511 }
1512
1513 # Load key-value pairs from stdin suitable for use with test_oid.  Blank lines
1514 # and lines starting with "#" are ignored.  Keys must be shell identifier
1515 # characters.
1516 #
1517 # Examples:
1518 # rawsz sha1:20
1519 # rawsz sha256:32
1520 test_oid_cache () {
1521         local tag rest k v &&
1522
1523         { test -n "$test_hash_algo" || test_detect_hash; } &&
1524         while read tag rest
1525         do
1526                 case $tag in
1527                 \#*)
1528                         continue;;
1529                 ?*)
1530                         # non-empty
1531                         ;;
1532                 *)
1533                         # blank line
1534                         continue;;
1535                 esac &&
1536
1537                 k="${rest%:*}" &&
1538                 v="${rest#*:}" &&
1539
1540                 if ! expr "$k" : '[a-z0-9][a-z0-9]*$' >/dev/null
1541                 then
1542                         BUG 'bad hash algorithm'
1543                 fi &&
1544                 eval "test_oid_${k}_$tag=\"\$v\""
1545         done
1546 }
1547
1548 # Look up a per-hash value based on a key ($1).  The value must have been loaded
1549 # by test_oid_init or test_oid_cache.
1550 test_oid () {
1551         local algo="${test_hash_algo}" &&
1552
1553         case "$1" in
1554         --hash=*)
1555                 algo="${1#--hash=}" &&
1556                 shift;;
1557         *)
1558                 ;;
1559         esac &&
1560
1561         local var="test_oid_${algo}_$1" &&
1562
1563         # If the variable is unset, we must be missing an entry for this
1564         # key-hash pair, so exit with an error.
1565         if eval "test -z \"\${$var+set}\""
1566         then
1567                 BUG "undefined key '$1'"
1568         fi &&
1569         eval "printf '%s' \"\${$var}\""
1570 }
1571
1572 # Insert a slash into an object ID so it can be used to reference a location
1573 # under ".git/objects".  For example, "deadbeef..." becomes "de/adbeef..".
1574 test_oid_to_path () {
1575         local basename=${1#??}
1576         echo "${1%$basename}/$basename"
1577 }
1578
1579 # Choose a port number based on the test script's number and store it in
1580 # the given variable name, unless that variable already contains a number.
1581 test_set_port () {
1582         local var=$1 port
1583
1584         if test $# -ne 1 || test -z "$var"
1585         then
1586                 BUG "test_set_port requires a variable name"
1587         fi
1588
1589         eval port=\$$var
1590         case "$port" in
1591         "")
1592                 # No port is set in the given env var, use the test
1593                 # number as port number instead.
1594                 # Remove not only the leading 't', but all leading zeros
1595                 # as well, so the arithmetic below won't (mis)interpret
1596                 # a test number like '0123' as an octal value.
1597                 port=${this_test#${this_test%%[1-9]*}}
1598                 if test "${port:-0}" -lt 1024
1599                 then
1600                         # root-only port, use a larger one instead.
1601                         port=$(($port + 10000))
1602                 fi
1603                 ;;
1604         *[!0-9]*|0*)
1605                 error >&7 "invalid port number: $port"
1606                 ;;
1607         *)
1608                 # The user has specified the port.
1609                 ;;
1610         esac
1611
1612         # Make sure that parallel '--stress' test jobs get different
1613         # ports.
1614         port=$(($port + ${GIT_TEST_STRESS_JOB_NR:-0}))
1615         eval $var=$port
1616 }
1617
1618 # Tests for the hidden file attribute on Windows
1619 test_path_is_hidden () {
1620         test_have_prereq MINGW ||
1621         BUG "test_path_is_hidden can only be used on Windows"
1622
1623         # Use the output of `attrib`, ignore the absolute path
1624         case "$("$SYSTEMROOT"/system32/attrib "$1")" in *H*?:*) return 0;; esac
1625         return 1
1626 }
1627
1628 # Check that the given command was invoked as part of the
1629 # trace2-format trace on stdin.
1630 #
1631 #       test_subcommand [!] <command> <args>... < <trace>
1632 #
1633 # For example, to look for an invocation of "git upload-pack
1634 # /path/to/repo"
1635 #
1636 #       GIT_TRACE2_EVENT=event.log git fetch ... &&
1637 #       test_subcommand git upload-pack "$PATH" <event.log
1638 #
1639 # If the first parameter passed is !, this instead checks that
1640 # the given command was not called.
1641 #
1642 test_subcommand () {
1643         local negate=
1644         if test "$1" = "!"
1645         then
1646                 negate=t
1647                 shift
1648         fi
1649
1650         local expr=$(printf '"%s",' "$@")
1651         expr="${expr%,}"
1652
1653         if test -n "$negate"
1654         then
1655                 ! grep "\[$expr\]"
1656         else
1657                 grep "\[$expr\]"
1658         fi
1659 }
1660
1661 # Check that the given command was invoked as part of the
1662 # trace2-format trace on stdin.
1663 #
1664 #       test_region [!] <category> <label> git <command> <args>...
1665 #
1666 # For example, to look for trace2_region_enter("index", "do_read_index", repo)
1667 # in an invocation of "git checkout HEAD~1", run
1668 #
1669 #       GIT_TRACE2_EVENT="$(pwd)/trace.txt" GIT_TRACE2_EVENT_NESTING=10 \
1670 #               git checkout HEAD~1 &&
1671 #       test_region index do_read_index <trace.txt
1672 #
1673 # If the first parameter passed is !, this instead checks that
1674 # the given region was not entered.
1675 #
1676 test_region () {
1677         local expect_exit=0
1678         if test "$1" = "!"
1679         then
1680                 expect_exit=1
1681                 shift
1682         fi
1683
1684         grep -e '"region_enter".*"category":"'"$1"'","label":"'"$2"\" "$3"
1685         exitcode=$?
1686
1687         if test $exitcode != $expect_exit
1688         then
1689                 return 1
1690         fi
1691
1692         grep -e '"region_leave".*"category":"'"$1"'","label":"'"$2"\" "$3"
1693         exitcode=$?
1694
1695         if test $exitcode != $expect_exit
1696         then
1697                 return 1
1698         fi
1699
1700         return 0
1701 }