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. 28test_set_editor () { 29 FAKE_EDITOR="$1" 30export FAKE_EDITOR 31 EDITOR='"$FAKE_EDITOR"' 32export EDITOR 33} 34 35test_set_index_version () { 36 GIT_INDEX_VERSION="$1" 37export GIT_INDEX_VERSION 38} 39 40test_decode_color () { 41awk' 42 function name(n) { 43 if (n == 0) return "RESET"; 44 if (n == 1) return "BOLD"; 45 if (n == 7) return "REVERSE"; 46 if (n == 30) return "BLACK"; 47 if (n == 31) return "RED"; 48 if (n == 32) return "GREEN"; 49 if (n == 33) return "YELLOW"; 50 if (n == 34) return "BLUE"; 51 if (n == 35) return "MAGENTA"; 52 if (n == 36) return "CYAN"; 53 if (n == 37) return "WHITE"; 54 if (n == 40) return "BLACK"; 55 if (n == 41) return "BRED"; 56 if (n == 42) return "BGREEN"; 57 if (n == 43) return "BYELLOW"; 58 if (n == 44) return "BBLUE"; 59 if (n == 45) return "BMAGENTA"; 60 if (n == 46) return "BCYAN"; 61 if (n == 47) return "BWHITE"; 62 } 63 { 64 while (match($0, /\033\[[0-9;]*m/) != 0) { 65 printf "%s<", substr($0, 1, RSTART-1); 66 codes = substr($0, RSTART+2, RLENGTH-3); 67 if (length(codes) == 0) 68 printf "%s", name(0) 69 else { 70 n = split(codes, ary, ";"); 71 sep = ""; 72 for (i = 1; i <= n; i++) { 73 printf "%s%s", sep, name(ary[i]); 74 sep = ";" 75 } 76 } 77 printf ">"; 78$0= substr($0, RSTART + RLENGTH, length($0) - RSTART - RLENGTH + 1); 79 } 80 print 81 } 82 ' 83} 84 85lf_to_nul () { 86 perl -pe'y/\012/\000/' 87} 88 89nul_to_q () { 90 perl -pe'y/\000/Q/' 91} 92 93q_to_nul () { 94 perl -pe'y/Q/\000/' 95} 96 97q_to_cr () { 98tr Q '\015' 99} 100 101q_to_tab () { 102tr Q '\011' 103} 104 105qz_to_tab_space () { 106tr QZ '\011\040' 107} 108 109append_cr () { 110sed-e's/$/Q/'|tr Q '\015' 111} 112 113remove_cr () { 114tr'\015' Q |sed-e's/Q$//' 115} 116 117# In some bourne shell implementations, the "unset" builtin returns 118# nonzero status when a variable to be unset was not set in the first 119# place. 120# 121# Use sane_unset when that should not be considered an error. 122 123sane_unset () { 124unset"$@" 125return0 126} 127 128test_tick () { 129iftest -z"${test_tick+set}" 130then 131 test_tick=1112911993 132else 133 test_tick=$(($test_tick + 60)) 134fi 135 GIT_COMMITTER_DATE="$test_tick-0700" 136 GIT_AUTHOR_DATE="$test_tick-0700" 137export GIT_COMMITTER_DATE GIT_AUTHOR_DATE 138} 139 140# Stop execution and start a shell. This is useful for debugging tests. 141# 142# Be sure to remove all invocations of this command before submitting. 143 144test_pause () { 145"$SHELL_PATH"<&6>&5 2>&7 146} 147 148# Wrap git with a debugger. Adding this to a command can make it easier 149# to understand what is going on in a failing test. 150# 151# Examples: 152# debug git checkout master 153# debug --debugger=nemiver git $ARGS 154# debug -d "valgrind --tool=memcheck --track-origins=yes" git $ARGS 155debug () { 156case"$1"in 157-d) 158 GIT_DEBUGGER="$2"&& 159shift2 160;; 161--debugger=*) 162 GIT_DEBUGGER="${1#*=}"&& 163shift1 164;; 165*) 166 GIT_DEBUGGER=1 167;; 168esac&& 169 GIT_DEBUGGER="${GIT_DEBUGGER}""$@"<&6>&5 2>&7 170} 171 172# Call test_commit with the arguments 173# [-C <directory>] <message> [<file> [<contents> [<tag>]]]" 174# 175# This will commit a file with the given contents and the given commit 176# message, and tag the resulting commit with the given tag name. 177# 178# <file>, <contents>, and <tag> all default to <message>. 179# 180# If the first argument is "-C", the second argument is used as a path for 181# the git invocations. 182 183test_commit () { 184 notick= && 185 signoff= && 186 indir= && 187whiletest$#!=0 188do 189case"$1"in 190--notick) 191 notick=yes 192;; 193--signoff) 194 signoff="$1" 195;; 196-C) 197 indir="$2" 198shift 199;; 200*) 201break 202;; 203esac 204shift 205done&& 206 indir=${indir:+"$indir"/}&& 207file=${2:-"$1.t"}&& 208echo"${3-$1}">"$indir$file"&& 209 git ${indir:+ -C "$indir"} add "$file"&& 210iftest -z"$notick" 211then 212 test_tick 213fi&& 214 git ${indir:+ -C "$indir"} commit $signoff-m"$1"&& 215 git ${indir:+ -C "$indir"} tag "${4:-$1}" 216} 217 218# Call test_merge with the arguments "<message> <commit>", where <commit> 219# can be a tag pointing to the commit-to-merge. 220 221test_merge () { 222 test_tick && 223 git merge -m"$1""$2"&& 224 git tag "$1" 225} 226 227# This function helps systems where core.filemode=false is set. 228# Use it instead of plain 'chmod +x' to set or unset the executable bit 229# of a file in the working directory and add it to the index. 230 231test_chmod () { 232chmod"$@"&& 233 git update-index --add"--chmod=$@" 234} 235 236# Get the modebits from a file. 237test_modebits () { 238ls-l"$1"|sed-e's|^\(..........\).*|\1|' 239} 240 241# Unset a configuration variable, but don't fail if it doesn't exist. 242test_unconfig () { 243 config_dir= 244iftest"$1"=-C 245then 246shift 247 config_dir=$1 248shift 249fi 250 git ${config_dir:+-C "$config_dir"} config --unset-all"$@" 251 config_status=$? 252case"$config_status"in 2535)# ok, nothing to unset 254 config_status=0 255;; 256esac 257return$config_status 258} 259 260# Set git config, automatically unsetting it after the test is over. 261test_config () { 262 config_dir= 263iftest"$1"=-C 264then 265shift 266 config_dir=$1 267shift 268fi 269 test_when_finished "test_unconfig${config_dir:+-C '$config_dir'}'$1'"&& 270 git ${config_dir:+-C "$config_dir"} config "$@" 271} 272 273test_config_global () { 274 test_when_finished "test_unconfig --global '$1'"&& 275 git config --global"$@" 276} 277 278write_script () { 279{ 280echo"#!${2-"$SHELL_PATH"}"&& 281cat 282} >"$1"&& 283chmod+x "$1" 284} 285 286# Use test_set_prereq to tell that a particular prerequisite is available. 287# The prerequisite can later be checked for in two ways: 288# 289# - Explicitly using test_have_prereq. 290# 291# - Implicitly by specifying the prerequisite tag in the calls to 292# test_expect_{success,failure,code}. 293# 294# The single parameter is the prerequisite tag (a simple word, in all 295# capital letters by convention). 296 297test_set_prereq () { 298 satisfied_prereq="$satisfied_prereq$1" 299} 300satisfied_prereq=" " 301lazily_testable_prereq= lazily_tested_prereq= 302 303# Usage: test_lazy_prereq PREREQ 'script' 304test_lazy_prereq () { 305 lazily_testable_prereq="$lazily_testable_prereq$1" 306eval test_prereq_lazily_$1=\$2 307} 308 309test_run_lazy_prereq_ () { 310script=' 311mkdir -p "$TRASH_DIRECTORY/prereq-test-dir" && 312( 313 cd "$TRASH_DIRECTORY/prereq-test-dir" &&'"$2"' 314)' 315 say >&3"checking prerequisite:$1" 316 say >&3"$script" 317 test_eval_ "$script" 318 eval_ret=$? 319rm-rf"$TRASH_DIRECTORY/prereq-test-dir" 320iftest"$eval_ret"=0;then 321 say >&3"prerequisite$1ok" 322else 323 say >&3"prerequisite$1not satisfied" 324fi 325return$eval_ret 326} 327 328test_have_prereq () { 329# prerequisites can be concatenated with ',' 330 save_IFS=$IFS 331 IFS=, 332set -- $* 333 IFS=$save_IFS 334 335 total_prereq=0 336 ok_prereq=0 337 missing_prereq= 338 339for prerequisite 340do 341case"$prerequisite"in 342!*) 343 negative_prereq=t 344 prerequisite=${prerequisite#!} 345;; 346*) 347 negative_prereq= 348esac 349 350case"$lazily_tested_prereq"in 351*"$prerequisite"*) 352;; 353*) 354case"$lazily_testable_prereq"in 355*"$prerequisite"*) 356eval"script=\$test_prereq_lazily_$prerequisite"&& 357if test_run_lazy_prereq_ "$prerequisite""$script" 358then 359 test_set_prereq $prerequisite 360fi 361 lazily_tested_prereq="$lazily_tested_prereq$prerequisite" 362esac 363;; 364esac 365 366 total_prereq=$(($total_prereq + 1)) 367case"$satisfied_prereq"in 368*"$prerequisite"*) 369 satisfied_this_prereq=t 370;; 371*) 372 satisfied_this_prereq= 373esac 374 375case"$satisfied_this_prereq,$negative_prereq"in 376 t,|,t) 377 ok_prereq=$(($ok_prereq + 1)) 378;; 379*) 380# Keep a list of missing prerequisites; restore 381# the negative marker if necessary. 382 prerequisite=${negative_prereq:+!}$prerequisite 383iftest -z"$missing_prereq" 384then 385 missing_prereq=$prerequisite 386else 387 missing_prereq="$prerequisite,$missing_prereq" 388fi 389esac 390done 391 392test$total_prereq=$ok_prereq 393} 394 395test_declared_prereq () { 396case",$test_prereq,"in 397*,$1,*) 398return0 399;; 400esac 401return1 402} 403 404test_verify_prereq () { 405test -z"$test_prereq"|| 406expr>/dev/null "$test_prereq":'[A-Z0-9_,!]*$'|| 407 error "bug in the test script: '$test_prereq' does not look like a prereq" 408} 409 410test_expect_failure () { 411 test_start_ 412test"$#"=3&& { test_prereq=$1;shift; } || test_prereq= 413test"$#"=2|| 414 error "bug in the test script: not 2 or 3 parameters to test-expect-failure" 415 test_verify_prereq 416export test_prereq 417if! test_skip "$@" 418then 419 say >&3"checking known breakage:$2" 420if test_run_ "$2" expecting_failure 421then 422 test_known_broken_ok_ "$1" 423else 424 test_known_broken_failure_ "$1" 425fi 426fi 427 test_finish_ 428} 429 430test_expect_success () { 431 test_start_ 432test"$#"=3&& { test_prereq=$1;shift; } || test_prereq= 433test"$#"=2|| 434 error "bug in the test script: not 2 or 3 parameters to test-expect-success" 435 test_verify_prereq 436export test_prereq 437if! test_skip "$@" 438then 439 say >&3"expecting success:$2" 440if test_run_ "$2" 441then 442 test_ok_ "$1" 443else 444 test_failure_ "$@" 445fi 446fi 447 test_finish_ 448} 449 450# test_external runs external test scripts that provide continuous 451# test output about their progress, and succeeds/fails on 452# zero/non-zero exit code. It outputs the test output on stdout even 453# in non-verbose mode, and announces the external script with "# run 454# <n>: ..." before running it. When providing relative paths, keep in 455# mind that all scripts run in "trash directory". 456# Usage: test_external description command arguments... 457# Example: test_external 'Perl API' perl ../path/to/test.pl 458test_external () { 459test"$#"=4&& { test_prereq=$1;shift; } || test_prereq= 460test"$#"=3|| 461 error >&5"bug in the test script: not 3 or 4 parameters to test_external" 462 descr="$1" 463shift 464 test_verify_prereq 465export test_prereq 466if! test_skip "$descr""$@" 467then 468# Announce the script to reduce confusion about the 469# test output that follows. 470 say_color """# run$test_count:$descr($*)" 471# Export TEST_DIRECTORY, TRASH_DIRECTORY and GIT_TEST_LONG 472# to be able to use them in script 473export TEST_DIRECTORY TRASH_DIRECTORY GIT_TEST_LONG 474# Run command; redirect its stderr to &4 as in 475# test_run_, but keep its stdout on our stdout even in 476# non-verbose mode. 477"$@"2>&4 478iftest"$?"=0 479then 480iftest$test_external_has_tap-eq0;then 481 test_ok_ "$descr" 482else 483 say_color """# test_external test$descrwas ok" 484 test_success=$(($test_success + 1)) 485fi 486else 487iftest$test_external_has_tap-eq0;then 488 test_failure_ "$descr""$@" 489else 490 say_color error "# test_external test$descrfailed: $@" 491 test_failure=$(($test_failure + 1)) 492fi 493fi 494fi 495} 496 497# Like test_external, but in addition tests that the command generated 498# no output on stderr. 499test_external_without_stderr () { 500# The temporary file has no (and must have no) security 501# implications. 502 tmp=${TMPDIR:-/tmp} 503 stderr="$tmp/git-external-stderr.$$.tmp" 504 test_external "$@"4>"$stderr" 505test -f"$stderr"|| error "Internal error:$stderrdisappeared." 506 descr="no stderr:$1" 507shift 508 say >&3"# expecting no stderr from previous command" 509iftest!-s"$stderr" 510then 511rm"$stderr" 512 513iftest$test_external_has_tap-eq0;then 514 test_ok_ "$descr" 515else 516 say_color """# test_external_without_stderr test$descrwas ok" 517 test_success=$(($test_success + 1)) 518fi 519else 520iftest"$verbose"= t 521then 522 output=$(echo; echo "# Stderr is:"; cat "$stderr") 523else 524 output= 525fi 526# rm first in case test_failure exits. 527rm"$stderr" 528iftest$test_external_has_tap-eq0;then 529 test_failure_ "$descr""$@""$output" 530else 531 say_color error "# test_external_without_stderr test$descrfailed: $@:$output" 532 test_failure=$(($test_failure + 1)) 533fi 534fi 535} 536 537# debugging-friendly alternatives to "test [-f|-d|-e]" 538# The commands test the existence or non-existence of $1. $2 can be 539# given to provide a more precise diagnosis. 540test_path_is_file () { 541if!test -f"$1" 542then 543echo"File$1doesn't exist.$2" 544 false 545fi 546} 547 548test_path_is_dir () { 549if!test -d"$1" 550then 551echo"Directory$1doesn't exist.$2" 552 false 553fi 554} 555 556# Check if the directory exists and is empty as expected, barf otherwise. 557test_dir_is_empty () { 558 test_path_is_dir "$1"&& 559iftest -n"$(ls -a1 "$1" | egrep -v '^\.\.?$')" 560then 561echo"Directory '$1' is not empty, it contains:" 562ls-la"$1" 563return1 564fi 565} 566 567test_path_is_missing () { 568iftest -e"$1" 569then 570echo"Path exists:" 571ls-ld"$1" 572iftest$#-ge1 573then 574echo"$*" 575fi 576 false 577fi 578} 579 580# test_line_count checks that a file has the number of lines it 581# ought to. For example: 582# 583# test_expect_success 'produce exactly one line of output' ' 584# do something >output && 585# test_line_count = 1 output 586# ' 587# 588# is like "test $(wc -l <output) = 1" except that it passes the 589# output through when the number of lines is wrong. 590 591test_line_count () { 592iftest$#!=3 593then 594 error "bug in the test script: not 3 parameters to test_line_count" 595elif!test$(wc -l <"$3")"$1""$2" 596then 597echo"test_line_count: line count for$3!$1$2" 598cat"$3" 599return1 600fi 601} 602 603# Returns success if a comma separated string of keywords ($1) contains a 604# given keyword ($2). 605# Examples: 606# `list_contains "foo,bar" bar` returns 0 607# `list_contains "foo" bar` returns 1 608 609list_contains () { 610case",$1,"in 611*,$2,*) 612return0 613;; 614esac 615return1 616} 617 618# This is not among top-level (test_expect_success | test_expect_failure) 619# but is a prefix that can be used in the test script, like: 620# 621# test_expect_success 'complain and die' ' 622# do something && 623# do something else && 624# test_must_fail git checkout ../outerspace 625# ' 626# 627# Writing this as "! git checkout ../outerspace" is wrong, because 628# the failure could be due to a segv. We want a controlled failure. 629# 630# Accepts the following options: 631# 632# ok=<signal-name>[,<...>]: 633# Don't treat an exit caused by the given signal as error. 634# Multiple signals can be specified as a comma separated list. 635# Currently recognized signal names are: sigpipe, success. 636# (Don't use 'success', use 'test_might_fail' instead.) 637 638test_must_fail () { 639case"$1"in 640 ok=*) 641 _test_ok=${1#ok=} 642shift 643;; 644*) 645 _test_ok= 646;; 647esac 648"$@"2>&7 649 exit_code=$? 650iftest$exit_code-eq0&& ! list_contains "$_test_ok" success 651then 652echo>&4"test_must_fail: command succeeded: $*" 653return1 654elif test_match_signal 13$exit_code&& list_contains "$_test_ok" sigpipe 655then 656return0 657eliftest$exit_code-gt129&&test$exit_code-le192 658then 659echo>&4"test_must_fail: died by signal$(($exit_code - 128)): $*" 660return1 661eliftest$exit_code-eq127 662then 663echo>&4"test_must_fail: command not found: $*" 664return1 665eliftest$exit_code-eq126 666then 667echo>&4"test_must_fail: valgrind error: $*" 668return1 669fi 670return0 671}7>&2 2>&4 672 673# Similar to test_must_fail, but tolerates success, too. This is 674# meant to be used in contexts like: 675# 676# test_expect_success 'some command works without configuration' ' 677# test_might_fail git config --unset all.configuration && 678# do something 679# ' 680# 681# Writing "git config --unset all.configuration || :" would be wrong, 682# because we want to notice if it fails due to segv. 683# 684# Accepts the same options as test_must_fail. 685 686test_might_fail () { 687 test_must_fail ok=success "$@"2>&7 688}7>&2 2>&4 689 690# Similar to test_must_fail and test_might_fail, but check that a 691# given command exited with a given exit code. Meant to be used as: 692# 693# test_expect_success 'Merge with d/f conflicts' ' 694# test_expect_code 1 git merge "merge msg" B master 695# ' 696 697test_expect_code () { 698 want_code=$1 699shift 700"$@"2>&7 701 exit_code=$? 702iftest$exit_code=$want_code 703then 704return0 705fi 706 707echo>&4"test_expect_code: command exited with$exit_code, we wanted$want_code$*" 708return1 709}7>&2 2>&4 710 711# test_cmp is a helper function to compare actual and expected output. 712# You can use it like: 713# 714# test_expect_success 'foo works' ' 715# echo expected >expected && 716# foo >actual && 717# test_cmp expected actual 718# ' 719# 720# This could be written as either "cmp" or "diff -u", but: 721# - cmp's output is not nearly as easy to read as diff -u 722# - not all diff versions understand "-u" 723 724test_cmp() { 725$GIT_TEST_CMP"$@" 726} 727 728# test_cmp_bin - helper to compare binary files 729 730test_cmp_bin() { 731cmp"$@" 732} 733 734# Use this instead of test_cmp to compare files that contain expected and 735# actual output from git commands that can be translated. When running 736# under GETTEXT_POISON this pretends that the command produced expected 737# results. 738test_i18ncmp () { 739test -n"$GETTEXT_POISON"|| test_cmp "$@" 740} 741 742# Use this instead of "grep expected-string actual" to see if the 743# output from a git command that can be translated either contains an 744# expected string, or does not contain an unwanted one. When running 745# under GETTEXT_POISON this pretends that the command produced expected 746# results. 747test_i18ngrep () { 748eval"last_arg=\${$#}" 749 750test -f"$last_arg"|| 751 error "bug in the test script: test_i18ngrep requires a file" \ 752"to read as the last parameter" 753 754iftest$#-lt2|| 755{test"x!"="x$1"&&test$#-lt3; } 756then 757 error "bug in the test script: too few parameters to test_i18ngrep" 758fi 759 760iftest -n"$GETTEXT_POISON" 761then 762# pretend success 763return0 764fi 765 766iftest"x!"="x$1" 767then 768shift 769!grep"$@"&&return0 770 771echo>&4"error: '! grep $@' did find a match in:" 772else 773grep"$@"&&return0 774 775echo>&4"error: 'grep $@' didn't find a match in:" 776fi 777 778iftest -s"$last_arg" 779then 780cat>&4"$last_arg" 781else 782echo>&4"<File '$last_arg' is empty>" 783fi 784 785return1 786} 787 788# Call any command "$@" but be more verbose about its 789# failure. This is handy for commands like "test" which do 790# not output anything when they fail. 791verbose () { 792"$@"&&return0 793echo>&4"command failed:$(git rev-parse --sq-quote "$@")" 794return1 795} 796 797# Check if the file expected to be empty is indeed empty, and barfs 798# otherwise. 799 800test_must_be_empty () { 801 test_path_is_file "$1"&& 802iftest -s"$1" 803then 804echo"'$1' is not empty, it contains:" 805cat"$1" 806return1 807fi 808} 809 810# Tests that its two parameters refer to the same revision 811test_cmp_rev () { 812 git rev-parse --verify"$1">expect.rev&& 813 git rev-parse --verify"$2">actual.rev&& 814 test_cmp expect.rev actual.rev 815} 816 817# Print a sequence of integers in increasing order, either with 818# two arguments (start and end): 819# 820# test_seq 1 5 -- outputs 1 2 3 4 5 one line at a time 821# 822# or with one argument (end), in which case it starts counting 823# from 1. 824 825test_seq () { 826case$#in 8271)set1"$@";; 8282) ;; 829*) error "bug in the test script: not 1 or 2 parameters to test_seq";; 830esac 831 test_seq_counter__=$1 832whiletest"$test_seq_counter__"-le"$2" 833do 834echo"$test_seq_counter__" 835 test_seq_counter__=$(( $test_seq_counter__ + 1 )) 836done 837} 838 839# This function can be used to schedule some commands to be run 840# unconditionally at the end of the test to restore sanity: 841# 842# test_expect_success 'test core.capslock' ' 843# git config core.capslock true && 844# test_when_finished "git config --unset core.capslock" && 845# hello world 846# ' 847# 848# That would be roughly equivalent to 849# 850# test_expect_success 'test core.capslock' ' 851# git config core.capslock true && 852# hello world 853# git config --unset core.capslock 854# ' 855# 856# except that the greeting and config --unset must both succeed for 857# the test to pass. 858# 859# Note that under --immediate mode, no clean-up is done to help diagnose 860# what went wrong. 861 862test_when_finished () { 863# We cannot detect when we are in a subshell in general, but by 864# doing so on Bash is better than nothing (the test will 865# silently pass on other shells). 866test"${BASH_SUBSHELL-0}"=0|| 867 error "bug in test script: test_when_finished does nothing in a subshell" 868 test_cleanup="{ $* 869 } && (exit\"\$eval_ret\"); eval_ret=\$?;$test_cleanup" 870} 871 872# Most tests can use the created repository, but some may need to create more. 873# Usage: test_create_repo <directory> 874test_create_repo () { 875test"$#"=1|| 876 error "bug in the test script: not 1 parameter to test-create-repo" 877 repo="$1" 878mkdir-p"$repo" 879( 880cd"$repo"|| error "Cannot setup test environment" 881"$GIT_EXEC_PATH/git-init""--template=$GIT_BUILD_DIR/templates/blt/">&3 2>&4|| 882 error "cannot run git init -- have you built things yet?" 883mv .git/hooks .git/hooks-disabled 884) ||exit 885} 886 887# This function helps on symlink challenged file systems when it is not 888# important that the file system entry is a symbolic link. 889# Use test_ln_s_add instead of "ln -s x y && git add y" to add a 890# symbolic link entry y to the index. 891 892test_ln_s_add () { 893if test_have_prereq SYMLINKS 894then 895ln-s"$1""$2"&& 896 git update-index --add"$2" 897else 898printf'%s'"$1">"$2"&& 899 ln_s_obj=$(git hash-object -w "$2")&& 900 git update-index --add --cacheinfo120000$ln_s_obj"$2"&& 901# pick up stat info from the file 902 git update-index"$2" 903fi 904} 905 906# This function writes out its parameters, one per line 907test_write_lines () { 908printf"%s\n""$@" 909} 910 911perl () { 912command"$PERL_PATH""$@"2>&7 913}7>&2 2>&4 914 915# Is the value one of the various ways to spell a boolean true/false? 916test_normalize_bool () { 917 git -c magic.variable="$1" config --bool magic.variable 2>/dev/null 918} 919 920# Given a variable $1, normalize the value of it to one of "true", 921# "false", or "auto" and store the result to it. 922# 923# test_tristate GIT_TEST_HTTPD 924# 925# A variable set to an empty string is set to 'false'. 926# A variable set to 'false' or 'auto' keeps its value. 927# Anything else is set to 'true'. 928# An unset variable defaults to 'auto'. 929# 930# The last rule is to allow people to set the variable to an empty 931# string and export it to decline testing the particular feature 932# for versions both before and after this change. We used to treat 933# both unset and empty variable as a signal for "do not test" and 934# took any non-empty string as "please test". 935 936test_tristate () { 937ifeval"test x\"\${$1+isset}\"= xisset" 938then 939# explicitly set 940eval" 941 case\"\$$1\"in 942 '')$1=false ;; 943 auto) ;; 944 *)$1=\$(test_normalize_bool \$$1 || echo true);; 945 esac 946 " 947else 948eval"$1=auto" 949fi 950} 951 952# Exit the test suite, either by skipping all remaining tests or by 953# exiting with an error. If "$1" is "auto", we then we assume we were 954# opportunistically trying to set up some tests and we skip. If it is 955# "true", then we report a failure. 956# 957# The error/skip message should be given by $2. 958# 959test_skip_or_die () { 960case"$1"in 961 auto) 962 skip_all=$2 963 test_done 964;; 965 true) 966 error "$2" 967;; 968*) 969 error "BUG: test tristate is '$1' (real error:$2)" 970esac 971} 972 973# The following mingw_* functions obey POSIX shell syntax, but are actually 974# bash scripts, and are meant to be used only with bash on Windows. 975 976# A test_cmp function that treats LF and CRLF equal and avoids to fork 977# diff when possible. 978mingw_test_cmp () { 979# Read text into shell variables and compare them. If the results 980# are different, use regular diff to report the difference. 981local test_cmp_a= test_cmp_b= 982 983# When text came from stdin (one argument is '-') we must feed it 984# to diff. 985local stdin_for_diff= 986 987# Since it is difficult to detect the difference between an 988# empty input file and a failure to read the files, we go straight 989# to diff if one of the inputs is empty. 990iftest -s"$1"&&test -s"$2" 991then 992# regular case: both files non-empty 993 mingw_read_file_strip_cr_ test_cmp_a <"$1" 994 mingw_read_file_strip_cr_ test_cmp_b <"$2" 995eliftest -s"$1"&&test"$2"= - 996then 997# read 2nd file from stdin 998 mingw_read_file_strip_cr_ test_cmp_a <"$1" 999 mingw_read_file_strip_cr_ test_cmp_b1000 stdin_for_diff='<<<"$test_cmp_b"'1001eliftest"$1"= - &&test -s"$2"1002then1003# read 1st file from stdin1004 mingw_read_file_strip_cr_ test_cmp_a1005 mingw_read_file_strip_cr_ test_cmp_b <"$2"1006 stdin_for_diff='<<<"$test_cmp_a"'1007fi1008test -n"$test_cmp_a"&&1009test -n"$test_cmp_b"&&1010test"$test_cmp_a"="$test_cmp_b"||1011eval"diff -u\"\$@\"$stdin_for_diff"1012}10131014# $1 is the name of the shell variable to fill in1015mingw_read_file_strip_cr_ () {1016# Read line-wise using LF as the line separator1017# and use IFS to strip CR.1018local line1019while:1020do1021if IFS=$'\r'read -r -d $'\n' line1022then1023# good1024 line=$line$'\n'1025else1026# we get here at EOF, but also if the last line1027# was not terminated by LF; in the latter case,1028# some text was read1029iftest -z"$line"1030then1031# EOF, really1032break1033fi1034fi1035eval"$1=\$$1\$line"1036done1037}10381039# Like "env FOO=BAR some-program", but run inside a subshell, which means1040# it also works for shell functions (though those functions cannot impact1041# the environment outside of the test_env invocation).1042test_env () {1043(1044whiletest$#-gt01045do1046case"$1"in1047*=*)1048eval"${1%%=*}=\${1#*=}"1049eval"export${1%%=*}"1050shift1051;;1052*)1053"$@"2>&71054exit1055;;1056esac1057done1058)1059}7>&2 2>&410601061# Returns true if the numeric exit code in "$2" represents the expected signal1062# in "$1". Signals should be given numerically.1063test_match_signal () {1064iftest"$2"="$((128 + $1))"1065then1066# POSIX1067return01068eliftest"$2"="$((256 + $1))"1069then1070# ksh1071return01072fi1073return11074}10751076# Read up to "$1" bytes (or to EOF) from stdin and write them to stdout.1077test_copy_bytes () {1078 perl -e'1079 my$len=$ARGV[1];1080 while ($len> 0) {1081 my$s;1082 my$nread= sysread(STDIN,$s,$len);1083 die "cannot read: $!" unless defined($nread);1084 last unless$nread;1085 print$s;1086$len-=$nread;1087 }1088 '-"$1"1089}10901091# run "$@" inside a non-git directory1092nongit () {1093test -d non-repo||1094mkdir non-repo||1095return110961097(1098 GIT_CEILING_DIRECTORIES=$(pwd)&&1099export GIT_CEILING_DIRECTORIES &&1100cd non-repo&&1101"$@"2>&71102)1103}7>&2 2>&411041105# convert stdin to pktline representation; note that empty input becomes an1106# empty packet, not a flush packet (for that you can just print 0000 yourself).1107packetize() {1108cat>packetize.tmp &&1109 len=$(wc -c <packetize.tmp)&&1110printf'%04x%s'"$(($len + 4))"&&1111cat packetize.tmp &&1112rm-f packetize.tmp1113}11141115# Parse the input as a series of pktlines, writing the result to stdout.1116# Sideband markers are removed automatically, and the output is routed to1117# stderr if appropriate.1118#1119# NUL bytes are converted to "\\0" for ease of parsing with text tools.1120depacketize () {1121 perl -e'1122 while (read(STDIN,$len, 4) == 4) {1123 if ($leneq "0000") {1124 print "FLUSH\n";1125 } else {1126 read(STDIN,$buf, hex($len) - 4);1127$buf=~ s/\0/\\0/g;1128 if ($buf=~ s/^[\x2\x3]//) {1129 print STDERR$buf;1130 } else {1131$buf=~ s/^\x1//;1132 print$buf;1133 }1134 }1135 }1136 '1137}