run-tests.sh 17.6 KB
Newer Older
Daniel Barlow's avatar
Daniel Barlow committed
1 2
#!/bin/sh

3
# run-tests {lisp invocation} {scripts-regex}
4 5 6 7
# - 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

8 9 10 11 12 13
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"
14
    echo " lisps include abcl, ccl (clozure),"
15 16 17
    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),"
18
    echo "    allegro_64_s, allegro8_64_s, allegromodern_64_s, allegromodern8_64_s, (SMP, 64-bit variants)"
19 20 21 22 23 24
    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."
25 26
    echo "OPTIONS:"
    echo "    -d -- debug mode"
27 28
    echo "    -h -- show this message."
    echo "    -u -- upgrade tests."
29 30
    echo "    -c -- clean load test"
    echo "    -l -- load systems tests"
31
    echo "    -t -- test interactively"
32
    echo "    -H -- extract all asdf versions to upgrade from"
33 34
}

35
unset DEBUG_ASDF_TEST upgrade clean_load load_systems test_interactively extract_all
36
SHELL=/bin/sh
37
export SHELL DEBUG_ASDF_TEST GCL_ANSI ASDF_OUTPUT_TRANSLATIONS
Robert P. Goldman's avatar
Robert P. Goldman committed
38

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
if [ $ALLEGRO64DIR ] ; then
    ALLEGRO_64=${ALLEGRO64DIR}/alisp
    ALLEGRO8_64=${ALLEGRO64DIR}/alisp8
    ALLEGROMODERN_64=${ALLEGRO64DIR}/mlisp
    ALLEGROMODERN8_64=${ALLEGRO64DIR}/mlisp8
fi
if [ $ALLEGRO64SDIR ] ; then
    ALLEGRO_64_S=${ALLEGRO64SDIR}/alisp
    ALLEGRO8_64_S=${ALLEGRO64SDIR}/alisp8
    ALLEGROMODERN_64_S=${ALLEGRO64SDIR}/mlisp
    ALLEGROMODERN8_64_S=${ALLEGRO64SDIR}/mlisp8
fi
if [ $ALLEGRODIR ] ; then
    ALLEGRO=${ALLEGRODIR}/alisp
    ALLEGRO8=${ALLEGRODIR}/alisp8
    ALLEGROMODERN=${ALLEGRODIR}/mlisp
    ALLEGROMODERN8=${ALLEGRODIR}/mlisp8
fi
if [ $ALLEGROSDIR ] ; then
    ALLEGRO_S=${ALLEGROSDIR}/alisp
    ALLEGRO8_S=${ALLEGROSDIR}/alisp8
    ALLEGROMODERN_S=${ALLEGROSDIR}/mlisp
    ALLEGROMODERN8_S=${ALLEGROSDIR}/mlisp8
fi


65
while getopts "cdtHulhu" OPTION
Robert P. Goldman's avatar
Robert P. Goldman committed
66
do
67
    case $OPTION in
Robert P. Goldman's avatar
Robert P. Goldman committed
68
        d)
69
            DEBUG_ASDF_TEST=t
Robert P. Goldman's avatar
Robert P. Goldman committed
70 71
            ;;
        u)
72
            upgrade=t
Robert P. Goldman's avatar
Robert P. Goldman committed
73
            ;;
74 75 76
        c)
            clean_load=t
            ;;
77 78 79
        l)
            load_systems=t
            ;;
80 81 82
        t)
            test_interactively=t
            ;;
83 84 85
        H)
            extract_all=t
            ;;
Robert P. Goldman's avatar
Robert P. Goldman committed
86 87 88 89 90 91 92
        h)
            usage
            exit 1
            ;;
    esac
done
shift $(($OPTIND - 1))
93

94
if [ x"$1" = "xhelp" ]; then
Robert P. Goldman's avatar
Robert P. Goldman committed
95 96
    usage
    exit 1
97
fi
98
lisp=${1:-sbcl} ; shift
99

100

101 102 103 104 105 106 107 108 109 110 111 112 113
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 "$@" ; "$@" ; }
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
114

115
do_tests () {
116 117 118 119 120
  if [ -z "$*" ]; then
       scripts="*.script"
  else
       scripts="$*"
  fi
121
  env | grep -i asdf
122
  ## We go through great lengths to avoid " in the command line,
123
  ## the quoting of which many Windows implementations get wrong.
124
  ## While we're at it, we also avoid spaces and backslashes.
125
  ( DO $bcmd $eval '(or`,#.(load(string`|script-support.lisp|))#.(asdf-test::compile-asdf-script))' )
126 127
  if [ $? -ne 0 ] ; then
    echo "Compilation FAILED" >&2
128 129 130
    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
131
    echo "$icmd" >&2
132 133
    echo "then copy/paste:" >&2
    echo '(load "test/script-support.lisp") (asdf-test::compile-asdf-script)' >&2
134 135
  else
    echo "Compiled OK" >&2
136 137 138 139
    test_count=0
    test_pass=0
    test_fail=0
    failed_list=""
140 141
    for i in $scripts ;
    do
142 143
      echo "Testing: $i" >&2
      test_count=`expr "$test_count" + 1`
144
      rm -f ~/.cache/common-lisp/"`pwd`"/* || true
145
      if DO $bcmd $eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test::with-test()(load(string'|$i|))))" ; then
146
        echo "Using $command, $i passed" >&2
147 148
	test_pass=`expr "$test_pass" + 1`
      else
149
        echo "Using $command, $i failed" >&2
150 151
	test_fail=`expr "$test_fail" + 1`
	failed_list="$failed_list $i"
152 153 154
        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
155
        echo "(cd test ; $icmd )" >&2
156
        echo "then copy/paste:" >&2
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
157
        echo "'(#.(load \"script-support.lisp\") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load \"$i\")))" >&2
158
      fi
159 160
      echo >&2
      echo >&2
161 162
    done
    echo >&2
163
    echo "-#---------------------------------------" >&2
164
    echo "Using $command" >&2
165 166 167 168
    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
169
        echo success > ../build/results/status
170 171 172
    else
	echo "failing test(s): $failed_list" >&2
    fi
173
    echo "-#---------------------------------------" >&2
174
    echo >&2
175
  fi
176 177
}

178 179 180
#
# not used currently but leave here for future reference.
#
181 182
case $(uname) in
    CYGWIN*) os=windows ;;
183 184 185
    Darwin) os=macos ;;
    Linux) os=linux ;;
    *) os=unknown ;;
186 187
esac

188 189


190
# terminate on error
191 192
set -e

193
command= flags= nodebug= eval= bcmd= icmd=
194
case "$lisp" in
195 196
  abcl)
    command="${ABCL:-abcl}"
197
    flags="--noinit --nosystem --noinform"
198 199
    eval="--eval"
    ;;
200
  allegro*)
201 202 203 204 205
    case "$lisp" in
      allegro) command="${ALLEGRO:-alisp}" ;;
      allegro8) command="${ALLEGRO8:-alisp8}" ;;
      allegromodern) command="${ALLEGROMODERN:-mlisp}" ;;
      allegromodern8) command="${ALLEGROMODERN8:-mlisp8}" ;;
206 207 208 209 210 211 212 213 214 215 216 217
      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}" ;;
218
    esac
219 220
    flags="-q"
    nodebug="-batch"
221
    if [ "$os" = windows ] && [ -z "$ALLEGRO_NOISY" ] ; then bcmd="$command +c $flags" ; fi
222
    eval="-e" ;;
223
  ccl)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
224
    command="${CCL:-ccl}"
225 226 227
    flags="--no-init --quiet"
    nodebug="--batch"
    eval="--eval" ;;
228 229
  clisp)
    command="${CLISP:-clisp}"
230
    flags="-norc --silent -ansi -I "
231 232
    nodebug="-on-error exit"
    eval="-x" ;;
233
  cmucl)
234 235 236
    # cmucl likes to have its executable called lisp, but so does scl
    # Please use a symlink or an exec ... "$@" trampoline script.
    command="${CMUCL:-cmucl}"
237 238 239
    flags="-noinit"
    nodebug="-batch"
    eval="-eval" ;;
240
  ecl)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
241
    command="${ECL:-ecl}"
242 243
    flags="-norc -load sys:cmp"
    eval="-eval" ;;
244
  ecl_bytecodes)
245 246
    command="${ECL:-ecl}"
    flags="-norc -eval (ext::install-bytecodes-compiler)"
247
    eval="-eval" ;;
248
  gcl)
249
    GCL_ANSI=t
250
    command="${GCL:-gcl}"
251 252
    flags=""
    nodebug="-batch"
253
    eval="-eval" ;;
254
  lispworks)
Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
255
    command="${LISPWORKS:-lispworks}"
256 257 258 259
    # 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
260 261
    flags="-siteinit - -init -"
    eval="-eval" ;;
262 263 264 265
  mkcl)
    command="${MKCL:-mkcl}"
    flags="-norc"
    eval="-eval" ;;
266 267
  sbcl)
    command="${SBCL:-sbcl}"
268
    flags="--noinform --no-userinit --no-sysinit"
269
    nodebug="--disable-debugger"
270
    eval="--eval" ;;
271 272 273 274 275
  scl)
    command="${SCL:-scl}"
    flags="-noinit"
    nodebug="-batch"
    eval="-eval" ;;
276 277
  xcl)
    command="${XCL:-xcl}"
278
    flags="--no-userinit --no-siteinit --noinform"
279
    eval="--eval" ;;
280 281 282 283
  *)
    echo "Unsupported lisp: $1" >&2
    echo "Please add support to run-tests.sh" >&2
    exit 42 ;;
284
esac
285

286
if ! type "$command" > /dev/null ; then
287
    echo "lisp implementation not found: $command" >&2
288 289 290
    exit 43
fi

291
ASDFDIR="$(cd $(dirname $0)/.. ; /bin/pwd)"
292
: ${bcmd:=$command $flags} ${icmd:=$command $flags} # batch and interactive
293
if [ -z "${DEBUG_ASDF_TEST}" ] ; then
294
  bcmd="$bcmd $nodebug"
295 296
fi

Francois-Rene Rideau's avatar
Francois-Rene Rideau committed
297

298
create_config () {
299 300
    cd ${ASDFDIR}
    mkdir -p build/results/ build/test-source-registry-conf.d build/test-asdf-output-translations-conf.d
301
}
302
upgrade_tags () {
303 304
    if [ -n "$ASDF_UPGRADE_TEST_TAGS" ] ; then
        echo $ASDF_UPGRADE_TEST_TAGS ; return
305
    fi
306 307 308 309 310 311 312
    # 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 and beyond are Faré's "stable" ASDF 2 releases
313
    # 2.26.61 is the last single-file, single-package ASDF.
314 315 316 317 318 319 320 321 322 323 324 325
    # 2.27 and beyond are Faré's "stable" ASDF 3 pre-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
    # 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
    # 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
326
    # 3.0.1 (2013-05-16) is the first stable ASDF 3 release
327
    echo REQUIRE 1.85 1.97 1.369
328 329 330
    # git tag -l '2.0??'
    # git tag -l '2.??'
    echo 2.000 2.008 2.011 2.014.6 2.019 2.20 2.22 2.26
331 332
    echo 2.27 2.32
    git tag -l '3.0.[1-9]'
333
}
334
upgrade_methods () {
335 336
    if [ -n "$ASDF_UPGRADE_TEST_METHODS" ] ; then
        echo $ASDF_UPGRADE_TEST_METHODS ; return
337 338
    fi
    cat <<EOF
339
'load-asdf-lisp'load-asdf-lisp-clean
340
'load-asdf-lisp'load-asdf-system
341
'load-asdf-lisp'compile-load-asdf-upgrade
342 343
'load-asdf-lisp'load-asdf-fasl
()'load-asdf-fasl
344
'load-asdf-lisp-and-test-uiop'load-asdf-fasl
345 346
EOF
}
347
extract_tagged_asdf () {
348 349
    cd ${ASDFDIR}
    mkdir -p build/
350 351
    tag=$1
    if [ REQUIRE = "$tag" ] ; then return 0 ; fi
352 353
    file=build/asdf-${tag}.lisp ;
    if [ ! -f $file ] ; then
354
        case $tag in
355
            1.*|2.0*|2.2[0-6]|2.26.61)
356
                git show ${tag}:asdf.lisp > $file ;;
357
            2.2[7-9]*|2.[3-9]*|3.*)
358
                mkdir -p build/old/build
359
                git archive ${tag} | (cd build/old/ ; tar xf -)
360
                make -C build/old
361
                mv build/old/build/asdf.lisp build/asdf-${tag}.lisp
362 363
                rm -rf build/old ;;
             *)
364 365 366 367 368 369
                echo "Don't know how to extract asdf.lisp for version $tag"
                exit 55
                ;;
        esac
    fi
}
370 371 372 373 374
extract_all_tagged_asdf () {
    for i in `upgrade_tags` ; do
      extract_tagged_asdf $i
    done
}
375 376
valid_upgrade_test_p () {
    case "${1}:${2}:${3}" in
377 378 379
        # 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]:*) : ;;
380 381
        # Skip allegro modern on 1.x -- fails for rpgoldman on his mac (!)
        allegromodern:1.*) : ;;
382 383
        # ccl fasl numbering broke loading of old asdf 2.0
        ccl:2.0[01]*) : ;;
384 385
        # my old ubuntu clisp 2.44.1 is wired in
        # with an antique ASDF 1.374 from CLC that can't be downgraded.
386 387
        # 2.00[0-7] use UID, which fails on that CLISP and was removed afterwards.
        # Note that for the longest time, CLISP has included 2.011 in its distribution.
388 389
        # Since we punt on the upgrade, let's only do the test once, for 2.26.
        clisp:2.00[0-7]:*|clisp:1.*|clisp:2.0[01]*|clisp:2.2[0-5]:*) : ;;
390
        # Skip, CMUCL has problems before 2.014.7 due to source-registry upgrade.
391 392 393 394 395
        # Weird unidentified problems before 2.018, so we punt equally for everything before,
        # and only need to test it once: above, for 2.017.
        cmucl:1.*|cmucl:2.00*|cmucl:2.01[0-6]:*) : ;;
        # Skip many ECL tests, for various ASDF issues
        ecl*:1.*|ecl*:2.0[01]*|ecl*:2.20:*) : ;;
396 397
        # GCL 2.7.0 from late November 2013 is required, with ASDF 3.1.1
        gcl:1.*|gcl:2.*|gcl:3.0*) : ;;
398 399
        # MKCL is only supported starting with 2.24, so skip earlier versions
        mkcl:1.*|mkcl:2.0[01]*|mkcl:2.2[0-3]:*) : ;;
400 401
        # XCL support starts with ASDF 2.014.2
        # — It also dies during upgrade trying to show the backtrace.
402
        xcl:1.*|xcl:2.00*|xcl:2.01[0-4]:*|xcl:*) : ;;
403 404 405
        *) return 0 ;;
   esac
   return 1
406
}
407
run_upgrade_tests () {
408
    cd ${ASDFDIR}
409
    mkdir -p build/results/
410
    rm -f build/*.*f* uiop/*.*f* test/*.*f* ## Remove stale FASLs from ASDF 1.x, especially when different implementations have same name
411
    ASDF_OUTPUT_TRANSLATIONS="(:output-translations (\"${ASDFDIR}\" (\"${ASDFDIR}/build/fasls/\" :implementation \"asdf/\")) (t (\"${ASDFDIR}/build/fasls/\" :implementation \"root/\")) :ignore-inherited-configuration)"
412 413
    su=test/script-support.lisp
    for tag in `upgrade_tags` ; do
414 415 416 417
        for method in `upgrade_methods` ; do
            if valid_upgrade_test_p $lisp $tag $method ; then
                echo "Testing ASDF upgrade from ${tag} using method $method"
                extract_tagged_asdf $tag
418
                $bcmd $eval \
419
                "'(#.(load(string'|$su|))#.#.\`(in-package,:asdf-test)#.(test-upgrade$method\`|$tag|))" ||
420 421
                { echo "upgrade FAILED for $lisp from $tag using method $method" ;
                  echo "you can retry just that test with:" ;
422
                  echo ASDF_UPGRADE_TEST_TAGS=\"$tag\" ASDF_UPGRADE_TEST_METHODS=\"$method\" ./test/run-tests.sh -u $lisp ;
423
                  echo "or more interactively (and maybe with rlwrap or in emacs), start with:"
424
                  echo "$icmd"
425
                  echo "then copy/paste:"
426
                  echo "(load \"$su\") (asdf-test::da) (test-upgrade $method \"$tag\")"
427
                  exit 1 ;}
428
    fi ; done ; done 2>&1 | tee build/results/${lisp}-upgrade.text
429 430 431
}
run_tests () {
  create_config
432
  cd ./test/
433 434
  echo failure > ../build/results/status
    thedate=`date "+%Y-%m-%d"`
435
    rm -f "../build/results/${lisp}-test.text" || :
436
    do_tests "$@" 2>&1 | \
437
	tee "../build/results/${lisp}-test.text" "../build/results/${lisp}-test-${thedate}.save"
438 439
    read a < ../build/results/status
  clean_up
440 441 442 443
  if [ success = "$a" ] ; then ## exit code
      return 0
  else
     echo "To view full results and failures, try the following command:" >&2
444
     echo "     less -p ABORTED build/results/${lisp}-test.text" >&2
445 446
     return 1
  fi
447
}
448
clean_up () {
449
    rm -rf ../build/test-source-registry-conf.d ../build/test-asdf-output-translations-conf.d
450
}
451
test_clean_load () {
452
    case $lisp in
453
        gcl|cmucl) return 0 ;; # These are hopeless
454
    esac
455 456
    cd ${ASDFDIR}
    mkdir -p build/results/
457 458
    nop=build/results/${lisp}-nop.text
    load=build/results/${lisp}-load.text
459
    $bcmd $eval \
460 461
      "(or'#.(load(string'|test/script-support.lisp|):verbose():print())#.(asdf-test::exit-lisp'0))" \
      > $nop 2>&1
462
    $bcmd $eval \
463 464
      "(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
465 466 467 468 469 470
    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
}
471
test_load_systems () {
472 473
    cd ${ASDFDIR}
    mkdir -p build/results/
474
    echo "Loading all these systems: $*"
475
    $bcmd $eval \
476
      "(or #.(load(string'|test/script-support.lisp|))#.(asdf-test::with-test()(asdf-test::test-load-systems $*)))" \
477 478
        2>&1 | tee build/results/${lisp}-systems.text
}
479
test_interactively () {
480 481
    cd ${ASDFDIR}
    mkdir -p build/results/
482
    rlwrap $icmd $eval "(or'#.(load(string'|test/script-support.lisp|))#.(asdf-test::interactive-test'($*)))"
483
}
484

485
if [ -z "$command" ] ; then
486
    echo "Error: cannot find or do not know how to run Lisp named $lisp"
487 488
elif [ -n "$test_interactively" ] ; then
    test_interactively "$@"
489 490
elif [ -n "$clean_load" ] ; then
    test_clean_load
491
elif [ -n "$load_systems" ] ; then
492
    test_load_systems "$@"
493 494
elif [ -n "$upgrade" ] ; then
    run_upgrade_tests
495 496
elif [ -n "$extract_all" ] ; then
    extract_all_tagged_asdf
497
else
498
    run_tests "$@"
499
fi ; exit # NB: "; exit" makes it robust wrt the script being modified while running.