Skip to content
Snippets Groups Projects
Commit 17f0fe42 authored by Robert Goldman's avatar Robert Goldman
Browse files

Restoring old shell script for tests.

parent 467019a5
No related branches found
No related tags found
No related merge requests found
#!/bin/sh
# run-tests {lisp invocation} {scripts-regex}
# - read lisp forms one at a time from standard input
# - quit with exit status 0 on getting eof
# - quit with exit status >0 if an unhandled error occurs
usage () {
echo "$0 [lisp invocation] [scripts-regex]"
echo " - read lisp forms one at a time from matching scripts"
echo " - quit with exit status 0 on getting eof"
echo " - quit with exit status >0 if an unhandled error occurs"
echo " you need to supply the .script in the second argument"
echo " lisps include abcl, ccl (clozure),"
echo " allegro, allegro8, allegromodern, allegromodern8,"
echo " allegro_s, allegro8_s, allegromodern_s, allegromodern8_s (SMP variants)"
echo " allegro_64, allegro8_64, allegromodern_64, allegromodern8_64 (64-bit variants),"
echo " allegro_64_s, allegro8_64_s, allegromodern_64_s, allegromodern8_64_s, (SMP, 64-bit variants)"
echo " clisp, cmucl, ecl, gcl, sbcl, scl and xcl."
echo " To configure the script, you may set environment variables to point to the various lisp runtimes."
echo " Allegro CL is a special case: instead of setting environment variables for the specific runtime"
echo " locations, you may simply specify the Allegro install directories using these variables:"
echo " ALLEGRO64DIR, ALLEGRO64SDIR (64-bit Allegro and SMP Allegro, respectively), ALLEGRODIR, and"
echo " ALLEGROSDIR."
echo "OPTIONS:"
echo " -c -- clean load test."
echo " -d -- debug mode."
echo " -t -- test interactively."
echo " -h -- show this message."
echo " -u -- upgrade tests."
echo " -l -- load systems tests."
echo " -H -- extract all asdf versions to upgrade from."
echo " -u -- upgrade tests, we already told you."
}
unset DEBUG_ASDF_TEST upgrade clean_load load_systems test_interactively extract_all
SHELL=/bin/sh
export SHELL DEBUG_ASDF_TEST GCL_ANSI ASDF_OUTPUT_TRANSLATIONS
if [ -n "$ALLEGRO64DIR" ] ; then
ALLEGRO_64=${ALLEGRO64DIR}/alisp
ALLEGRO8_64=${ALLEGRO64DIR}/alisp8
ALLEGROMODERN_64=${ALLEGRO64DIR}/mlisp
ALLEGROMODERN8_64=${ALLEGRO64DIR}/mlisp8
fi
if [ -n "$ALLEGRO64SDIR" ] ; then
ALLEGRO_64_S=${ALLEGRO64SDIR}/alisp
ALLEGRO8_64_S=${ALLEGRO64SDIR}/alisp8
ALLEGROMODERN_64_S=${ALLEGRO64SDIR}/mlisp
ALLEGROMODERN8_64_S=${ALLEGRO64SDIR}/mlisp8
fi
if [ -n "$ALLEGRODIR" ] ; then
ALLEGRO=${ALLEGRODIR}/alisp
ALLEGRO8=${ALLEGRODIR}/alisp8
ALLEGROMODERN=${ALLEGRODIR}/mlisp
ALLEGROMODERN8=${ALLEGRODIR}/mlisp8
fi
if [ -n "$ALLEGROSDIR" ] ; then
ALLEGRO_S=${ALLEGROSDIR}/alisp
ALLEGRO8_S=${ALLEGROSDIR}/alisp8
ALLEGROMODERN_S=${ALLEGROSDIR}/mlisp
ALLEGROMODERN8_S=${ALLEGROSDIR}/mlisp8
fi
while getopts "cdtHulhu" OPTION
do
case $OPTION in
c)
clean_load=t
;;
d)
DEBUG_ASDF_TEST=t
;;
t)
test_interactively=t
;;
h)
usage
exit 1
;;
u)
upgrade=t
;;
l)
load_systems=t
;;
H)
extract_all=t
;;
esac
done
shift $(($OPTIND - 1))
if [ x"$1" = "xhelp" ]; then
usage
exit 1
fi
lisp=${1:-sbcl} ; shift
ECHO () { printf '%s\n' "$*" ;}
ECHOn () { printf '%s' "$*" ;}
DBG () { ECHO "$*" >& 2 ;}
simple_term_p () {
case "$1" in *[!a-zA-Z0-9-+_,.:=%/]*) return 1 ;; *) return 0 ;; esac
}
kwote0 () { ECHOn "$1" | sed -e "s/\([\\\\\"\$\`]\)/\\\\\\1/g" ;}
kwote1 () { if simple_term_p "$1" ; then ECHOn "$1"
else ECHOn "\"$(kwote0 "$1")\"" ; fi ;}
kwote () { ( set +x
k="" ; for i ; do ECHOn "$k" ; kwote1 "$i" ; k=" " ; done ; echo
) }
DO () { kwote "$@" ; "$@" ; }
do_tests () {
if [ -z "$*" ]; then
scripts="*.script"
else
scripts="$*"
fi
env | grep -i asdf
## We go through great lengths to avoid " in the command line,
## the quoting of which many Windows implementations get wrong.
## While we're at it, we also avoid spaces and backslashes.
( DO $bcmd $eval '(or`,#.(load(string`|script-support.lisp|))#.(asdf-test::compile-asdf-script))' )
if [ $? -ne 0 ] ; then
echo "Compilation FAILED" >&2
echo "you can retry compilation with:" >&2
echo ./test/run-tests.sh $lisp >&2
echo "or more interactively (and maybe with rlwrap or in emacs), start with:" >&2
echo "$icmd" >&2
echo "then copy/paste:" >&2
echo '(load "test/script-support.lisp") (asdf-test::compile-asdf-script)' >&2
else
echo "Compiled OK" >&2
test_count=0
test_pass=0
test_fail=0
failed_list=""
for i in $scripts ;
do
echo "Testing: $i" >&2
test_count=`expr "$test_count" + 1`
rm -f ~/.cache/common-lisp/"`pwd`"/* || true
if DO $bcmd $eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|$i|))" ; then
echo "Using $command, $i passed" >&2
test_pass=`expr "$test_pass" + 1`
else
echo "Using $command, $i failed" >&2
test_fail=`expr "$test_fail" + 1`
failed_list="$failed_list $i"
echo "you can retry compilation with:" >&2
echo ./test/run-tests.sh $lisp $i >&2
echo "or more interactively (and maybe with rlwrap or in emacs), start with:" >&2
echo "(cd test ; $icmd )" >&2
echo "then copy/paste:" >&2
echo "'(#.(load \"script-support.lisp\") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load \"$i\")))" >&2
fi
echo >&2
echo >&2
done
echo >&2
echo "-#---------------------------------------" >&2
echo "Using $command" >&2
echo "Ran $test_count tests: " >&2
echo " $test_pass passing and $test_fail failing" >&2
if [ $test_fail -eq 0 ] ; then
echo "all tests apparently successful" >&2
echo success > ../build/results/status
else
echo "failing test(s): $failed_list" >&2
fi
echo "-#---------------------------------------" >&2
echo >&2
fi
}
#
# not used currently but leave here for future reference.
#
case $(uname) in
CYGWIN*) os=windows ;;
Darwin) os=macos ;;
Linux) os=linux ;;
*) os=unknown ;;
esac
# terminate on error
set -e
command= flags= nodebug= eval= bcmd= icmd=
case "$lisp" in
abcl)
command="${ABCL:-abcl}"
flags="--noinit --nosystem --noinform"
eval="--eval"
;;
allegro*)
case "$lisp" in
allegro) command="${ALLEGRO:-alisp}" ;;
allegro8) command="${ALLEGRO8:-alisp8}" ;;
allegromodern) command="${ALLEGROMODERN:-mlisp}" ;;
allegromodern8) command="${ALLEGROMODERN8:-mlisp8}" ;;
allegro_s) command="${ALLEGRO_S:-alisp_s}" ;;
allegro8_s) command="${ALLEGRO8_S:-alisp8_s}" ;;
allegromodern_s) command="${ALLEGROMODERN_S:-mlisp_s}" ;;
allegromodern8_s) command="${ALLEGROMODERN8_S:-mlisp8_s}" ;;
allegro_64) command="${ALLEGRO_64:-alisp_64}" ;;
allegro8_64) command="${ALLEGRO8_64:-alisp8_64}" ;;
allegromodern_64) command="${ALLEGROMODERN_64:-mlisp_64}" ;;
allegromodern8_64) command="${ALLEGROMODERN8_64:-mlisp8_64}" ;;
allegro_64_s) command="${ALLEGRO_64_S:-alisp_64_s}" ;;
allegro8_64_s) command="${ALLEGRO8_64_S:-alisp8_64_s}" ;;
allegromodern_64_s) command="${ALLEGROMODERN_64_S:-mlisp_64_s}" ;;
allegromodern8_64_s) command="${ALLEGROMODERN8_64_S:-mlisp8_64_s}" ;;
esac
# For the sake of the lisp-invocation library, re-export these
# ALLEGRO=$command ; export ALLEGRO ;
# echo ALLEGRO=$ALLEGRO
flags="-q"
nodebug="-batch"
if [ "$os" = windows ] && [ -z "$ALLEGRO_NOISY" ] ; then
adir=$(dirname "${command}") ;
allegroName=$(basename "${command}") ;
if [[ ${allegroName: -1} == "8" ]] ; then build=build ; else build=buildi ; fi ;
# this takes somewhat unjustifiable advantage of the fact that
# the Allegro images have the same name (with .dxl extension)
# as the corresponding executables. the "build" executable
# runs an ACL image in the current terminal instead of a
# separate window, as is normal on Windows.
bcmd="${adir}/${build}.exe -I ${command}.dxl $flags" ;
fi
eval="-e" ;;
ccl)
command="${CCL:-ccl}"
flags="--no-init --quiet"
nodebug="--batch"
eval="--eval" ;;
clasp)
command="${CLASP:-clasp}"
flags=""
eval="" ;;
clisp)
command="${CLISP:-clisp}"
flags="-norc --silent -ansi -I "
nodebug="-on-error exit"
eval="-x" ;;
cmucl)
# cmucl likes to have its executable called lisp, but so does scl
# Please use a symlink or an exec ... "$@" trampoline script.
command="${CMUCL:-cmucl}"
flags="-noinit"
nodebug="-batch"
eval="-eval" ;;
ecl)
command="${ECL:-ecl}"
flags="-norc -load sys:cmp"
eval="-eval" ;;
ecl_bytecodes)
command="${ECL:-ecl}"
flags="-norc -eval (ext::install-bytecodes-compiler)"
eval="-eval" ;;
gcl)
GCL_ANSI=t
command="${GCL:-gcl}"
flags=""
nodebug="-batch"
eval="-eval" ;;
lispworks)
command="${LISPWORKS:-lispworks-console}"
# If you have a licensed copy of lispworks,
# you can obtain the "lispworks" binary with, e.g.
# echo '(hcl:save-image "/lispworks" :environment nil)' > /tmp/build.lisp ;
# ./lispworks-6-0-0-x86-linux -siteinit - -init - -build /tmp/build.lisp
flags="-siteinit - -init -"
eval="-eval" ;;
mkcl)
command="${MKCL:-mkcl}"
flags="-norc"
eval="-eval" ;;
sbcl)
command="${SBCL:-sbcl}"
flags="--noinform --no-userinit --no-sysinit"
nodebug="--disable-debugger"
eval="--eval" ;;
scl)
command="${SCL:-scl}"
flags="-noinit"
nodebug="-batch"
eval="-eval" ;;
xcl)
command="${XCL:-xcl}"
flags="--no-userinit --no-siteinit --noinform"
eval="--eval" ;;
*)
echo "Unsupported lisp: $1" >&2
echo "Please add support to run-tests.sh" >&2
exit 42 ;;
esac
if ! type "$command" > /dev/null ; then
echo "lisp implementation not found: $command" >&2
exit 43
fi
ASDFDIR="$(cd $(dirname $0)/.. ; /bin/pwd)"
: ${bcmd:=$command $flags} ${icmd:=$command $flags} # batch and interactive
if [ -z "${DEBUG_ASDF_TEST}" ] ; then
bcmd="$bcmd $nodebug"
fi
create_config () {
cd ${ASDFDIR}
mkdir -p build/results/ build/test-source-registry-conf.d build/test-asdf-output-translations-conf.d
}
upgrade_tags () {
if [ -n "$ASDF_UPGRADE_TEST_TAGS" ] ; then
echo $ASDF_UPGRADE_TEST_TAGS ; return
fi
# REQUIRE is a magic tag meaning whatever your implementation provides, if anything
#
# 1.85 (2004-05-16) is the last release by Daniel Barlow (not 1.37, which is the README revision!)
# 1.97 (2006-05-14) is the last release before Gary King takes over
# 1.369 (2009-10-27) is the last release by Gary King
#
# 2.000 to 2.019 and 2.20 to 2.26 are Faré's "stable" ASDF 2 releases
# 2.000 (2010-05-31) was the first ASDF 2 release
# 2.008 (2010-09-10) was a somewhat stable ASDF 2 release
# 2.011 (2010-11-28) was used by CLISP 2.49, Debian squeeze, Ubuntu 10.04 LTS
# 2.014.6 (2011-04-06) was used by Quicklisp in 2011
# 2.019 (2011-11-27) was stable and used by LispWorks since 2012.
# 2.20 (2012-01-18) was in CCL 1.8, Ubuntu 12.04 LTS
# 2.22 (2012-06-12) was used by debian wheezy
# 2.26 (2012-10-30) was used by Quicklisp in 2013
#
# 2.26.x is where the refactoring that begat ASDF 3 took place.
# 2.26.61 is the last single-file, single-package ASDF.
# 2.27 to 2.33 are Faré's "stable" ASDF 3 pre-releases
# 2.27 (2013-02-01) is the first ASDF 3 pre-release
# 2.32 (2013-03-05) is the first really stable ASDF 3 pre-release
#
# The 3.0 series is a stable release of ASDF 3
# with Robert Goldman taking over maintainership at 3.0.2.
# 3.0.0 was just 2.33.10 promoted, but version-satisfies meant it was suddenly
# not compatible with ASDF2 anymore, so we immediately released 3.0.1
# 3.0.1 (2013-05-16) is the first stable ASDF 3 release
# 3.0.2 (2013-07-02) is the first ASDF 3 in SBCL
# 3.0.3 (2013-10-22) is the last in the ASDF 3.0 series
#
# The 3.1 series provides the 3.1 feature, meaning users can rely on
# all the stabilization work done in 3.0 so far, plus extra developments
# in UIOP, package-inferred-system, and more robustification.
# 3.1.2 (2014-05-06) is the first ASDF 3.1 release
#
# We return the above designated versions in order of decreasing relevance,
# which pretty much means REQUIRE and most recent first.
echo REQUIRE
echo 3.1.4 3.1.3 3.1.2
echo 3.0.3 3.0.2 3.0.1
# echo 2.32 2.27
# echo 2.26 2.22 2.20 2.019 2.014.6 2.011 2.008 2.000
# echo 1.369 1.97 1.85
}
upgrade_methods () {
if [ -n "$ASDF_UPGRADE_TEST_METHODS" ] ; then
echo $ASDF_UPGRADE_TEST_METHODS ; return
fi
cat <<EOF
'load-asdf-lisp'load-asdf-lisp-clean
'load-asdf-lisp'load-asdf-system
'load-asdf-lisp'compile-load-asdf-upgrade
'load-asdf-lisp'load-asdf-fasl
()'load-asdf-fasl
'load-asdf-lisp-and-test-uiop'load-asdf-fasl
EOF
}
extract_tagged_asdf () {
cd ${ASDFDIR}
mkdir -p build/
tag=$1
if [ REQUIRE = "$tag" ] ; then return 0 ; fi
file=build/asdf-${tag}.lisp ;
if [ ! -f $file ] ; then
case $tag in
1.*|2.0*|2.2[0-6]|2.26.61)
git show ${tag}:asdf.lisp > $file ;;
2.2[7-9]*|2.[3-9]*|3.*)
mkdir -p build/old/build
git archive ${tag} | (cd build/old/ ; tar xf -)
make -C build/old
mv build/old/build/asdf.lisp build/asdf-${tag}.lisp
rm -rf build/old ;;
*)
echo "Don't know how to extract asdf.lisp for version $tag"
exit 55
;;
esac
fi
}
extract_all_tagged_asdf () {
for i in `upgrade_tags` ; do
extract_tagged_asdf $i
done
}
valid_upgrade_test_p () {
case "${1}:${2}:${3}" in
# It's damn slow. Also, for some reason, we punt on anything earlier than 2.25,
# and only need to test it once, below for 2.24.
abcl:1.*|abcl:2.00[0-9]:*|abcl:201[0-9]:*|abcl:2.2[0-3]:*) : ;;
# ccl fasl numbering broke loading of old asdf 2.0
ccl:2.0[01]*) : ;;
# My old ubuntu 10.04LTS clisp 2.44.1 came wired in
# with an antique ASDF 1.374 from CLC that can't be downgraded.
# More recent CLISPs work.
# 2.00[0-7] use UID, which fails on some old CLISPs.
# Note that for the longest time, CLISP has included 2.011 in its distribution.
# Now its hg repository includes 3.0.2.29, but clisp hasn't released in many years(!)
# We don't punt on upgrade anymore, so we can go at it!
#clisp:2.00[0-7]:*|clisp:1.*|clisp:2.0[01]*|clisp:2.2[0-5]:*) : ;;
# CMUCL has problems with 2.32 and earlier because of
# the redefinition of system's superclass component.
cmucl:1.*|cmucl:2.[012]*|cmucl:2.3[012]*) : ;;
# Skip many ECL tests, for various ASDF issues
ecl*:1.*|ecl*:2.0[01]*|ecl*:2.20:*) : ;;
# GCL 2.7.0 from late November 2013 is required, with ASDF 3.1.2
gcl:REQUIRE:*|gcl:1.*|gcl:2.*|gcl:3.0*) : ;;
# LispWorks is broken at ASDF 3.0.3, but can upgrade from earlier and later ASDFs.
lispworks:3.0.3:*) : ;;
# MKCL is only supported starting with specific versions 2.24, 2.26.x, 3.0.3.0.x, so skip.
mkcl:[12]*|mkcl:3.0*) : ;;
# XCL support starts with ASDF 2.014.2
# — It also dies during upgrade trying to show the backtrace.
xcl:1.*|xcl:2.00*|xcl:2.01[0-4]:*|xcl:*) : ;;
*) return 0 ;;
esac
return 1
}
run_upgrade_tests () {
cd ${ASDFDIR}
mkdir -p build/results/
rm -f build/*.*f* uiop/*.*f* test/*.*f* ## Remove stale FASLs from ASDF 1.x, especially when different implementations have same name
ASDF_OUTPUT_TRANSLATIONS="(:output-translations (\"${ASDFDIR}\" (\"${ASDFDIR}/build/fasls/\" :implementation \"asdf/\")) (t (\"${ASDFDIR}/build/fasls/\" :implementation \"root/\")) :ignore-inherited-configuration)"
su=test/script-support.lisp
tags="`upgrade_tags`"
methods="`upgrade_methods`"
{
for tag in $tags ; do
for method in $methods ; do
if valid_upgrade_test_p $lisp $tag $method ; then
echo "Testing ASDF upgrade from ${tag} using method $method"
extract_tagged_asdf $tag
$bcmd $eval \
"'(#.(load(string'|$su|))#.#.\`(in-package,:asdf-test)#.(test-upgrade$method\`|$tag|))" ||
{ echo "upgrade FAILED for $lisp from $tag using method $method" ;
echo "you can retry just that test with:" ;
echo ASDF_UPGRADE_TEST_TAGS=\"$tag\" ASDF_UPGRADE_TEST_METHODS=\"$method\" ./test/run-tests.sh -u $lisp ;
echo "or more interactively (and maybe with rlwrap or in emacs), start with:"
echo "$icmd"
echo "then copy/paste:"
echo "(load \"$su\") (asdf-test::da) (test-upgrade $method \"$tag\")"
exit 1 ;}
fi ; done ; done
echo "Upgrade test succeeded for ${lisp}"
} 2>&1 | tee build/results/${lisp}-upgrade.text
}
run_tests () {
create_config
cd ./test/
echo failure > ../build/results/status
thedate=`date "+%Y-%m-%d"`
rm -f "../build/results/${lisp}-test.text" || :
do_tests "$@" 2>&1 | \
tee "../build/results/${lisp}-test.text" "../build/results/${lisp}-test-${thedate}.save"
read a < ../build/results/status
clean_up
if [ success = "$a" ] ; then ## exit code
return 0
else
echo "To view full results and failures, try the following command:" >&2
echo " less -p ABORTED build/results/${lisp}-test.text" >&2
return 1
fi
}
clean_up () {
rm -rf ../build/test-source-registry-conf.d ../build/test-asdf-output-translations-conf.d
}
test_clean_load () {
case $lisp in
gcl|cmucl) return 0 ;; # These are hopeless
esac
cd ${ASDFDIR}
mkdir -p build/results/
nop=build/results/${lisp}-nop.text
load=build/results/${lisp}-load.text
$bcmd $eval \
"(or'#.(load(string'|test/script-support.lisp|):verbose():print())#.(asdf-test:exit-lisp'0))" \
> $nop 2>&1
$bcmd $eval \
"(or'#.(load(string'|test/script-support.lisp|):verbose():print())#.(asdf-test:verbose())#.(load(string'|build/asdf.lisp|):verbose())#.(asdf/image:quit'0))" \
> $load 2>&1
if diff $nop $load ; then
echo "GOOD: Loading ASDF on $lisp produces no message" >&2 ; return 0
else
echo "BAD: Loading ASDF on $lisp produces messages" >&2 ; return 1
fi
}
test_load_systems () {
cd ${ASDFDIR}
mkdir -p build/results/
echo "Loading all these systems: $*"
$bcmd $eval \
"(or #.(load(string'|test/script-support.lisp|))#.(asdf-test:with-test()(asdf-test:test-load-systems $*)))" \
2>&1 | tee build/results/${lisp}-systems.text
}
test_interactively () {
cd ${ASDFDIR}
mkdir -p build/results/
rlwrap $icmd $eval "(or'#.(load(string'|test/script-support.lisp|))#.(asdf-test:interactive-test'($*)))"
}
if [ -z "$command" ] ; then
echo "Error: cannot find or do not know how to run Lisp named $lisp"
elif [ -n "$test_interactively" ] ; then
test_interactively "$@"
elif [ -n "$clean_load" ] ; then
test_clean_load
elif [ -n "$load_systems" ] ; then
test_load_systems "$@"
elif [ -n "$upgrade" ] ; then
run_upgrade_tests
elif [ -n "$extract_all" ] ; then
extract_all_tagged_asdf
else
run_tests "$@"
fi ; exit # NB: "; exit" makes it robust wrt the script being modified while running.
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment