mirror of
https://github.com/git/git
synced 2024-08-27 11:39:22 +00:00
![Martin Ågren](/assets/img/avatar_default.png)
`test_path_is_missing` was introduced back in2caf20c52b
("test-lib: user-friendly alternatives to test [-d|-f|-e]", 2010-08-10). It took the path that was supposed to be missing, as well as an optional "diagnosis" that would be echoed if the path was found to be alive. Commit45a2686441
("test-lib-functions: remove bug-inducing "diagnostics" helper param", 2021-02-12) dropped this diagnostic functionality from several `test_path_is_foo` helpers, but note how it tweaked the README entry on `test_path_is_missing` without actually adjusting its implementation. Commite7884b353b
("test-lib-functions: assert correct parameter count", 2021-02-12) then followed up by asserting that we get just a single argument. This history leaves us in a state where we assert that we have exactly one argument, then go on to anyway check for arguments, echoing them all. It's clear that we can simplify this code. We should also note that we run `ls -ld "$1"`, so printing the filename a second time doesn't really buy us anything. Thus, we can drop the whole `if` block as redundant. Signed-off-by: Martin Ågren <martin.agren@gmail.com> Signed-off-by: Taylor Blau <me@ttaylorr.com>
1878 lines
42 KiB
Bash
1878 lines
42 KiB
Bash
# Library of functions shared by all tests scripts, included by
|
|
# test-lib.sh.
|
|
#
|
|
# Copyright (c) 2005 Junio C Hamano
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see http://www.gnu.org/licenses/ .
|
|
|
|
# The semantics of the editor variables are that of invoking
|
|
# sh -c "$EDITOR \"$@\"" files ...
|
|
#
|
|
# If our trash directory contains shell metacharacters, they will be
|
|
# interpreted if we just set $EDITOR directly, so do a little dance with
|
|
# environment variables to work around this.
|
|
#
|
|
# In particular, quoting isn't enough, as the path may contain the same quote
|
|
# that we're using.
|
|
test_set_editor () {
|
|
FAKE_EDITOR="$1"
|
|
export FAKE_EDITOR
|
|
EDITOR='"$FAKE_EDITOR"'
|
|
export EDITOR
|
|
}
|
|
|
|
test_decode_color () {
|
|
awk '
|
|
function name(n) {
|
|
if (n == 0) return "RESET";
|
|
if (n == 1) return "BOLD";
|
|
if (n == 2) return "FAINT";
|
|
if (n == 3) return "ITALIC";
|
|
if (n == 7) return "REVERSE";
|
|
if (n == 30) return "BLACK";
|
|
if (n == 31) return "RED";
|
|
if (n == 32) return "GREEN";
|
|
if (n == 33) return "YELLOW";
|
|
if (n == 34) return "BLUE";
|
|
if (n == 35) return "MAGENTA";
|
|
if (n == 36) return "CYAN";
|
|
if (n == 37) return "WHITE";
|
|
if (n == 40) return "BLACK";
|
|
if (n == 41) return "BRED";
|
|
if (n == 42) return "BGREEN";
|
|
if (n == 43) return "BYELLOW";
|
|
if (n == 44) return "BBLUE";
|
|
if (n == 45) return "BMAGENTA";
|
|
if (n == 46) return "BCYAN";
|
|
if (n == 47) return "BWHITE";
|
|
}
|
|
{
|
|
while (match($0, /\033\[[0-9;]*m/) != 0) {
|
|
printf "%s<", substr($0, 1, RSTART-1);
|
|
codes = substr($0, RSTART+2, RLENGTH-3);
|
|
if (length(codes) == 0)
|
|
printf "%s", name(0)
|
|
else {
|
|
n = split(codes, ary, ";");
|
|
sep = "";
|
|
for (i = 1; i <= n; i++) {
|
|
printf "%s%s", sep, name(ary[i]);
|
|
sep = ";"
|
|
}
|
|
}
|
|
printf ">";
|
|
$0 = substr($0, RSTART + RLENGTH, length($0) - RSTART - RLENGTH + 1);
|
|
}
|
|
print
|
|
}
|
|
'
|
|
}
|
|
|
|
lf_to_nul () {
|
|
perl -pe 'y/\012/\000/'
|
|
}
|
|
|
|
nul_to_q () {
|
|
perl -pe 'y/\000/Q/'
|
|
}
|
|
|
|
q_to_nul () {
|
|
perl -pe 'y/Q/\000/'
|
|
}
|
|
|
|
q_to_cr () {
|
|
tr Q '\015'
|
|
}
|
|
|
|
q_to_tab () {
|
|
tr Q '\011'
|
|
}
|
|
|
|
qz_to_tab_space () {
|
|
tr QZ '\011\040'
|
|
}
|
|
|
|
append_cr () {
|
|
sed -e 's/$/Q/' | tr Q '\015'
|
|
}
|
|
|
|
remove_cr () {
|
|
tr '\015' Q | sed -e 's/Q$//'
|
|
}
|
|
|
|
# In some bourne shell implementations, the "unset" builtin returns
|
|
# nonzero status when a variable to be unset was not set in the first
|
|
# place.
|
|
#
|
|
# Use sane_unset when that should not be considered an error.
|
|
|
|
sane_unset () {
|
|
unset "$@"
|
|
return 0
|
|
}
|
|
|
|
test_tick () {
|
|
if test -z "${test_tick+set}"
|
|
then
|
|
test_tick=1112911993
|
|
else
|
|
test_tick=$(($test_tick + 60))
|
|
fi
|
|
GIT_COMMITTER_DATE="$test_tick -0700"
|
|
GIT_AUTHOR_DATE="$test_tick -0700"
|
|
export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
|
|
}
|
|
|
|
# Stop execution and start a shell. This is useful for debugging tests.
|
|
#
|
|
# Be sure to remove all invocations of this command before submitting.
|
|
# WARNING: the shell invoked by this helper does not have the same environment
|
|
# as the one running the tests (shell variables and functions are not
|
|
# available, and the options below further modify the environment). As such,
|
|
# commands copied from a test script might behave differently than when
|
|
# running the test.
|
|
#
|
|
# Usage: test_pause [options]
|
|
# -t
|
|
# Use your original TERM instead of test-lib.sh's "dumb".
|
|
# This usually restores color output in the invoked shell.
|
|
# -s
|
|
# Invoke $SHELL instead of $TEST_SHELL_PATH.
|
|
# -h
|
|
# Use your original HOME instead of test-lib.sh's "$TRASH_DIRECTORY".
|
|
# This allows you to use your regular shell environment and Git aliases.
|
|
# CAUTION: running commands copied from a test script into the paused shell
|
|
# might result in files in your HOME being overwritten.
|
|
# -a
|
|
# Shortcut for -t -s -h
|
|
|
|
test_pause () {
|
|
PAUSE_TERM=$TERM &&
|
|
PAUSE_SHELL=$TEST_SHELL_PATH &&
|
|
PAUSE_HOME=$HOME &&
|
|
while test $# != 0
|
|
do
|
|
case "$1" in
|
|
-t)
|
|
PAUSE_TERM="$USER_TERM"
|
|
;;
|
|
-s)
|
|
PAUSE_SHELL="$SHELL"
|
|
;;
|
|
-h)
|
|
PAUSE_HOME="$USER_HOME"
|
|
;;
|
|
-a)
|
|
PAUSE_TERM="$USER_TERM"
|
|
PAUSE_SHELL="$SHELL"
|
|
PAUSE_HOME="$USER_HOME"
|
|
;;
|
|
*)
|
|
break
|
|
;;
|
|
esac
|
|
shift
|
|
done &&
|
|
TERM="$PAUSE_TERM" HOME="$PAUSE_HOME" "$PAUSE_SHELL" <&6 >&5 2>&7
|
|
}
|
|
|
|
# Wrap git with a debugger. Adding this to a command can make it easier
|
|
# to understand what is going on in a failing test.
|
|
#
|
|
# Usage: debug [options] <git command>
|
|
# -d <debugger>
|
|
# --debugger=<debugger>
|
|
# Use <debugger> instead of GDB
|
|
# -t
|
|
# Use your original TERM instead of test-lib.sh's "dumb".
|
|
# This usually restores color output in the debugger.
|
|
# WARNING: the command being debugged might behave differently than when
|
|
# running the test.
|
|
#
|
|
# Examples:
|
|
# debug git checkout master
|
|
# debug --debugger=nemiver git $ARGS
|
|
# debug -d "valgrind --tool=memcheck --track-origins=yes" git $ARGS
|
|
debug () {
|
|
GIT_DEBUGGER=1 &&
|
|
DEBUG_TERM=$TERM &&
|
|
while test $# != 0
|
|
do
|
|
case "$1" in
|
|
-t)
|
|
DEBUG_TERM="$USER_TERM"
|
|
;;
|
|
-d)
|
|
GIT_DEBUGGER="$2" &&
|
|
shift
|
|
;;
|
|
--debugger=*)
|
|
GIT_DEBUGGER="${1#*=}"
|
|
;;
|
|
*)
|
|
break
|
|
;;
|
|
esac
|
|
shift
|
|
done &&
|
|
|
|
dotfiles=".gdbinit .lldbinit"
|
|
|
|
for dotfile in $dotfiles
|
|
do
|
|
dotfile="$USER_HOME/$dotfile" &&
|
|
test -f "$dotfile" && cp "$dotfile" "$HOME" || :
|
|
done &&
|
|
|
|
TERM="$DEBUG_TERM" GIT_DEBUGGER="${GIT_DEBUGGER}" "$@" <&6 >&5 2>&7 &&
|
|
|
|
for dotfile in $dotfiles
|
|
do
|
|
rm -f "$HOME/$dotfile"
|
|
done
|
|
}
|
|
|
|
# Usage: test_commit [options] <message> [<file> [<contents> [<tag>]]]
|
|
# -C <dir>:
|
|
# Run all git commands in directory <dir>
|
|
# --notick
|
|
# Do not call test_tick before making a commit
|
|
# --append
|
|
# Use ">>" instead of ">" when writing "<contents>" to "<file>"
|
|
# --printf
|
|
# Use "printf" instead of "echo" when writing "<contents>" to
|
|
# "<file>", use this to write escape sequences such as "\0", a
|
|
# trailing "\n" won't be added automatically. This option
|
|
# supports nothing but the FORMAT of printf(1), i.e. no custom
|
|
# ARGUMENT(s).
|
|
# --signoff
|
|
# Invoke "git commit" with --signoff
|
|
# --author <author>
|
|
# Invoke "git commit" with --author <author>
|
|
# --no-tag
|
|
# Do not tag the resulting commit
|
|
# --annotate
|
|
# Create an annotated tag with "--annotate -m <message>". Calls
|
|
# test_tick between making the commit and tag, unless --notick
|
|
# is given.
|
|
#
|
|
# This will commit a file with the given contents and the given commit
|
|
# message, and tag the resulting commit with the given tag name.
|
|
#
|
|
# <file>, <contents>, and <tag> all default to <message>.
|
|
|
|
test_commit () {
|
|
local notick= &&
|
|
local echo=echo &&
|
|
local append= &&
|
|
local author= &&
|
|
local signoff= &&
|
|
local indir= &&
|
|
local tag=light &&
|
|
while test $# != 0
|
|
do
|
|
case "$1" in
|
|
--notick)
|
|
notick=yes
|
|
;;
|
|
--printf)
|
|
echo=printf
|
|
;;
|
|
--append)
|
|
append=yes
|
|
;;
|
|
--author)
|
|
author="$2"
|
|
shift
|
|
;;
|
|
--signoff)
|
|
signoff="$1"
|
|
;;
|
|
--date)
|
|
notick=yes
|
|
GIT_COMMITTER_DATE="$2"
|
|
GIT_AUTHOR_DATE="$2"
|
|
shift
|
|
;;
|
|
-C)
|
|
indir="$2"
|
|
shift
|
|
;;
|
|
--no-tag)
|
|
tag=none
|
|
;;
|
|
--annotate)
|
|
tag=annotate
|
|
;;
|
|
*)
|
|
break
|
|
;;
|
|
esac
|
|
shift
|
|
done &&
|
|
indir=${indir:+"$indir"/} &&
|
|
local file=${2:-"$1.t"} &&
|
|
if test -n "$append"
|
|
then
|
|
$echo "${3-$1}" >>"$indir$file"
|
|
else
|
|
$echo "${3-$1}" >"$indir$file"
|
|
fi &&
|
|
git ${indir:+ -C "$indir"} add -- "$file" &&
|
|
if test -z "$notick"
|
|
then
|
|
test_tick
|
|
fi &&
|
|
git ${indir:+ -C "$indir"} commit \
|
|
${author:+ --author "$author"} \
|
|
$signoff -m "$1" &&
|
|
case "$tag" in
|
|
none)
|
|
;;
|
|
light)
|
|
git ${indir:+ -C "$indir"} tag "${4:-$1}"
|
|
;;
|
|
annotate)
|
|
if test -z "$notick"
|
|
then
|
|
test_tick
|
|
fi &&
|
|
git ${indir:+ -C "$indir"} tag -a -m "$1" "${4:-$1}"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Call test_merge with the arguments "<message> <commit>", where <commit>
|
|
# can be a tag pointing to the commit-to-merge.
|
|
|
|
test_merge () {
|
|
label="$1" &&
|
|
shift &&
|
|
test_tick &&
|
|
git merge -m "$label" "$@" &&
|
|
git tag "$label"
|
|
}
|
|
|
|
# Efficiently create <nr> commits, each with a unique number (from 1 to <nr>
|
|
# by default) in the commit message.
|
|
#
|
|
# Usage: test_commit_bulk [options] <nr>
|
|
# -C <dir>:
|
|
# Run all git commands in directory <dir>
|
|
# --ref=<n>:
|
|
# ref on which to create commits (default: HEAD)
|
|
# --start=<n>:
|
|
# number commit messages from <n> (default: 1)
|
|
# --message=<msg>:
|
|
# use <msg> as the commit mesasge (default: "commit %s")
|
|
# --filename=<fn>:
|
|
# modify <fn> in each commit (default: %s.t)
|
|
# --contents=<string>:
|
|
# place <string> in each file (default: "content %s")
|
|
# --id=<string>:
|
|
# shorthand to use <string> and %s in message, filename, and contents
|
|
#
|
|
# The message, filename, and contents strings are evaluated by printf, with the
|
|
# first "%s" replaced by the current commit number. So you can do:
|
|
#
|
|
# test_commit_bulk --filename=file --contents="modification %s"
|
|
#
|
|
# to have every commit touch the same file, but with unique content.
|
|
#
|
|
test_commit_bulk () {
|
|
tmpfile=.bulk-commit.input
|
|
indir=.
|
|
ref=HEAD
|
|
n=1
|
|
message='commit %s'
|
|
filename='%s.t'
|
|
contents='content %s'
|
|
while test $# -gt 0
|
|
do
|
|
case "$1" in
|
|
-C)
|
|
indir=$2
|
|
shift
|
|
;;
|
|
--ref=*)
|
|
ref=${1#--*=}
|
|
;;
|
|
--start=*)
|
|
n=${1#--*=}
|
|
;;
|
|
--message=*)
|
|
message=${1#--*=}
|
|
;;
|
|
--filename=*)
|
|
filename=${1#--*=}
|
|
;;
|
|
--contents=*)
|
|
contents=${1#--*=}
|
|
;;
|
|
--id=*)
|
|
message="${1#--*=} %s"
|
|
filename="${1#--*=}-%s.t"
|
|
contents="${1#--*=} %s"
|
|
;;
|
|
-*)
|
|
BUG "invalid test_commit_bulk option: $1"
|
|
;;
|
|
*)
|
|
break
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
total=$1
|
|
|
|
add_from=
|
|
if git -C "$indir" rev-parse --quiet --verify "$ref"
|
|
then
|
|
add_from=t
|
|
fi
|
|
|
|
while test "$total" -gt 0
|
|
do
|
|
test_tick &&
|
|
echo "commit $ref"
|
|
printf 'author %s <%s> %s\n' \
|
|
"$GIT_AUTHOR_NAME" \
|
|
"$GIT_AUTHOR_EMAIL" \
|
|
"$GIT_AUTHOR_DATE"
|
|
printf 'committer %s <%s> %s\n' \
|
|
"$GIT_COMMITTER_NAME" \
|
|
"$GIT_COMMITTER_EMAIL" \
|
|
"$GIT_COMMITTER_DATE"
|
|
echo "data <<EOF"
|
|
printf "$message\n" $n
|
|
echo "EOF"
|
|
if test -n "$add_from"
|
|
then
|
|
echo "from $ref^0"
|
|
add_from=
|
|
fi
|
|
printf "M 644 inline $filename\n" $n
|
|
echo "data <<EOF"
|
|
printf "$contents\n" $n
|
|
echo "EOF"
|
|
echo
|
|
n=$((n + 1))
|
|
total=$((total - 1))
|
|
done >"$tmpfile"
|
|
|
|
git -C "$indir" \
|
|
-c fastimport.unpacklimit=0 \
|
|
fast-import <"$tmpfile" || return 1
|
|
|
|
# This will be left in place on failure, which may aid debugging.
|
|
rm -f "$tmpfile"
|
|
|
|
# If we updated HEAD, then be nice and update the index and working
|
|
# tree, too.
|
|
if test "$ref" = "HEAD"
|
|
then
|
|
git -C "$indir" checkout -f HEAD || return 1
|
|
fi
|
|
|
|
}
|
|
|
|
# This function helps systems where core.filemode=false is set.
|
|
# Use it instead of plain 'chmod +x' to set or unset the executable bit
|
|
# of a file in the working directory and add it to the index.
|
|
|
|
test_chmod () {
|
|
chmod "$@" &&
|
|
git update-index --add "--chmod=$@"
|
|
}
|
|
|
|
# Get the modebits from a file or directory, ignoring the setgid bit (g+s).
|
|
# This bit is inherited by subdirectories at their creation. So we remove it
|
|
# from the returning string to prevent callers from having to worry about the
|
|
# state of the bit in the test directory.
|
|
#
|
|
test_modebits () {
|
|
ls -ld "$1" | sed -e 's|^\(..........\).*|\1|' \
|
|
-e 's|^\(......\)S|\1-|' -e 's|^\(......\)s|\1x|'
|
|
}
|
|
|
|
# Unset a configuration variable, but don't fail if it doesn't exist.
|
|
test_unconfig () {
|
|
config_dir=
|
|
if test "$1" = -C
|
|
then
|
|
shift
|
|
config_dir=$1
|
|
shift
|
|
fi
|
|
git ${config_dir:+-C "$config_dir"} config --unset-all "$@"
|
|
config_status=$?
|
|
case "$config_status" in
|
|
5) # ok, nothing to unset
|
|
config_status=0
|
|
;;
|
|
esac
|
|
return $config_status
|
|
}
|
|
|
|
# Set git config, automatically unsetting it after the test is over.
|
|
test_config () {
|
|
config_dir=
|
|
if test "$1" = -C
|
|
then
|
|
shift
|
|
config_dir=$1
|
|
shift
|
|
fi
|
|
test_when_finished "test_unconfig ${config_dir:+-C '$config_dir'} '$1'" &&
|
|
git ${config_dir:+-C "$config_dir"} config "$@"
|
|
}
|
|
|
|
test_config_global () {
|
|
test_when_finished "test_unconfig --global '$1'" &&
|
|
git config --global "$@"
|
|
}
|
|
|
|
write_script () {
|
|
{
|
|
echo "#!${2-"$SHELL_PATH"}" &&
|
|
cat
|
|
} >"$1" &&
|
|
chmod +x "$1"
|
|
}
|
|
|
|
# Usage: test_hook [options] <hook-name> <<-\EOF
|
|
#
|
|
# -C <dir>:
|
|
# Run all git commands in directory <dir>
|
|
# --setup
|
|
# Setup a hook for subsequent tests, i.e. don't remove it in a
|
|
# "test_when_finished"
|
|
# --clobber
|
|
# Overwrite an existing <hook-name>, if it exists. Implies
|
|
# --setup (i.e. the "test_when_finished" is assumed to have been
|
|
# set up already).
|
|
# --disable
|
|
# Disable (chmod -x) an existing <hook-name>, which must exist.
|
|
# --remove
|
|
# Remove (rm -f) an existing <hook-name>, which must exist.
|
|
test_hook () {
|
|
setup= &&
|
|
clobber= &&
|
|
disable= &&
|
|
remove= &&
|
|
indir= &&
|
|
while test $# != 0
|
|
do
|
|
case "$1" in
|
|
-C)
|
|
indir="$2" &&
|
|
shift
|
|
;;
|
|
--setup)
|
|
setup=t
|
|
;;
|
|
--clobber)
|
|
clobber=t
|
|
;;
|
|
--disable)
|
|
disable=t
|
|
;;
|
|
--remove)
|
|
remove=t
|
|
;;
|
|
-*)
|
|
BUG "invalid argument: $1"
|
|
;;
|
|
*)
|
|
break
|
|
;;
|
|
esac &&
|
|
shift
|
|
done &&
|
|
|
|
git_dir=$(git -C "$indir" rev-parse --absolute-git-dir) &&
|
|
hook_dir="$git_dir/hooks" &&
|
|
hook_file="$hook_dir/$1" &&
|
|
if test -n "$disable$remove"
|
|
then
|
|
test_path_is_file "$hook_file" &&
|
|
if test -n "$disable"
|
|
then
|
|
chmod -x "$hook_file"
|
|
elif test -n "$remove"
|
|
then
|
|
rm -f "$hook_file"
|
|
fi &&
|
|
return 0
|
|
fi &&
|
|
if test -z "$clobber"
|
|
then
|
|
test_path_is_missing "$hook_file"
|
|
fi &&
|
|
if test -z "$setup$clobber"
|
|
then
|
|
test_when_finished "rm \"$hook_file\""
|
|
fi &&
|
|
write_script "$hook_file"
|
|
}
|
|
|
|
# Use test_set_prereq to tell that a particular prerequisite is available.
|
|
# The prerequisite can later be checked for in two ways:
|
|
#
|
|
# - Explicitly using test_have_prereq.
|
|
#
|
|
# - Implicitly by specifying the prerequisite tag in the calls to
|
|
# test_expect_{success,failure}
|
|
#
|
|
# The single parameter is the prerequisite tag (a simple word, in all
|
|
# capital letters by convention).
|
|
|
|
test_unset_prereq () {
|
|
! test_have_prereq "$1" ||
|
|
satisfied_prereq="${satisfied_prereq% $1 *} ${satisfied_prereq#* $1 }"
|
|
}
|
|
|
|
test_set_prereq () {
|
|
if test -n "$GIT_TEST_FAIL_PREREQS_INTERNAL"
|
|
then
|
|
case "$1" in
|
|
# The "!" case is handled below with
|
|
# test_unset_prereq()
|
|
!*)
|
|
;;
|
|
# List of things we can't easily pretend to not support
|
|
SYMLINKS)
|
|
;;
|
|
# Inspecting whether GIT_TEST_FAIL_PREREQS is on
|
|
# should be unaffected.
|
|
FAIL_PREREQS)
|
|
;;
|
|
*)
|
|
return
|
|
esac
|
|
fi
|
|
|
|
case "$1" in
|
|
!*)
|
|
test_unset_prereq "${1#!}"
|
|
;;
|
|
*)
|
|
satisfied_prereq="$satisfied_prereq$1 "
|
|
;;
|
|
esac
|
|
}
|
|
satisfied_prereq=" "
|
|
lazily_testable_prereq= lazily_tested_prereq=
|
|
|
|
# Usage: test_lazy_prereq PREREQ 'script'
|
|
test_lazy_prereq () {
|
|
lazily_testable_prereq="$lazily_testable_prereq$1 "
|
|
eval test_prereq_lazily_$1=\$2
|
|
}
|
|
|
|
test_run_lazy_prereq_ () {
|
|
script='
|
|
mkdir -p "$TRASH_DIRECTORY/prereq-test-dir-'"$1"'" &&
|
|
(
|
|
cd "$TRASH_DIRECTORY/prereq-test-dir-'"$1"'" &&'"$2"'
|
|
)'
|
|
say >&3 "checking prerequisite: $1"
|
|
say >&3 "$script"
|
|
test_eval_ "$script"
|
|
eval_ret=$?
|
|
rm -rf "$TRASH_DIRECTORY/prereq-test-dir-$1"
|
|
if test "$eval_ret" = 0; then
|
|
say >&3 "prerequisite $1 ok"
|
|
else
|
|
say >&3 "prerequisite $1 not satisfied"
|
|
fi
|
|
return $eval_ret
|
|
}
|
|
|
|
test_have_prereq () {
|
|
# prerequisites can be concatenated with ','
|
|
save_IFS=$IFS
|
|
IFS=,
|
|
set -- $*
|
|
IFS=$save_IFS
|
|
|
|
total_prereq=0
|
|
ok_prereq=0
|
|
missing_prereq=
|
|
|
|
for prerequisite
|
|
do
|
|
case "$prerequisite" in
|
|
!*)
|
|
negative_prereq=t
|
|
prerequisite=${prerequisite#!}
|
|
;;
|
|
*)
|
|
negative_prereq=
|
|
esac
|
|
|
|
case " $lazily_tested_prereq " in
|
|
*" $prerequisite "*)
|
|
;;
|
|
*)
|
|
case " $lazily_testable_prereq " in
|
|
*" $prerequisite "*)
|
|
eval "script=\$test_prereq_lazily_$prerequisite" &&
|
|
if test_run_lazy_prereq_ "$prerequisite" "$script"
|
|
then
|
|
test_set_prereq $prerequisite
|
|
fi
|
|
lazily_tested_prereq="$lazily_tested_prereq$prerequisite "
|
|
esac
|
|
;;
|
|
esac
|
|
|
|
total_prereq=$(($total_prereq + 1))
|
|
case "$satisfied_prereq" in
|
|
*" $prerequisite "*)
|
|
satisfied_this_prereq=t
|
|
;;
|
|
*)
|
|
satisfied_this_prereq=
|
|
esac
|
|
|
|
case "$satisfied_this_prereq,$negative_prereq" in
|
|
t,|,t)
|
|
ok_prereq=$(($ok_prereq + 1))
|
|
;;
|
|
*)
|
|
# Keep a list of missing prerequisites; restore
|
|
# the negative marker if necessary.
|
|
prerequisite=${negative_prereq:+!}$prerequisite
|
|
|
|
# Abort if this prereq was marked as required
|
|
if test -n "$GIT_TEST_REQUIRE_PREREQ"
|
|
then
|
|
case " $GIT_TEST_REQUIRE_PREREQ " in
|
|
*" $prerequisite "*)
|
|
BAIL_OUT "required prereq $prerequisite failed"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if test -z "$missing_prereq"
|
|
then
|
|
missing_prereq=$prerequisite
|
|
else
|
|
missing_prereq="$prerequisite,$missing_prereq"
|
|
fi
|
|
esac
|
|
done
|
|
|
|
test $total_prereq = $ok_prereq
|
|
}
|
|
|
|
test_declared_prereq () {
|
|
case ",$test_prereq," in
|
|
*,$1,*)
|
|
return 0
|
|
;;
|
|
esac
|
|
return 1
|
|
}
|
|
|
|
test_verify_prereq () {
|
|
test -z "$test_prereq" ||
|
|
expr >/dev/null "$test_prereq" : '[A-Z0-9_,!]*$' ||
|
|
BUG "'$test_prereq' does not look like a prereq"
|
|
}
|
|
|
|
test_expect_failure () {
|
|
test_start_ "$@"
|
|
test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
|
|
test "$#" = 2 ||
|
|
BUG "not 2 or 3 parameters to test-expect-failure"
|
|
test_verify_prereq
|
|
export test_prereq
|
|
if ! test_skip "$@"
|
|
then
|
|
test -n "$test_skip_test_preamble" ||
|
|
say >&3 "checking known breakage of $TEST_NUMBER.$test_count '$1': $2"
|
|
if test_run_ "$2" expecting_failure
|
|
then
|
|
test_known_broken_ok_ "$1"
|
|
else
|
|
test_known_broken_failure_ "$1"
|
|
fi
|
|
fi
|
|
test_finish_
|
|
}
|
|
|
|
test_expect_success () {
|
|
test_start_ "$@"
|
|
test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq=
|
|
test "$#" = 2 ||
|
|
BUG "not 2 or 3 parameters to test-expect-success"
|
|
test_verify_prereq
|
|
export test_prereq
|
|
if ! test_skip "$@"
|
|
then
|
|
test -n "$test_skip_test_preamble" ||
|
|
say >&3 "expecting success of $TEST_NUMBER.$test_count '$1': $2"
|
|
if test_run_ "$2"
|
|
then
|
|
test_ok_ "$1"
|
|
else
|
|
test_failure_ "$@"
|
|
fi
|
|
fi
|
|
test_finish_
|
|
}
|
|
|
|
# debugging-friendly alternatives to "test [-f|-d|-e]"
|
|
# The commands test the existence or non-existence of $1
|
|
test_path_is_file () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
if ! test -f "$1"
|
|
then
|
|
echo "File $1 doesn't exist"
|
|
false
|
|
fi
|
|
}
|
|
|
|
test_path_is_file_not_symlink () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
test_path_is_file "$1" &&
|
|
if test -h "$1"
|
|
then
|
|
echo "$1 shouldn't be a symbolic link"
|
|
false
|
|
fi
|
|
}
|
|
|
|
test_path_is_dir () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
if ! test -d "$1"
|
|
then
|
|
echo "Directory $1 doesn't exist"
|
|
false
|
|
fi
|
|
}
|
|
|
|
test_path_is_dir_not_symlink () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
test_path_is_dir "$1" &&
|
|
if test -h "$1"
|
|
then
|
|
echo "$1 shouldn't be a symbolic link"
|
|
false
|
|
fi
|
|
}
|
|
|
|
test_path_exists () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
if ! test -e "$1"
|
|
then
|
|
echo "Path $1 doesn't exist"
|
|
false
|
|
fi
|
|
}
|
|
|
|
test_path_is_symlink () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
if ! test -h "$1"
|
|
then
|
|
echo "Symbolic link $1 doesn't exist"
|
|
false
|
|
fi
|
|
}
|
|
|
|
# Check if the directory exists and is empty as expected, barf otherwise.
|
|
test_dir_is_empty () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
test_path_is_dir "$1" &&
|
|
if test -n "$(ls -a1 "$1" | grep -E -v '^\.\.?$')"
|
|
then
|
|
echo "Directory '$1' is not empty, it contains:"
|
|
ls -la "$1"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Check if the file exists and has a size greater than zero
|
|
test_file_not_empty () {
|
|
test "$#" = 2 && BUG "2 param"
|
|
if ! test -s "$1"
|
|
then
|
|
echo "'$1' is not a non-empty file."
|
|
false
|
|
fi
|
|
}
|
|
|
|
test_path_is_missing () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
if test -e "$1"
|
|
then
|
|
echo "Path exists:"
|
|
ls -ld "$1"
|
|
false
|
|
fi
|
|
}
|
|
|
|
# test_line_count checks that a file has the number of lines it
|
|
# ought to. For example:
|
|
#
|
|
# test_expect_success 'produce exactly one line of output' '
|
|
# do something >output &&
|
|
# test_line_count = 1 output
|
|
# '
|
|
#
|
|
# is like "test $(wc -l <output) = 1" except that it passes the
|
|
# output through when the number of lines is wrong.
|
|
|
|
test_line_count () {
|
|
if test $# != 3
|
|
then
|
|
BUG "not 3 parameters to test_line_count"
|
|
elif ! test $(wc -l <"$3") "$1" "$2"
|
|
then
|
|
echo "test_line_count: line count for $3 !$1 $2"
|
|
cat "$3"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# SYNOPSIS:
|
|
# test_stdout_line_count <bin-ops> <value> <cmd> [<args>...]
|
|
#
|
|
# test_stdout_line_count checks that the output of a command has the number
|
|
# of lines it ought to. For example:
|
|
#
|
|
# test_stdout_line_count = 3 git ls-files -u
|
|
# test_stdout_line_count -gt 10 ls
|
|
test_stdout_line_count () {
|
|
local ops val trashdir &&
|
|
if test "$#" -le 3
|
|
then
|
|
BUG "expect 3 or more arguments"
|
|
fi &&
|
|
ops="$1" &&
|
|
val="$2" &&
|
|
shift 2 &&
|
|
if ! trashdir="$(git rev-parse --git-dir)/trash"; then
|
|
BUG "expect to be run inside a worktree"
|
|
fi &&
|
|
mkdir -p "$trashdir" &&
|
|
"$@" >"$trashdir/output" &&
|
|
test_line_count "$ops" "$val" "$trashdir/output"
|
|
}
|
|
|
|
|
|
test_file_size () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
test-tool path-utils file-size "$1"
|
|
}
|
|
|
|
# Returns success if a comma separated string of keywords ($1) contains a
|
|
# given keyword ($2).
|
|
# Examples:
|
|
# `list_contains "foo,bar" bar` returns 0
|
|
# `list_contains "foo" bar` returns 1
|
|
|
|
list_contains () {
|
|
case ",$1," in
|
|
*,$2,*)
|
|
return 0
|
|
;;
|
|
esac
|
|
return 1
|
|
}
|
|
|
|
# Returns success if the arguments indicate that a command should be
|
|
# accepted by test_must_fail(). If the command is run with env, the env
|
|
# and its corresponding variable settings will be stripped before we
|
|
# test the command being run.
|
|
test_must_fail_acceptable () {
|
|
if test "$1" = "env"
|
|
then
|
|
shift
|
|
while test $# -gt 0
|
|
do
|
|
case "$1" in
|
|
*?=*)
|
|
shift
|
|
;;
|
|
*)
|
|
break
|
|
;;
|
|
esac
|
|
done
|
|
fi
|
|
|
|
case "$1" in
|
|
git|__git*|test-tool|test_terminal)
|
|
return 0
|
|
;;
|
|
*)
|
|
return 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# This is not among top-level (test_expect_success | test_expect_failure)
|
|
# but is a prefix that can be used in the test script, like:
|
|
#
|
|
# test_expect_success 'complain and die' '
|
|
# do something &&
|
|
# do something else &&
|
|
# test_must_fail git checkout ../outerspace
|
|
# '
|
|
#
|
|
# Writing this as "! git checkout ../outerspace" is wrong, because
|
|
# the failure could be due to a segv. We want a controlled failure.
|
|
#
|
|
# Accepts the following options:
|
|
#
|
|
# ok=<signal-name>[,<...>]:
|
|
# Don't treat an exit caused by the given signal as error.
|
|
# Multiple signals can be specified as a comma separated list.
|
|
# Currently recognized signal names are: sigpipe, success.
|
|
# (Don't use 'success', use 'test_might_fail' instead.)
|
|
#
|
|
# Do not use this to run anything but "git" and other specific testable
|
|
# commands (see test_must_fail_acceptable()). We are not in the
|
|
# business of vetting system supplied commands -- in other words, this
|
|
# is wrong:
|
|
#
|
|
# test_must_fail grep pattern output
|
|
#
|
|
# Instead use '!':
|
|
#
|
|
# ! grep pattern output
|
|
|
|
test_must_fail () {
|
|
case "$1" in
|
|
ok=*)
|
|
_test_ok=${1#ok=}
|
|
shift
|
|
;;
|
|
*)
|
|
_test_ok=
|
|
;;
|
|
esac
|
|
if ! test_must_fail_acceptable "$@"
|
|
then
|
|
echo >&7 "test_must_fail: only 'git' is allowed: $*"
|
|
return 1
|
|
fi
|
|
"$@" 2>&7
|
|
exit_code=$?
|
|
if test $exit_code -eq 0 && ! list_contains "$_test_ok" success
|
|
then
|
|
echo >&4 "test_must_fail: command succeeded: $*"
|
|
return 1
|
|
elif test_match_signal 13 $exit_code && list_contains "$_test_ok" sigpipe
|
|
then
|
|
return 0
|
|
elif test $exit_code -gt 129 && test $exit_code -le 192
|
|
then
|
|
echo >&4 "test_must_fail: died by signal $(($exit_code - 128)): $*"
|
|
return 1
|
|
elif test $exit_code -eq 127
|
|
then
|
|
echo >&4 "test_must_fail: command not found: $*"
|
|
return 1
|
|
elif test $exit_code -eq 126
|
|
then
|
|
echo >&4 "test_must_fail: valgrind error: $*"
|
|
return 1
|
|
fi
|
|
return 0
|
|
} 7>&2 2>&4
|
|
|
|
# Similar to test_must_fail, but tolerates success, too. This is
|
|
# meant to be used in contexts like:
|
|
#
|
|
# test_expect_success 'some command works without configuration' '
|
|
# test_might_fail git config --unset all.configuration &&
|
|
# do something
|
|
# '
|
|
#
|
|
# Writing "git config --unset all.configuration || :" would be wrong,
|
|
# because we want to notice if it fails due to segv.
|
|
#
|
|
# Accepts the same options as test_must_fail.
|
|
|
|
test_might_fail () {
|
|
test_must_fail ok=success "$@" 2>&7
|
|
} 7>&2 2>&4
|
|
|
|
# Similar to test_must_fail and test_might_fail, but check that a
|
|
# given command exited with a given exit code. Meant to be used as:
|
|
#
|
|
# test_expect_success 'Merge with d/f conflicts' '
|
|
# test_expect_code 1 git merge "merge msg" B master
|
|
# '
|
|
|
|
test_expect_code () {
|
|
want_code=$1
|
|
shift
|
|
"$@" 2>&7
|
|
exit_code=$?
|
|
if test $exit_code = $want_code
|
|
then
|
|
return 0
|
|
fi
|
|
|
|
echo >&4 "test_expect_code: command exited with $exit_code, we wanted $want_code $*"
|
|
return 1
|
|
} 7>&2 2>&4
|
|
|
|
# test_cmp is a helper function to compare actual and expected output.
|
|
# You can use it like:
|
|
#
|
|
# test_expect_success 'foo works' '
|
|
# echo expected >expected &&
|
|
# foo >actual &&
|
|
# test_cmp expected actual
|
|
# '
|
|
#
|
|
# This could be written as either "cmp" or "diff -u", but:
|
|
# - cmp's output is not nearly as easy to read as diff -u
|
|
# - not all diff versions understand "-u"
|
|
|
|
test_cmp () {
|
|
test "$#" -ne 2 && BUG "2 param"
|
|
eval "$GIT_TEST_CMP" '"$@"'
|
|
}
|
|
|
|
# Check that the given config key has the expected value.
|
|
#
|
|
# test_cmp_config [-C <dir>] <expected-value>
|
|
# [<git-config-options>...] <config-key>
|
|
#
|
|
# for example to check that the value of core.bar is foo
|
|
#
|
|
# test_cmp_config foo core.bar
|
|
#
|
|
test_cmp_config () {
|
|
local GD &&
|
|
if test "$1" = "-C"
|
|
then
|
|
shift &&
|
|
GD="-C $1" &&
|
|
shift
|
|
fi &&
|
|
printf "%s\n" "$1" >expect.config &&
|
|
shift &&
|
|
git $GD config "$@" >actual.config &&
|
|
test_cmp expect.config actual.config
|
|
}
|
|
|
|
# test_cmp_bin - helper to compare binary files
|
|
|
|
test_cmp_bin () {
|
|
test "$#" -ne 2 && BUG "2 param"
|
|
cmp "$@"
|
|
}
|
|
|
|
# Wrapper for grep which used to be used for
|
|
# GIT_TEST_GETTEXT_POISON=false. Only here as a shim for other
|
|
# in-flight changes. Should not be used and will be removed soon.
|
|
test_i18ngrep () {
|
|
eval "last_arg=\${$#}"
|
|
|
|
test -f "$last_arg" ||
|
|
BUG "test_i18ngrep requires a file to read as the last parameter"
|
|
|
|
if test $# -lt 2 ||
|
|
{ test "x!" = "x$1" && test $# -lt 3 ; }
|
|
then
|
|
BUG "too few parameters to test_i18ngrep"
|
|
fi
|
|
|
|
if test "x!" = "x$1"
|
|
then
|
|
shift
|
|
! grep "$@" && return 0
|
|
|
|
echo >&4 "error: '! grep $@' did find a match in:"
|
|
else
|
|
grep "$@" && return 0
|
|
|
|
echo >&4 "error: 'grep $@' didn't find a match in:"
|
|
fi
|
|
|
|
if test -s "$last_arg"
|
|
then
|
|
cat >&4 "$last_arg"
|
|
else
|
|
echo >&4 "<File '$last_arg' is empty>"
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
# Call any command "$@" but be more verbose about its
|
|
# failure. This is handy for commands like "test" which do
|
|
# not output anything when they fail.
|
|
verbose () {
|
|
"$@" && return 0
|
|
echo >&4 "command failed: $(git rev-parse --sq-quote "$@")"
|
|
return 1
|
|
}
|
|
|
|
# Check if the file expected to be empty is indeed empty, and barfs
|
|
# otherwise.
|
|
|
|
test_must_be_empty () {
|
|
test "$#" -ne 1 && BUG "1 param"
|
|
test_path_is_file "$1" &&
|
|
if test -s "$1"
|
|
then
|
|
echo "'$1' is not empty, it contains:"
|
|
cat "$1"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Tests that its two parameters refer to the same revision, or if '!' is
|
|
# provided first, that its other two parameters refer to different
|
|
# revisions.
|
|
test_cmp_rev () {
|
|
local op='=' wrong_result=different
|
|
|
|
if test $# -ge 1 && test "x$1" = 'x!'
|
|
then
|
|
op='!='
|
|
wrong_result='the same'
|
|
shift
|
|
fi
|
|
if test $# != 2
|
|
then
|
|
BUG "test_cmp_rev requires two revisions, but got $#"
|
|
else
|
|
local r1 r2
|
|
r1=$(git rev-parse --verify "$1") &&
|
|
r2=$(git rev-parse --verify "$2") || return 1
|
|
|
|
if ! test "$r1" "$op" "$r2"
|
|
then
|
|
cat >&4 <<-EOF
|
|
error: two revisions point to $wrong_result objects:
|
|
'$1': $r1
|
|
'$2': $r2
|
|
EOF
|
|
return 1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Compare paths respecting core.ignoreCase
|
|
test_cmp_fspath () {
|
|
if test "x$1" = "x$2"
|
|
then
|
|
return 0
|
|
fi
|
|
|
|
if test true != "$(git config --get --type=bool core.ignorecase)"
|
|
then
|
|
return 1
|
|
fi
|
|
|
|
test "x$(echo "$1" | tr A-Z a-z)" = "x$(echo "$2" | tr A-Z a-z)"
|
|
}
|
|
|
|
# Print a sequence of integers in increasing order, either with
|
|
# two arguments (start and end):
|
|
#
|
|
# test_seq 1 5 -- outputs 1 2 3 4 5 one line at a time
|
|
#
|
|
# or with one argument (end), in which case it starts counting
|
|
# from 1.
|
|
|
|
test_seq () {
|
|
case $# in
|
|
1) set 1 "$@" ;;
|
|
2) ;;
|
|
*) BUG "not 1 or 2 parameters to test_seq" ;;
|
|
esac
|
|
test_seq_counter__=$1
|
|
while test "$test_seq_counter__" -le "$2"
|
|
do
|
|
echo "$test_seq_counter__"
|
|
test_seq_counter__=$(( $test_seq_counter__ + 1 ))
|
|
done
|
|
}
|
|
|
|
# This function can be used to schedule some commands to be run
|
|
# unconditionally at the end of the test to restore sanity:
|
|
#
|
|
# test_expect_success 'test core.capslock' '
|
|
# git config core.capslock true &&
|
|
# test_when_finished "git config --unset core.capslock" &&
|
|
# hello world
|
|
# '
|
|
#
|
|
# That would be roughly equivalent to
|
|
#
|
|
# test_expect_success 'test core.capslock' '
|
|
# git config core.capslock true &&
|
|
# hello world
|
|
# git config --unset core.capslock
|
|
# '
|
|
#
|
|
# except that the greeting and config --unset must both succeed for
|
|
# the test to pass.
|
|
#
|
|
# Note that under --immediate mode, no clean-up is done to help diagnose
|
|
# what went wrong.
|
|
|
|
test_when_finished () {
|
|
# We cannot detect when we are in a subshell in general, but by
|
|
# doing so on Bash is better than nothing (the test will
|
|
# silently pass on other shells).
|
|
test "${BASH_SUBSHELL-0}" = 0 ||
|
|
BUG "test_when_finished does nothing in a subshell"
|
|
test_cleanup="{ $*
|
|
} && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup"
|
|
}
|
|
|
|
# This function can be used to schedule some commands to be run
|
|
# unconditionally at the end of the test script, e.g. to stop a daemon:
|
|
#
|
|
# test_expect_success 'test git daemon' '
|
|
# git daemon &
|
|
# daemon_pid=$! &&
|
|
# test_atexit 'kill $daemon_pid' &&
|
|
# hello world
|
|
# '
|
|
#
|
|
# The commands will be executed before the trash directory is removed,
|
|
# i.e. the atexit commands will still be able to access any pidfiles or
|
|
# socket files.
|
|
#
|
|
# Note that these commands will be run even when a test script run
|
|
# with '--immediate' fails. Be careful with your atexit commands to
|
|
# minimize any changes to the failed state.
|
|
|
|
test_atexit () {
|
|
# We cannot detect when we are in a subshell in general, but by
|
|
# doing so on Bash is better than nothing (the test will
|
|
# silently pass on other shells).
|
|
test "${BASH_SUBSHELL-0}" = 0 ||
|
|
BUG "test_atexit does nothing in a subshell"
|
|
test_atexit_cleanup="{ $*
|
|
} && (exit \"\$eval_ret\"); eval_ret=\$?; $test_atexit_cleanup"
|
|
}
|
|
|
|
# Deprecated wrapper for "git init", use "git init" directly instead
|
|
# Usage: test_create_repo <directory>
|
|
test_create_repo () {
|
|
git init "$@"
|
|
}
|
|
|
|
# This function helps on symlink challenged file systems when it is not
|
|
# important that the file system entry is a symbolic link.
|
|
# Use test_ln_s_add instead of "ln -s x y && git add y" to add a
|
|
# symbolic link entry y to the index.
|
|
|
|
test_ln_s_add () {
|
|
if test_have_prereq SYMLINKS
|
|
then
|
|
ln -s "$1" "$2" &&
|
|
git update-index --add "$2"
|
|
else
|
|
printf '%s' "$1" >"$2" &&
|
|
ln_s_obj=$(git hash-object -w "$2") &&
|
|
git update-index --add --cacheinfo 120000 $ln_s_obj "$2" &&
|
|
# pick up stat info from the file
|
|
git update-index "$2"
|
|
fi
|
|
}
|
|
|
|
# This function writes out its parameters, one per line
|
|
test_write_lines () {
|
|
printf "%s\n" "$@"
|
|
}
|
|
|
|
perl () {
|
|
command "$PERL_PATH" "$@" 2>&7
|
|
} 7>&2 2>&4
|
|
|
|
# Given the name of an environment variable with a bool value, normalize
|
|
# its value to a 0 (true) or 1 (false or empty string) return code.
|
|
#
|
|
# test_bool_env GIT_TEST_HTTPD <default-value>
|
|
#
|
|
# Return with code corresponding to the given default value if the variable
|
|
# is unset.
|
|
# Abort the test script if either the value of the variable or the default
|
|
# are not valid bool values.
|
|
|
|
test_bool_env () {
|
|
if test $# != 2
|
|
then
|
|
BUG "test_bool_env requires two parameters (variable name and default value)"
|
|
fi
|
|
|
|
git env--helper --type=bool --default="$2" --exit-code "$1"
|
|
ret=$?
|
|
case $ret in
|
|
0|1) # unset or valid bool value
|
|
;;
|
|
*) # invalid bool value or something unexpected
|
|
error >&7 "test_bool_env requires bool values both for \$$1 and for the default fallback"
|
|
;;
|
|
esac
|
|
return $ret
|
|
}
|
|
|
|
# Exit the test suite, either by skipping all remaining tests or by
|
|
# exiting with an error. If our prerequisite variable $1 falls back
|
|
# on a default assume we were opportunistically trying to set up some
|
|
# tests and we skip. If it is explicitly "true", then we report a failure.
|
|
#
|
|
# The error/skip message should be given by $2.
|
|
#
|
|
test_skip_or_die () {
|
|
if ! test_bool_env "$1" false
|
|
then
|
|
skip_all=$2
|
|
test_done
|
|
fi
|
|
error "$2"
|
|
}
|
|
|
|
# The following mingw_* functions obey POSIX shell syntax, but are actually
|
|
# bash scripts, and are meant to be used only with bash on Windows.
|
|
|
|
# A test_cmp function that treats LF and CRLF equal and avoids to fork
|
|
# diff when possible.
|
|
mingw_test_cmp () {
|
|
# Read text into shell variables and compare them. If the results
|
|
# are different, use regular diff to report the difference.
|
|
local test_cmp_a= test_cmp_b=
|
|
|
|
# When text came from stdin (one argument is '-') we must feed it
|
|
# to diff.
|
|
local stdin_for_diff=
|
|
|
|
# Since it is difficult to detect the difference between an
|
|
# empty input file and a failure to read the files, we go straight
|
|
# to diff if one of the inputs is empty.
|
|
if test -s "$1" && test -s "$2"
|
|
then
|
|
# regular case: both files non-empty
|
|
mingw_read_file_strip_cr_ test_cmp_a <"$1"
|
|
mingw_read_file_strip_cr_ test_cmp_b <"$2"
|
|
elif test -s "$1" && test "$2" = -
|
|
then
|
|
# read 2nd file from stdin
|
|
mingw_read_file_strip_cr_ test_cmp_a <"$1"
|
|
mingw_read_file_strip_cr_ test_cmp_b
|
|
stdin_for_diff='<<<"$test_cmp_b"'
|
|
elif test "$1" = - && test -s "$2"
|
|
then
|
|
# read 1st file from stdin
|
|
mingw_read_file_strip_cr_ test_cmp_a
|
|
mingw_read_file_strip_cr_ test_cmp_b <"$2"
|
|
stdin_for_diff='<<<"$test_cmp_a"'
|
|
fi
|
|
test -n "$test_cmp_a" &&
|
|
test -n "$test_cmp_b" &&
|
|
test "$test_cmp_a" = "$test_cmp_b" ||
|
|
eval "diff -u \"\$@\" $stdin_for_diff"
|
|
}
|
|
|
|
# $1 is the name of the shell variable to fill in
|
|
mingw_read_file_strip_cr_ () {
|
|
# Read line-wise using LF as the line separator
|
|
# and use IFS to strip CR.
|
|
local line
|
|
while :
|
|
do
|
|
if IFS=$'\r' read -r -d $'\n' line
|
|
then
|
|
# good
|
|
line=$line$'\n'
|
|
else
|
|
# we get here at EOF, but also if the last line
|
|
# was not terminated by LF; in the latter case,
|
|
# some text was read
|
|
if test -z "$line"
|
|
then
|
|
# EOF, really
|
|
break
|
|
fi
|
|
fi
|
|
eval "$1=\$$1\$line"
|
|
done
|
|
}
|
|
|
|
# Like "env FOO=BAR some-program", but run inside a subshell, which means
|
|
# it also works for shell functions (though those functions cannot impact
|
|
# the environment outside of the test_env invocation).
|
|
test_env () {
|
|
(
|
|
while test $# -gt 0
|
|
do
|
|
case "$1" in
|
|
*=*)
|
|
eval "${1%%=*}=\${1#*=}"
|
|
eval "export ${1%%=*}"
|
|
shift
|
|
;;
|
|
*)
|
|
"$@" 2>&7
|
|
exit
|
|
;;
|
|
esac
|
|
done
|
|
)
|
|
} 7>&2 2>&4
|
|
|
|
# Returns true if the numeric exit code in "$2" represents the expected signal
|
|
# in "$1". Signals should be given numerically.
|
|
test_match_signal () {
|
|
if test "$2" = "$((128 + $1))"
|
|
then
|
|
# POSIX
|
|
return 0
|
|
elif test "$2" = "$((256 + $1))"
|
|
then
|
|
# ksh
|
|
return 0
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
# Read up to "$1" bytes (or to EOF) from stdin and write them to stdout.
|
|
test_copy_bytes () {
|
|
perl -e '
|
|
my $len = $ARGV[1];
|
|
while ($len > 0) {
|
|
my $s;
|
|
my $nread = sysread(STDIN, $s, $len);
|
|
die "cannot read: $!" unless defined($nread);
|
|
last unless $nread;
|
|
print $s;
|
|
$len -= $nread;
|
|
}
|
|
' - "$1"
|
|
}
|
|
|
|
# run "$@" inside a non-git directory
|
|
nongit () {
|
|
test -d non-repo ||
|
|
mkdir non-repo ||
|
|
return 1
|
|
|
|
(
|
|
GIT_CEILING_DIRECTORIES=$(pwd) &&
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
cd non-repo &&
|
|
"$@" 2>&7
|
|
)
|
|
} 7>&2 2>&4
|
|
|
|
# These functions are historical wrappers around "test-tool pkt-line"
|
|
# for older tests. Use "test-tool pkt-line" itself in new tests.
|
|
packetize () {
|
|
if test $# -gt 0
|
|
then
|
|
packet="$*"
|
|
printf '%04x%s' "$((4 + ${#packet}))" "$packet"
|
|
else
|
|
test-tool pkt-line pack
|
|
fi
|
|
}
|
|
|
|
packetize_raw () {
|
|
test-tool pkt-line pack-raw-stdin
|
|
}
|
|
|
|
depacketize () {
|
|
test-tool pkt-line unpack
|
|
}
|
|
|
|
# Converts base-16 data into base-8. The output is given as a sequence of
|
|
# escaped octals, suitable for consumption by 'printf'.
|
|
hex2oct () {
|
|
perl -ne 'printf "\\%03o", hex for /../g'
|
|
}
|
|
|
|
# Set the hash algorithm in use to $1. Only useful when testing the testsuite.
|
|
test_set_hash () {
|
|
test_hash_algo="$1"
|
|
}
|
|
|
|
# Detect the hash algorithm in use.
|
|
test_detect_hash () {
|
|
test_hash_algo="${GIT_TEST_DEFAULT_HASH:-sha1}"
|
|
}
|
|
|
|
# Load common hash metadata and common placeholder object IDs for use with
|
|
# test_oid.
|
|
test_oid_init () {
|
|
test -n "$test_hash_algo" || test_detect_hash &&
|
|
test_oid_cache <"$TEST_DIRECTORY/oid-info/hash-info" &&
|
|
test_oid_cache <"$TEST_DIRECTORY/oid-info/oid"
|
|
}
|
|
|
|
# Load key-value pairs from stdin suitable for use with test_oid. Blank lines
|
|
# and lines starting with "#" are ignored. Keys must be shell identifier
|
|
# characters.
|
|
#
|
|
# Examples:
|
|
# rawsz sha1:20
|
|
# rawsz sha256:32
|
|
test_oid_cache () {
|
|
local tag rest k v &&
|
|
|
|
{ test -n "$test_hash_algo" || test_detect_hash; } &&
|
|
while read tag rest
|
|
do
|
|
case $tag in
|
|
\#*)
|
|
continue;;
|
|
?*)
|
|
# non-empty
|
|
;;
|
|
*)
|
|
# blank line
|
|
continue;;
|
|
esac &&
|
|
|
|
k="${rest%:*}" &&
|
|
v="${rest#*:}" &&
|
|
|
|
if ! expr "$k" : '[a-z0-9][a-z0-9]*$' >/dev/null
|
|
then
|
|
BUG 'bad hash algorithm'
|
|
fi &&
|
|
eval "test_oid_${k}_$tag=\"\$v\""
|
|
done
|
|
}
|
|
|
|
# Look up a per-hash value based on a key ($1). The value must have been loaded
|
|
# by test_oid_init or test_oid_cache.
|
|
test_oid () {
|
|
local algo="${test_hash_algo}" &&
|
|
|
|
case "$1" in
|
|
--hash=*)
|
|
algo="${1#--hash=}" &&
|
|
shift;;
|
|
*)
|
|
;;
|
|
esac &&
|
|
|
|
local var="test_oid_${algo}_$1" &&
|
|
|
|
# If the variable is unset, we must be missing an entry for this
|
|
# key-hash pair, so exit with an error.
|
|
if eval "test -z \"\${$var+set}\""
|
|
then
|
|
BUG "undefined key '$1'"
|
|
fi &&
|
|
eval "printf '%s' \"\${$var}\""
|
|
}
|
|
|
|
# Insert a slash into an object ID so it can be used to reference a location
|
|
# under ".git/objects". For example, "deadbeef..." becomes "de/adbeef..".
|
|
test_oid_to_path () {
|
|
local basename=${1#??}
|
|
echo "${1%$basename}/$basename"
|
|
}
|
|
|
|
# Parse oids from git ls-files --staged output
|
|
test_parse_ls_files_stage_oids () {
|
|
awk '{print $2}' -
|
|
}
|
|
|
|
# Parse oids from git ls-tree output
|
|
test_parse_ls_tree_oids () {
|
|
awk '{print $3}' -
|
|
}
|
|
|
|
# Choose a port number based on the test script's number and store it in
|
|
# the given variable name, unless that variable already contains a number.
|
|
test_set_port () {
|
|
local var=$1 port
|
|
|
|
if test $# -ne 1 || test -z "$var"
|
|
then
|
|
BUG "test_set_port requires a variable name"
|
|
fi
|
|
|
|
eval port=\$$var
|
|
case "$port" in
|
|
"")
|
|
# No port is set in the given env var, use the test
|
|
# number as port number instead.
|
|
# Remove not only the leading 't', but all leading zeros
|
|
# as well, so the arithmetic below won't (mis)interpret
|
|
# a test number like '0123' as an octal value.
|
|
port=${this_test#${this_test%%[1-9]*}}
|
|
if test "${port:-0}" -lt 1024
|
|
then
|
|
# root-only port, use a larger one instead.
|
|
port=$(($port + 10000))
|
|
fi
|
|
;;
|
|
*[!0-9]*|0*)
|
|
error >&7 "invalid port number: $port"
|
|
;;
|
|
*)
|
|
# The user has specified the port.
|
|
;;
|
|
esac
|
|
|
|
# Make sure that parallel '--stress' test jobs get different
|
|
# ports.
|
|
port=$(($port + ${GIT_TEST_STRESS_JOB_NR:-0}))
|
|
eval $var=$port
|
|
}
|
|
|
|
# Tests for the hidden file attribute on Windows
|
|
test_path_is_hidden () {
|
|
test_have_prereq MINGW ||
|
|
BUG "test_path_is_hidden can only be used on Windows"
|
|
|
|
# Use the output of `attrib`, ignore the absolute path
|
|
case "$("$SYSTEMROOT"/system32/attrib "$1")" in *H*?:*) return 0;; esac
|
|
return 1
|
|
}
|
|
|
|
# Check that the given command was invoked as part of the
|
|
# trace2-format trace on stdin.
|
|
#
|
|
# test_subcommand [!] <command> <args>... < <trace>
|
|
#
|
|
# For example, to look for an invocation of "git upload-pack
|
|
# /path/to/repo"
|
|
#
|
|
# GIT_TRACE2_EVENT=event.log git fetch ... &&
|
|
# test_subcommand git upload-pack "$PATH" <event.log
|
|
#
|
|
# If the first parameter passed is !, this instead checks that
|
|
# the given command was not called.
|
|
#
|
|
test_subcommand () {
|
|
local negate=
|
|
if test "$1" = "!"
|
|
then
|
|
negate=t
|
|
shift
|
|
fi
|
|
|
|
local expr=$(printf '"%s",' "$@")
|
|
expr="${expr%,}"
|
|
|
|
if test -n "$negate"
|
|
then
|
|
! grep "\[$expr\]"
|
|
else
|
|
grep "\[$expr\]"
|
|
fi
|
|
}
|
|
|
|
# Check that the given command was invoked as part of the
|
|
# trace2-format trace on stdin.
|
|
#
|
|
# test_region [!] <category> <label> git <command> <args>...
|
|
#
|
|
# For example, to look for trace2_region_enter("index", "do_read_index", repo)
|
|
# in an invocation of "git checkout HEAD~1", run
|
|
#
|
|
# GIT_TRACE2_EVENT="$(pwd)/trace.txt" GIT_TRACE2_EVENT_NESTING=10 \
|
|
# git checkout HEAD~1 &&
|
|
# test_region index do_read_index <trace.txt
|
|
#
|
|
# If the first parameter passed is !, this instead checks that
|
|
# the given region was not entered.
|
|
#
|
|
test_region () {
|
|
local expect_exit=0
|
|
if test "$1" = "!"
|
|
then
|
|
expect_exit=1
|
|
shift
|
|
fi
|
|
|
|
grep -e '"region_enter".*"category":"'"$1"'","label":"'"$2"\" "$3"
|
|
exitcode=$?
|
|
|
|
if test $exitcode != $expect_exit
|
|
then
|
|
return 1
|
|
fi
|
|
|
|
grep -e '"region_leave".*"category":"'"$1"'","label":"'"$2"\" "$3"
|
|
exitcode=$?
|
|
|
|
if test $exitcode != $expect_exit
|
|
then
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
# Print the destination of symlink(s) provided as arguments. Basically
|
|
# the same as the readlink command, but it's not available everywhere.
|
|
test_readlink () {
|
|
perl -le 'print readlink($_) for @ARGV' "$@"
|
|
}
|
|
|
|
# Set mtime to a fixed "magic" timestamp in mid February 2009, before we
|
|
# run an operation that may or may not touch the file. If the file was
|
|
# touched, its timestamp will not accidentally have such an old timestamp,
|
|
# as long as your filesystem clock is reasonably correct. To verify the
|
|
# timestamp, follow up with test_is_magic_mtime.
|
|
#
|
|
# An optional increment to the magic timestamp may be specified as second
|
|
# argument.
|
|
test_set_magic_mtime () {
|
|
local inc=${2:-0} &&
|
|
local mtime=$((1234567890 + $inc)) &&
|
|
test-tool chmtime =$mtime "$1" &&
|
|
test_is_magic_mtime "$1" $inc
|
|
}
|
|
|
|
# Test whether the given file has the "magic" mtime set. This is meant to
|
|
# be used in combination with test_set_magic_mtime.
|
|
#
|
|
# An optional increment to the magic timestamp may be specified as second
|
|
# argument. Usually, this should be the same increment which was used for
|
|
# the associated test_set_magic_mtime.
|
|
test_is_magic_mtime () {
|
|
local inc=${2:-0} &&
|
|
local mtime=$((1234567890 + $inc)) &&
|
|
echo $mtime >.git/test-mtime-expect &&
|
|
test-tool chmtime --get "$1" >.git/test-mtime-actual &&
|
|
test_cmp .git/test-mtime-expect .git/test-mtime-actual
|
|
local ret=$?
|
|
rm -f .git/test-mtime-expect
|
|
rm -f .git/test-mtime-actual
|
|
return $ret
|
|
}
|
|
|
|
# Given two filenames, parse both using 'git config --list --file'
|
|
# and compare the sorted output of those commands. Useful when
|
|
# wanting to ignore whitespace differences and sorting concerns.
|
|
test_cmp_config_output () {
|
|
git config --list --file="$1" >config-expect &&
|
|
git config --list --file="$2" >config-actual &&
|
|
sort config-expect >sorted-expect &&
|
|
sort config-actual >sorted-actual &&
|
|
test_cmp sorted-expect sorted-actual
|
|
}
|