CL_SOURCE_REGISTRY=/boot/home/ecl/asdf/:/boot/home/ecl/asdf/uiop/:/boot/home/ecl/asdf/ext//
PWD=/boot/home/ecl/asdf/test
ASDF_TEST_LISPS=ecl
OLDPWD=/boot/home/ecl/asdf
ecl -norc -load sys:cmp -eval "(or\`,#.(load(string\`|script-support.lisp|))#.(asdf-test::compile-asdf-script))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Warning: Can you please fix ASDF to not emit style-warnings? Got a C::COMPILER-STYLE-WARNING:
Style warning:
  in file asdf.lisp, position 226311
  at (WITH-UPGRADABILITY NIL ...)
  ! The variable S is not used.
;;; Warning: Can you please fix ASDF to not emit style-warnings? Got a C::COMPILER-STYLE-WARNING:
Style warning:
  in file asdf.lisp, position 226311
  at (WITH-UPGRADABILITY NIL ...)
  ! The variable TOKEN is not used.
;;; Warning: Can you please fix ASDF to not emit style-warnings? Got a C::COMPILER-STYLE-WARNING:
Style warning:
  in file asdf.lisp, position 240212
  at (WITH-UPGRADABILITY NIL ...)
  ! The variable DIR-ARG is not used.
;;; Warning: Can you please fix ASDF to not emit style-warnings? Got a C::COMPILER-STYLE-WARNING:
Style warning:
  in file asdf.lisp, position 240212
  at (WITH-UPGRADABILITY NIL ...)
  ! The variable REDIRECTIONS is not used.
;;; Warning: Can you please fix ASDF to not emit style-warnings? Got a C::COMPILER-STYLE-WARNING:
Style warning:
  in file asdf.lisp, position 240212
  at (WITH-UPGRADABILITY NIL ...)
  ! The variable NORMALIZED is not used.
;;; Warning: Can you please fix ASDF to not emit style-warnings? Got a C::COMPILER-STYLE-WARNING:
Style warning:
  in file asdf.lisp, position 240212
  at (WITH-UPGRADABILITY NIL ...)
  ! The variable CHDIR is not used.
ASDF compiled with style-warnings, ignored for your implementation
Compiled OK
Testing: asdf-pathname-test.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|asdf-pathname-test.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running asdf-pathname-test.script with ecl-16.1.2-e640ef1c-haiku-x86
source registry: (("serve-event" . #P"SYS:SERVE-EVENT.ASD.NEWEST")
                  ("sockets" . #P"SYS:SOCKETS.ASD.NEWEST")
                  ("defsystem" . #P"SYS:DEFSYSTEM.ASD.NEWEST")
                  ("ql-minitar" . #P"SYS:QL-MINITAR.ASD.NEWEST")
                  ("cmp" . #P"SYS:CMP.ASD.NEWEST")
                  ("ecl-help" . #P"SYS:ECL-HELP.ASD.NEWEST")
                  ("ecl-cdb" . #P"SYS:ECL-CDB.ASD.NEWEST")
                  ("ecl-curl" . #P"SYS:ECL-CURL.ASD.NEWEST")
                  ("rt" . #P"SYS:RT.ASD.NEWEST")
                  ("ecl-quicklisp" . #P"SYS:ECL-QUICKLISP.ASD.NEWEST")
                  ("deflate" . #P"SYS:DEFLATE.ASD.NEWEST")
                  ("sb-bsd-sockets" . #P"SYS:SB-BSD-SOCKETS.ASD.NEWEST")
                  ("profile" . #P"SYS:PROFILE.ASD.NEWEST"))
output translations: ((#P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/**/*.*"
                       T)
                      (#P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/**/*.*"
                       T)
                      (#P"/boot/home/config/cache/common-lisp/ecl-16.1.2-e640ef1c-haiku-x86/**/*.*"
                       T)
                      (#P"/boot/home/ecl/asdf/**/*.*"
                       #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/**/*.*")
                      (#P"SYS:**;*.*.*" T)
                      (T
                       #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/**/*.*")
                      (T
                       #P"/boot/home/config/cache/common-lisp/ecl-16.1.2-e640ef1c-haiku-x86/**/*.*"))
(RESOLVE-LOCATION '(:HOME)) and
 (TRUENAME (USER-HOMEDIR-PATHNAME)) both evaluate to same path:
  #P"/boot/home/"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (RESOLVE-LOCATION '("/foo" "bar" "baz")) yields this:
  #P"/foo/bar/baz"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "foo" "bar") :NAME "baz" :TYPE
   NIL :VERSION NIL)

        the other expression #P"/foo/bar/baz" yields that:
  #P"/foo/bar/baz"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "foo" "bar") :NAME "baz" :TYPE
   NIL :VERSION :NEWEST)

(RESOLVE-LOCATION '("/foo" "bar" "baz") :ENSURE-DIRECTORY T) and
 #P"/foo/bar/baz/" both evaluate to same path:
  #P"/foo/bar/baz/"
(RESOLVE-LOCATION '("/foo" "bar" "baz") :ENSURE-DIRECTORY T :WILDEN T) and
 (WILDEN #P"/foo/bar/baz/") both evaluate to same path:
  #P"/foo/bar/baz/**/*.*"
(RESOLVE-LOCATION '("/foo" "bar" "baz") :ENSURE-DIRECTORY NIL :WILDEN T) and
 (WILDEN #P"/foo/bar/") both evaluate to same path:
  #P"/foo/bar/**/*.*"
(RESOLVE-LOCATION '("/foo" "bar" :**/ "baz" :*.*.*)
                  :ENSURE-DIRECTORY
                  NIL
                  :WILDEN
                  T) and
 (MERGE-PATHNAMES* *WILD-FILE* #P"/foo/bar/**/baz/") both evaluate to same path:
  #P"/foo/bar/**/baz/*.*"
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (MAKE-PATHNAME :HOST "ASDFTEST" :DIRECTORY '(:ABSOLUTE "system2" "module4") :NAME NIL :TYPE NIL) yields this:
  #P"ASDFTEST:SYSTEM2;MODULE4;"
  (:HOST "ASDFTEST" :DEVICE NIL :DIRECTORY (:ABSOLUTE "SYSTEM2" "MODULE4") :NAME NIL :TYPE NIL :VERSION NIL)

        the other expression (PARSE-NAMESTRING "ASDFTEST:system2;module4;") yields that:
  #P"ASDFTEST:SYSTEM2;MODULE4;"
  (:HOST "ASDFTEST" :DEVICE :UNSPECIFIC :DIRECTORY (:ABSOLUTE "SYSTEM2" "MODULE4") :NAME NIL :TYPE NIL :VERSION NIL)


;;; 20160907T055409Z : ECL 16.1.2 3.1.7.9


(:RESULT :TYPE "ECL" :VERSION "16.1.2" :FILE #P"/boot/home/ecl/asdf/build/results/ecl-pathnames.text" :SYSTEM-FAILURES (0 336) :DIRECTORY-FAILURES (0 672) :FILE-FAILURES (0 992) :HOMOGENEOUS 0) 
Checking CMUCL user-homedir-pathname issue.
Script succeeded
Using ecl, asdf-pathname-test.script passed


Testing: duplicate-components-test.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|duplicate-components-test.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running duplicate-components-test.script with ecl-16.1.2-e640ef1c-haiku-x86
; Loading system definition for duplicate-components from /boot/home/ecl/asdf/test/duplicate-components.asd
; Registering #<system "duplicate-components">
Script succeeded
Using ecl, duplicate-components-test.script passed


Testing: ecl-make-image.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|ecl-make-image.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running ecl-make-image.script with ecl-16.1.2-e640ef1c-haiku-x86
Test ld-flags in make-image. Should load from ecl-make-image/

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; BUILDING hello_aux.o FILE
;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; BUILDING A STANDALONE EXECUTABLE
;;;
TEST ABORTED: not a valid pathname designator NIL
Backtrace:
0: (#:G2351 NIL)
1: (UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX #(1915841584 10662680 1915841488))
2: (UIOP/IMAGE:PRINT-BACKTRACE NIL)
3: (UIOP/IMAGE:PRINT-CONDITION-BACKTRACE #(1 10664680 1915841988))
4: (#<bytecompiled-function ASDF-TEST:ACALL> ((ASDF-TEST::ARGS #<a SIMPLE-ERROR> :COUNT 69 :STREAM #<output stream "stdout">) (ASDF-TEST::NAME . :PRINT-CONDITION-BACKTRACE)))
5: (#<bytecompiled-function 191f4348> ((234 . 0) (#:G238) (233 . #:G237) (ASDF-TEST::C . #<a SIMPLE-ERROR>) (:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 191f4258>>)))
6: (UIOP/UTILITY:CALL-FUNCTION #(1 10659448 1915843780))
7: (UIOP/PATHNAME:ENSURE-ABSOLUTE-PATHNAME #(1915843912 10661360 1915843844))
8: (#:G3896 #(1915844280 10676072 1915844140 1915844128))
9: (UIOP/UTILITY:CALL-FUNCTION #(1 10659448 1915844724))
10: (ASDF/CACHE:CONSULT-ASDF-CACHE #(1915844864 10668744 1915844760))
11: (#:G3895 #(1 10676112 1915845072))
12: (#:G5722 #(1 10673688 1915845972 1915845976))
13: (ASDF/PLAN:MAP-DIRECT-DEPENDENCIES #(1915846248 10670760 1915846048))
14: (ASDF/BUNDLE:DIRECT-DEPENDENCY-FILES #(1 10673704 1915846564 1915846568))
15: (#:G5727 #(1 10679272 1915846688 1915846692))
16: (#:G3935 #(1915847136 10676136 1915847160))
17: (CALL-NEXT-METHOD NIL)
18: (#:G3913 NIL)
19: (UIOP/UTILITY:CALL-FUNCTION #(1 10659448 1915848100))
20: (ASDF/CACHE:CONSULT-ASDF-CACHE #(1915848240 10668744 1915848136))
21: (#:G3912 #(1 10676120 1915848448 1915848452))
22: (ASDF/BUNDLE::BUNDLE-OUTPUT-FILES #(1915849160 10673608 1915849084))
23: (#:G5628 #(1 10679176 1915849392 1915849396))
24: (CALL-NEXT-METHOD NIL)
25: (#:G3896 NIL)
26: (UIOP/UTILITY:CALL-FUNCTION #(1 10659448 1915850500))
27: (ASDF/CACHE:CONSULT-ASDF-CACHE #(1915850640 10668744 1915850536))
28: (#:G3895 #(1 10676112 1915850848))
29: (#:G4311 #(1 10677080 1915851536 1915851540))
30: (#:G4685 #(1 10677864 1915852268))
31: (#:G4728 #(1915852976 10678040 1915852908))
32: (#:G4941 #(1 10678792 1915853972 1915853976))
33: (CALL-NEXT-METHOD NIL)
34: (#:G4924 NIL)
35: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 10668824 1915854700))
36: (#:G4917 #(1915854992 10678704 1915854920 1915854912 1915854908))
37: (#:G4911 #(1 10678664 1915855924 1915855928))
38: (CALL-NEXT-METHOD NIL)
39: (#:G4924 NIL)
40: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 10668824 1915856652))
41: (#:G4917 #(1915856944 10678704 1915856872 1915856864 1915856860))
42: (#:G4917 #(1915857888 10678704 1915857816 1915857808 1915857804))
43: (ASDF/BUNDLE:MAKE-BUILD #(1 10673864 1915859140))
44: (#<bytecompiled-function SI:BYTECODES> NIL)
45: (#<bytecompiled-function SI:BYTECODES> NIL)
46: (#<bytecompiled-function 191f4258> ((ASDF-TEST::NAME . "ecl-make-image.script") (ASDF-TEST::FILE . ASDF-TEST::|ecl-make-image.script|)))
47: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 10668824 1915861724))
48: (#<bytecompiled-function ASDF-TEST::CALL-WITH-TEST> ((:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 191f4258>>)))
49: (#<bytecompiled-function ASDF-TEST:RUN-TEST-SCRIPT> ((ASDF-TEST::FILE . ASDF-TEST::|ecl-make-image.script|)))
50: (#<bytecompiled-function SI:BYTECODES> NIL)
51: (#<bytecompiled-function SI:BYTECODES> ((SI::OUTPUT-FILE . T) (SI::C-FILE) (SI::H-FILE) (SI::DATA-FILE) (SI::VERBOSE . T) (SI::SYSTEM-P) (EXT:QUIT)))
52: (#<bytecompiled-function SI:BYTECODES> NIL)
53: (NIL NIL)
Above backtrace due to this condition:
not a valid pathname designator NIL
Script failed
Using ecl, ecl-make-image.script failed
you can retry compilation with:
./test/run-tests.sh ecl ecl-make-image.script
or more interactively (and maybe with rlwrap or in emacs), start with:
(cd test ; ecl -norc -load sys:cmp )
then copy/paste:
'(#.(load "script-support.lisp") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load "ecl-make-image.script")))


Testing: package-inferred-system-test.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|package-inferred-system-test.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running package-inferred-system-test.script with ecl-16.1.2-e640ef1c-haiku-x86
;;;
;;; Compiling /boot/home/ecl/asdf/test/package-inferred-system-test/a.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
This is compile-time and the *read-base* is 2
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/package-inferred-system-test/a.lisp.
;;;
This is load-time and the *read-base* is 10
(add10 0) is (in decimal) 2
;;;
;;; Compiling /boot/home/ecl/asdf/test/package-inferred-system-test/c.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/package-inferred-system-test/c.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/package-inferred-system-test/a/x.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/package-inferred-system-test/a/x.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/package-inferred-system-test/b.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/package-inferred-system-test/b.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/package-inferred-system-test/d.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/package-inferred-system-test/d.lisp.
;;;
Checking whether (LOAD-SYSTEM :PACKAGE-INFERRED-SYSTEM-TEST/E) signals PACKAGE-INFERRED-SYSTEM-MISSING-PACKAGE-ERROR
Received signal #<a ASDF/PACKAGE-INFERRED-SYSTEM:PACKAGE-INFERRED-SYSTEM-MISSING-PACKAGE-ERROR>
Checking whether (LOAD-SYSTEM :PACKAGE-INFERRED-SYSTEM-TEST/F) signals MISSING-COMPONENT
Received signal Component :PACKAGE-INFERRED-SYSTEM-TEST/F not found
Script succeeded
Using ecl, package-inferred-system-test.script passed


Testing: test-around-compile.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-around-compile.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-around-compile.script with ecl-16.1.2-e640ef1c-haiku-x86
Testing around-compile with a function name
; Registering #<system "test-around-compile">
;;;
;;; Compiling /boot/home/ecl/asdf/test/test.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
This is compile-time and the *read-base* is 2
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/test.lisp.
;;;
This is load-time and the *read-base* is 10
(add10 0) is (in decimal) 2
Testing around-compile with a lambda
; Registering #<system "test-around-compile-lambda">
;;;
;;; Compiling /boot/home/ecl/asdf/test/test.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
This is compile-time and the *read-base* is 9
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/test.lisp.
;;;
This is load-time and the *read-base* is 10
(add10 0) is (in decimal) 9
Script succeeded
Using ecl, test-around-compile.script passed


Testing: test-asdf.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-asdf.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-asdf.script with ecl-16.1.2-e640ef1c-haiku-x86
;;;
;;; Compiling /boot/home/ecl/asdf/test/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file1.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file3.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file3.lisp.
;;;
FOO
  ASDF-TEST::*PLAN* => #<a ASDF/PLAN:SEQUENTIAL-PLAN>
  (ASDF/ACTION:COMPONENT-DEPENDS-ON 'ASDF/LISP-ACTION:COMPILE-OP '("test-asdf/test-module-depend" "quux" "file3mod" "file3")) => ((ASDF/LISP-ACTION:PREPARE-OP #<cl-source-file "test-asdf/test-module-depend" "quux" "file3mod" "file3">))
  (ASDF/COMPONENT:COMPONENT-IF-FEATURE (ASDF/FIND-COMPONENT:FIND-COMPONENT "test-asdf/test-module-depend" '("quux" "file3mod" "file3"))) => :COMMON-LISP
Script succeeded
Using ecl, test-asdf.script passed


Testing: test-builtin-source-file-type.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-builtin-source-file-type.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-builtin-source-file-type.script with ecl-16.1.2-e640ef1c-haiku-x86
3.1.7.9
; Registering #<system "test-builtin-source-file-type-1">
;;;
;;; Compiling /boot/home/ecl/asdf/test/test-tmp.cl.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
compiling test-tmp.cl
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/test-tmp.cl.
;;;
loading test-tmp.cl
; Loading system definition for test-source-file-type-1 from /boot/home/ecl/asdf/test/test-source-file-type-1.asd
; Registering #<system "test-source-file-type-1">
Hello, world!
; Registering #<system "test-builtin-source-file-type-2">
loading test-tmp.cl
; Registering #<system "test-builtin-source-file-type-3">
loading test-tmp.cl
; Registering #<system "test-builtin-source-file-type-4">
loading test-tmp.cl
Script succeeded
Using ecl, test-builtin-source-file-type.script passed


Testing: test-bundle.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-bundle.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-bundle.script with ecl-16.1.2-e640ef1c-haiku-x86
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
TEST ABORTED: The assertion (LENGTH=N-P ASDF/ACTION::FILES 1) failed
Backtrace:
0: (#:G2351 NIL)
1: (UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX #(1903367424 15377176 1903367328))
2: (UIOP/IMAGE:PRINT-BACKTRACE NIL)
3: (UIOP/IMAGE:PRINT-CONDITION-BACKTRACE #(1 15379176 1903367828))
4: (#<bytecompiled-function ASDF-TEST:ACALL> ((ASDF-TEST::ARGS #<a SIMPLE-TYPE-ERROR> :COUNT 69 :STREAM #<output stream "stdout">) (ASDF-TEST::NAME . :PRINT-CONDITION-BACKTRACE)))
5: (#<bytecompiled-function 1983f348> ((390 . 0) (#:G238) (389 . #:G237) (ASDF-TEST::C . #<a SIMPLE-TYPE-ERROR>) (:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1983f258>>)))
6: (ASDF/ACTION:OUTPUT-FILE #(1903369536 15384744 1903369484))
7: (#<bytecompiled-function SI:BYTECODES> NIL)
8: (#<bytecompiled-function 1983f258> ((ASDF-TEST::NAME . "test-bundle.script") (ASDF-TEST::FILE . ASDF-TEST::|test-bundle.script|)))
9: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 15383320 1903371244))
10: (#<bytecompiled-function ASDF-TEST::CALL-WITH-TEST> ((:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1983f258>>)))
11: (#<bytecompiled-function ASDF-TEST:RUN-TEST-SCRIPT> ((ASDF-TEST::FILE . ASDF-TEST::|test-bundle.script|)))
12: (#<bytecompiled-function SI:BYTECODES> NIL)
13: (#<bytecompiled-function SI:BYTECODES> ((SI::OUTPUT-FILE . T) (SI::C-FILE) (SI::H-FILE) (SI::DATA-FILE) (SI::VERBOSE . T) (SI::SYSTEM-P) (EXT:QUIT)))
14: (#<bytecompiled-function SI:BYTECODES> NIL)
15: (NIL NIL)
Above backtrace due to this condition:
The assertion (UIOP/UTILITY:LENGTH=N-P ASDF/ACTION::FILES 1) failed
Script failed
Using ecl, test-bundle.script failed
you can retry compilation with:
./test/run-tests.sh ecl test-bundle.script
or more interactively (and maybe with rlwrap or in emacs), start with:
(cd test ; ecl -norc -load sys:cmp )
then copy/paste:
'(#.(load "script-support.lisp") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load "test-bundle.script")))


Testing: test-cache-for-introspection.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-cache-for-introspection.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-cache-for-introspection.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-weakly-depends-on">
; Loading system definition for file3-only from /boot/home/ecl/asdf/test/file3-only.asd
; Registering #<system "file3-only">
; Registering #<system "test-no-weakly-depends-on">
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
; Registering #<system "versioned-system-3">
; Registering #<system "versioned-system-4">
; Registering #<system "test-concatenate-source">
; Registering #<system "test-structured-depends">
The weakly-depends-on information is properly cached
The depends-on information is properly cached
The defsystem-depends-on information is properly cached
Test structured dependencies
Test removal of non-orthogonal feature syntax.
; Registering #<system "test-structured-depends-with-obsolete-feature-syntax">
Script succeeded
Using ecl, test-cache-for-introspection.script passed


Testing: test-cache.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-cache.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-cache.script with ecl-16.1.2-e640ef1c-haiku-x86
Script succeeded
Using ecl, test-cache.script passed


Testing: test-compile-file-failure.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-compile-file-failure.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-compile-file-failure.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-compile-file-failure">
;;;
;;; Compiling /boot/home/ecl/asdf/test/test-compile-file-failure.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; Warning: Warning.
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/test-compile-file-failure.lisp.
;;;
;;; Warning: Lisp compilation failed while compiling
   #<cl-source-file "test-compile-file-failure" "test-compile-file-failure">
;;; Warning: Lisp compilation had style-warnings while compiling
   #<cl-source-file "test-compile-file-failure" "test-compile-file-failure">
;;; Warning: Warning.
;;;
;;; Compiling /boot/home/ecl/asdf/test/test-compile-file-failure.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; Warning: Warning.
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/test-compile-file-failure.lisp.
;;;
Script succeeded
Using ecl, test-compile-file-failure.script passed


Testing: test-concatenate-source.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-concatenate-source.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-concatenate-source.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-concatenate-source">
; Loading system definition for file3-only from /boot/home/ecl/asdf/test/file3-only.asd
; Registering #<system "file3-only">
(NTH 0 (INPUT-FILES MCSO SYS)) and
 (NTH 0
      (LOOP :FOR
            N
            :IN
            '(3 1 2)
            :COLLECT
            (TEST-SOURCE (FORMAT NIL "file~D.lisp" N)))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/file3.lisp"
(NTH 1 (INPUT-FILES MCSO SYS)) and
 (NTH 1
      (LOOP :FOR
            N
            :IN
            '(3 1 2)
            :COLLECT
            (TEST-SOURCE (FORMAT NIL "file~D.lisp" N)))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/file1.lisp"
(NTH 2 (INPUT-FILES MCSO SYS)) and
 (NTH 2
      (LOOP :FOR
            N
            :IN
            '(3 1 2)
            :COLLECT
            (TEST-SOURCE (FORMAT NIL "file~D.lisp" N)))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/file2.lisp"
(OUTPUT-FILE MCSO SYS) and
 (APPLY-OUTPUT-TRANSLATIONS
  (RESOLVE-OUTPUT "asdf/test/test-concatenate-source--all-systems.lisp")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-concatenate-source--all-systems.lisp"
(NTH 0 (OUTPUT-FILES MCSO SYS)) and
 (NTH 0 (INPUT-FILES MCCSO SYS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-concatenate-source--all-systems.lisp"
(FIRST (OUTPUT-FILES MCCSO SYS)) and
 (TEST-FASL "test-concatenate-source--all-systems.lisp") both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-concatenate-source--all-systems.fas"
(NTH 0 (OUTPUT-FILES MCCSO SYS)) and
 (NTH 0 (INPUT-FILES MLCCSO SYS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-concatenate-source--all-systems.fas"
(NTH 1 (OUTPUT-FILES MCCSO SYS)) and
 (NTH 1 (INPUT-FILES MLCCSO SYS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-concatenate-source--all-systems.o"
;;;
;;; Compiling /boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-concatenate-source--all-systems.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-concatenate-source--all-systems.lisp.
;;;
Script succeeded
Using ecl, test-concatenate-source.script passed


Testing: test-configuration.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-configuration.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-configuration.script with ecl-16.1.2-e640ef1c-haiku-x86
subdirectories of dir2/: (#P"/boot/home/ecl/asdf/build/dir2/dir4/"
                          #P"/boot/home/ecl/asdf/build/dir2/dir3/")
subdirectories of dir5/: (#P"/boot/home/ecl/asdf/build/dir5/dir7/"
                          #P"/boot/home/ecl/asdf/build/dir5/dir6/")
Source Registry: #<hash-table 1a090570>
; Loading system definition for foo0 from /boot/home/ecl/asdf/build/dir1/foo0.asd
; Registering #<system "foo0">
; Loading system definition for foo1 from /boot/home/ecl/asdf/build/dir2/dir3/foo1.asd
; Registering #<system "foo1">
; Loading system definition for foo2 from /boot/home/ecl/asdf/build/dir2/dir4/foo2.asd
; Registering #<system "foo2">
; Loading system definition for foo3 from /boot/home/ecl/asdf/build/dir2/foo3.asd
; Registering #<system "foo3">
; Loading system definition for foo4 from /boot/home/ecl/asdf/build/dir5/dir6/foo4.asd
; Registering #<system "foo4">
; Loading system definition for foo6 from /boot/home/ecl/asdf/build/dir8/foo6.asd
; Registering #<system "foo6">
; Loading system definition for foo7 from /boot/home/ecl/asdf/build/dir9/dira/foo7.asd
; Registering #<system "foo7">
; Loading system definition for foo8 from /boot/home/ecl/asdf/build/dir9/dira/dirc/foo8.asd
; Registering #<system "foo8">
A: "/boot/home/ecl/asdf/build/dir2/bar/baz.lisp"
B: "/boot/home/ecl/asdf/build/dir2/bar/baz.lisp"
Script succeeded
Using ecl, test-configuration.script passed


Testing: test-deferred-warnings.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-deferred-warnings.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-deferred-warnings.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "unintern-foo">
; Registering #<system "use-foo-only">
; Registering #<system "use-foo-with-wrapper">
; Registering #<system "use-then-defun-foo">
; Registering #<system "use-then-defmacro-foo">
; Registering #<system "use-setf-foo-only">
; Registering #<system "use-setf-then-defun-foo">
; Registering #<system "use-setf-then-defsetf-foo">
; Registering #<system "undefined-variables">
TDW0
  UIOP/LISP-BUILD:*COMPILE-FILE-WARNINGS-BEHAVIOUR* => :WARN
;;;
;;; Compiling /boot/home/ecl/asdf/test/unintern-foo.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/unintern-foo.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/use-foo.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/use-foo.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/use-foo.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/use-foo.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/use-setf-foo.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/use-setf-foo.lisp.
;;;
TDW1
  UIOP/LISP-BUILD:*WARNINGS-FILE-TYPE* => NIL
;;;
;;; Compiling /boot/home/ecl/asdf/test/use-foo.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/use-foo.lisp.
;;;
Your Lisp does not support deferred-warnings
Using ecl, test-deferred-warnings.script passed


Testing: test-defsystem-depends-on.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-defsystem-depends-on.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-defsystem-depends-on.script with ecl-16.1.2-e640ef1c-haiku-x86
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
; Registering #<system "test-asdf/l-file">
; Registering #<package-inferred-system "test-asdf/l-file">
;;;
;;; Compiling /boot/home/ecl/asdf/test/l-file.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/l-file.lisp.
;;;
; Registering #<system "test-defsystem-depends-on-1">
;;;
;;; Compiling /boot/home/ecl/asdf/test/test-extension.l.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.In file included from /boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-extension.c:8:0:
/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-extension.data:1:0: warning: "compiler_data_text" redefined
 #define compiler_data_text NULL
 ^
In file included from /boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-extension.c:6:0:
/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/test-extension.eclh:13:0: note: this is the location of the previous definition
 #define compiler_data_text 0
 ^

;;; Finished compiling /boot/home/ecl/asdf/test/test-extension.l.
;;;
; Registering #<system "test-asdf/l-operation">
; Registering #<package-inferred-system "test-asdf/l-operation">
;;;
;;; Compiling /boot/home/ecl/asdf/test/l-operation.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/l-operation.lisp.
;;;
; Registering #<system "test-defsystem-depends-on-2">
; Registering #<system "test-defsystem-depends-on-3">
Checking whether (MAKE :TEST-DEFSYSTEM-DEPENDS-ON-3) signals ASDF/FIND-SYSTEM:FORMATTED-SYSTEM-DEFINITION-ERROR
Received signal #<a ASDF/FIND-SYSTEM:FORMATTED-SYSTEM-DEFINITION-ERROR>
; Registering #<system "test-defsystem-depends-on-4">
Checking whether (DEF-TEST-SYSTEM UNLOADABLE-SYSTEM
                                  :DEFSYSTEM-DEPENDS-ON
                                  (NONEXISTENT-SYSTEM)) signals MISSING-DEPENDENCY
Received signal Component "nonexistent-system" not found, required by NIL
Checking whether (FIND-SYSTEM "test-defsystem-depends-on-missing-system") signals MISSING-DEPENDENCY
; Loading system definition for test-defsystem-depends-on-missing-system from /boot/home/ecl/asdf/test/test-defsystem-depends-on-missing-system.asd
Received signal Component "nonexistent-system" not found, required by NIL
Script succeeded
Using ecl, test-defsystem-depends-on.script passed


Testing: test-defsystem-errors.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-defsystem-errors.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-defsystem-errors.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "foo">
Script succeeded
Using ecl, test-defsystem-errors.script passed


Testing: test-encodings.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-encodings.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-encodings.script with ecl-16.1.2-e640ef1c-haiku-x86
Test TEST-ENCODING-EXPLICIT-U8: should be UTF-8
; Registering #<system "test-encoding-explicit-u8">
Couldn't find ASDF-ENCODINGS. Skipping the rest the test.
Using ecl, test-encodings.script passed


Testing: test-force.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-force.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-force.script with ecl-16.1.2-e640ef1c-haiku-x86
Check that :force t forces the current system but not its dependencies
  ASDF-TEST::PLAN => ((#<prepare-op > . #<system "test-asdf/force">) (#<prepare-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<cl-source-file "test-asdf/force" "file3">) (#<load-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<system "test-asdf/force">) (#<load-op > . #<system "test-asdf/force">))
Check that :force :all forces the current system and its dependencies
  ASDF-TEST::PLAN => ((#<prepare-op > . #<system "test-asdf/force1">) (#<prepare-op > . #<cl-source-file "test-asdf/force1" "file1">) (#<compile-op > . #<cl-source-file "test-asdf/force1" "file1">) (#<load-op > . #<cl-source-file "test-asdf/force1" "file1">) (#<compile-op > . #<system "test-asdf/force1">) (#<load-op > . #<system "test-asdf/force1">) (#<prepare-op > . #<system "test-asdf/force">) (#<prepare-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<cl-source-file "test-asdf/force" "file3">) (#<load-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<system "test-asdf/force">) (#<load-op > . #<system "test-asdf/force">))
Check that :force-not takes precedence over :force, with t means "all but current system"
  ASDF-TEST::PLAN => ((#<prepare-op > . #<system "test-asdf/force">) (#<prepare-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<cl-source-file "test-asdf/force" "file3">) (#<load-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<system "test-asdf/force">) (#<load-op > . #<system "test-asdf/force">))
Check that :force-not :all means "all systems"
  ASDF-TEST::PLAN => NIL
Check that :force-not :all takes precedence over :force
  ASDF-TEST::PLAN => NIL
Check that immutable-systems will block forcing
  ASDF-TEST::PLAN => ((#<prepare-op > . #<system "test-asdf/force">) (#<prepare-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<cl-source-file "test-asdf/force" "file3">) (#<load-op > . #<cl-source-file "test-asdf/force" "file3">) (#<compile-op > . #<system "test-asdf/force">) (#<load-op > . #<system "test-asdf/force">))
;;;
;;; Compiling /boot/home/ecl/asdf/test/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file1.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file3.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file3.lisp.
;;;
Script succeeded
Using ecl, test-force.script passed


Testing: test-inline-methods.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-inline-methods.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-inline-methods.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "foo">
Method run before loading FASL for #<cl-source-file "foo" "file1"> - *a* = 1

;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
Method run for loading FASL for #<cl-source-file "foo" "file2"> - *a* = 2
Script succeeded
Using ecl, test-inline-methods.script passed


Testing: test-logical-pathname.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-logical-pathname.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-logical-pathname.script with ecl-16.1.2-e640ef1c-haiku-x86
LOGICAL
  (LOGICAL-PATHNAME-TRANSLATIONS "ASDF") => ((#P"ASDF:**;*.ASD.*" #P"/boot/home/ecl/asdf/**/*.asd") (#P"ASDF:**;*.LISP.*" #P"/boot/home/ecl/asdf/**/*.lisp") (#P"ASDF:**;*.*.*" #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/**/*.*"))
  (TRANSLATE-LOGICAL-PATHNAME "ASDF:test;test-logical-pathname.asd") => #P"/boot/home/ecl/asdf/test/test-logical-pathname.asd"
  (TRUENAME "ASDF:test;test-logical-pathname.asd") => #P"/boot/home/ecl/asdf/test/test-logical-pathname.asd"
  (TRANSLATE-LOGICAL-PATHNAME "ASDF:test;test-logical-pathname.lisp") => #P"/boot/home/ecl/asdf/test/test-logical-pathname.lisp"
  (TRANSLATE-LOGICAL-PATHNAME "ASDF:test;test-logical-pathname.fasl") => #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/test/test-logical-pathname.fasl"
Test logical pathnames in central registry
loading
  (ASDF/OPERATE:LOAD-SYSTEM :TEST-LOGICAL-PATHNAME :FORCE T) => 
;;;
;;; Compiling /boot/home/ecl/asdf/test/logical-file.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/logical-file.lisp.
;;;
T
Test logical pathnames in source-registry, non-recursive
; Loading system definition for test-logical-pathname from ASDF:TEST;TEST-LOGICAL-PATHNAME.ASD.NEWEST
; Registering #<system "test-logical-pathname">
;;;
;;; Compiling ASDF:TEST;LOGICAL-FILE.LISP.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling ASDF:TEST;LOGICAL-FILE.LISP.
;;;
Test logical pathnames in source-registry, recursive
;;;
;;; Compiling ASDF:TEST;LOGICAL-FILE.LISP.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling ASDF:TEST;LOGICAL-FILE.LISP.
;;;
Done
Script succeeded
Using ecl, test-logical-pathname.script passed


Testing: test-make-build.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-make-build.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-make-build.script with ecl-16.1.2-e640ef1c-haiku-x86
build sample-system. Should load from sample-system/
; Loading system definition for sample-system from /boot/home/ecl/asdf/test/sample-system/sample-system.asd
; Registering #<system "sample-system">
TEST ABORTED: not a valid pathname designator NIL
Backtrace:
0: (#:G2351 NIL)
1: (UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX #(1906751040 28181272 1906750944))
2: (UIOP/IMAGE:PRINT-BACKTRACE NIL)
3: (UIOP/IMAGE:PRINT-CONDITION-BACKTRACE #(1 28183272 1906751444))
4: (#<bytecompiled-function ASDF-TEST:ACALL> ((ASDF-TEST::ARGS #<a SIMPLE-ERROR> :COUNT 69 :STREAM #<output stream "stdout">) (ASDF-TEST::NAME . :PRINT-CONDITION-BACKTRACE)))
5: (#<bytecompiled-function 19caa348> ((212 . 0) (#:G238) (211 . #:G237) (ASDF-TEST::C . #<a SIMPLE-ERROR>) (:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 19caa258>>)))
6: (UIOP/UTILITY:CALL-FUNCTION #(1 28178040 1906753236))
7: (UIOP/PATHNAME:ENSURE-ABSOLUTE-PATHNAME #(1906753368 28179952 1906753300))
8: (#:G3896 #(1906753736 28194664 1906753596 1906753584))
9: (UIOP/UTILITY:CALL-FUNCTION #(1 28178040 1906754180))
10: (ASDF/CACHE:CONSULT-ASDF-CACHE #(1906754320 28187336 1906754216))
11: (#:G3895 #(1 28194704 1906754528))
12: (#:G5722 #(1 28192280 1906755428 1906755432))
13: (ASDF/PLAN:MAP-DIRECT-DEPENDENCIES #(1906755704 28189352 1906755504))
14: (ASDF/BUNDLE:DIRECT-DEPENDENCY-FILES #(1 28192296 1906756020 1906756024))
15: (#:G5727 #(1 28197864 1906756144 1906756148))
16: (#:G3935 #(1906756592 28194728 1906756616))
17: (CALL-NEXT-METHOD NIL)
18: (#:G3913 NIL)
19: (UIOP/UTILITY:CALL-FUNCTION #(1 28178040 1906757556))
20: (ASDF/CACHE:CONSULT-ASDF-CACHE #(1906757696 28187336 1906757592))
21: (#:G3912 #(1 28194712 1906757904 1906757908))
22: (ASDF/BUNDLE::BUNDLE-OUTPUT-FILES #(1906758616 28192200 1906758540))
23: (#:G5628 #(1 28197768 1906758848 1906758852))
24: (CALL-NEXT-METHOD NIL)
25: (#:G3896 NIL)
26: (UIOP/UTILITY:CALL-FUNCTION #(1 28178040 1906759956))
27: (ASDF/CACHE:CONSULT-ASDF-CACHE #(1906760096 28187336 1906759992))
28: (#:G3895 #(1 28194704 1906760304))
29: (#:G4311 #(1 28195672 1906760992 1906760996))
30: (#:G4685 #(1 28196456 1906761724))
31: (#:G4728 #(1906762432 28196632 1906762364))
32: (#:G4941 #(1 28197384 1906763412 1906763416))
33: (CALL-NEXT-METHOD NIL)
34: (#:G4924 NIL)
35: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 28187416 1906764124))
36: (#:G4917 #(1906764416 28197296 1906764344 1906764336 1906764332))
37: (#:G4911 #(1 28197256 1906765332 1906765336))
38: (CALL-NEXT-METHOD NIL)
39: (#:G4924 NIL)
40: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 28187416 1906766044))
41: (#:G4917 #(1906766336 28197296 1906766264 1906766256 1906766252))
42: (#:G4917 #(1906767264 28197296 1906767192 1906767184 1906767180))
43: (ASDF/BUNDLE:MAKE-BUILD #(1 28192456 1906768500))
44: (#<bytecompiled-function SI:BYTECODES> NIL)
45: (#<bytecompiled-function 19caa258> ((ASDF-TEST::NAME . "test-make-build.script") (ASDF-TEST::FILE . ASDF-TEST::|test-make-build.script|)))
46: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 28187416 1906769772))
47: (#<bytecompiled-function ASDF-TEST::CALL-WITH-TEST> ((:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 19caa258>>)))
48: (#<bytecompiled-function ASDF-TEST:RUN-TEST-SCRIPT> ((ASDF-TEST::FILE . ASDF-TEST::|test-make-build.script|)))
49: (#<bytecompiled-function SI:BYTECODES> NIL)
50: (#<bytecompiled-function SI:BYTECODES> ((SI::OUTPUT-FILE . T) (SI::C-FILE) (SI::H-FILE) (SI::DATA-FILE) (SI::VERBOSE . T) (SI::SYSTEM-P) (EXT:QUIT)))
51: (#<bytecompiled-function SI:BYTECODES> NIL)
52: (NIL NIL)
Above backtrace due to this condition:
not a valid pathname designator NIL
Script failed
Using ecl, test-make-build.script failed
you can retry compilation with:
./test/run-tests.sh ecl test-make-build.script
or more interactively (and maybe with rlwrap or in emacs), start with:
(cd test ; ecl -norc -load sys:cmp )
then copy/paste:
'(#.(load "script-support.lisp") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load "test-make-build.script")))


Testing: test-missing-lisp-file.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-missing-lisp-file.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-missing-lisp-file.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-missing-lisp-file">
;;;
;;; Compiling /boot/home/ecl/asdf/test/fileMissing.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/fileMissing.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
Script succeeded
Using ecl, test-missing-lisp-file.script passed


Testing: test-module-depend.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-module-depend.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-module-depend.script with ecl-16.1.2-e640ef1c-haiku-x86
FILE1.FASL and
 (TEST-FASL "file1") both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas"
FILE2.FASL and
 (TEST-FASL "file2") both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file2.fas"
FILE3.FASL and
 (TEST-FASL "file3") both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file3.fas"
;;;
;;; Compiling /boot/home/ecl/asdf/test/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file1.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file3.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file3.lisp.
;;;
Script succeeded
Using ecl, test-module-depend.script passed


Testing: test-module-excessive-depend.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-module-excessive-depend.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-module-excessive-depend.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-module-excessive-depend">
loading test-module-excessive-depend
  (ASDF/OPERATE:OPERATE 'ASDF/LISP-ACTION:LOAD-OP 'ASDF-TEST::TEST-MODULE-EXCESSIVE-DEPEND) => #<load-op > #<a ASDF/PLAN:SEQUENTIAL-PLAN>
;;;
;;; Compiling /boot/home/ecl/asdf/test/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file1.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
Script succeeded
Using ecl, test-module-excessive-depend.script passed


Testing: test-module-pathnames.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-module-pathnames.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-module-pathnames.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-module-pathnames">
Loading the system
;;;
;;; Compiling /boot/home/ecl/asdf/test/sources/level1/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
compiling level1/file1
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/sources/level1/file1.lisp.
;;;
loading level1/file1
;;;
;;; Compiling /boot/home/ecl/asdf/test/sources/level1/level2/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/sources/level1/level2/file2.lisp.
;;;
Checking pathnames
Script succeeded
Using ecl, test-module-pathnames.script passed


Testing: test-multiple.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-multiple.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-multiple.script with ecl-16.1.2-e640ef1c-haiku-x86
;;;
;;; Compiling /boot/home/ecl/asdf/test/file4.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file4.lisp.
;;;
Script succeeded
Using ecl, test-multiple.script passed


Testing: test-mutual-redefinition.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-mutual-redefinition.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-mutual-redefinition.script with ecl-16.1.2-e640ef1c-haiku-x86
loading test-mutual-redefinition-1
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (TEST-SOURCE "test-mutual-redefinition-1.asd") yields this:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION NIL)

        the other expression (CURRENT-SYSTEM-SOURCE-FILE
                              "test-mutual-redefinition-1") yields that:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION :NEWEST)

;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (TEST-SOURCE "test-mutual-redefinition-1.asd") yields this:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION NIL)

        the other expression (CURRENT-SYSTEM-SOURCE-FILE
                              "test-mutual-redefinition-2") yields that:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION :NEWEST)

loading test-mutual-redefinition-2 in the same cache session
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (TEST-SOURCE "test-mutual-redefinition-1.asd") yields this:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION NIL)

        the other expression (CURRENT-SYSTEM-SOURCE-FILE
                              "test-mutual-redefinition-1") yields that:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION :NEWEST)

;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (TEST-SOURCE "test-mutual-redefinition-1.asd") yields this:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION NIL)

        the other expression (CURRENT-SYSTEM-SOURCE-FILE
                              "test-mutual-redefinition-2") yields that:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-1" :TYPE "asd" :VERSION :NEWEST)

loading test-mutual-redefinition-2 in a different cache session
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (TEST-SOURCE "test-mutual-redefinition-2.asd") yields this:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-2.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-2" :TYPE "asd" :VERSION NIL)

        the other expression (CURRENT-SYSTEM-SOURCE-FILE
                              "test-mutual-redefinition-1") yields that:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-2.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-2" :TYPE "asd" :VERSION :NEWEST)

;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (TEST-SOURCE "test-mutual-redefinition-2.asd") yields this:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-2.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-2" :TYPE "asd" :VERSION NIL)

        the other expression (CURRENT-SYSTEM-SOURCE-FILE
                              "test-mutual-redefinition-2") yields that:
  #P"/boot/home/ecl/asdf/test/test-mutual-redefinition-2.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME
   "test-mutual-redefinition-2" :TYPE "asd" :VERSION :NEWEST)

Script succeeded
Using ecl, test-mutual-redefinition.script passed


Testing: test-nested-components.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-nested-components.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-nested-components.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-nested-components-a">
; Registering #<system "test-nested-components-b">
; Registering #<system "db-agraph-preflight">
; Registering #<system "db-agraph-preflight-2">
(:A
 ((#<prepare-op > . #<system "test-nested-components-a">)
  (#<prepare-op > . #<module "test-nested-components-a" "nested-components">)
  (#<prepare-op >
   . #<cl-source-file "test-nested-components-a" "nested-components" "test-nested-1">)
  (#<compile-op >
   . #<cl-source-file "test-nested-components-a" "nested-components" "test-nested-1">)
  (#<compile-op > . #<module "test-nested-components-a" "nested-components">)
  (#<compile-op > . #<system "test-nested-components-a">))
 ((#<prepare-op > . #<system "test-nested-components-b">)
  (#<prepare-op >
   . #<cl-source-file "test-nested-components-b" "test-nested-1">)
  (#<compile-op >
   . #<cl-source-file "test-nested-components-b" "test-nested-1">)
  (#<compile-op > . #<system "test-nested-components-b">))
 :X
 ((#<prepare-op > . #<system "db-agraph-preflight">)
  (#<prepare-op > . #<module "db-agraph-preflight" "preflight-checks">)
  (#<prepare-op >
   . #<cl-source-file "db-agraph-preflight" "preflight-checks" "preflight">)
  (#<compile-op >
   . #<cl-source-file "db-agraph-preflight" "preflight-checks" "preflight">)
  (#<compile-op > . #<module "db-agraph-preflight" "preflight-checks">)
  (#<compile-op > . #<system "db-agraph-preflight">))
 ((#<prepare-op > . #<system "db-agraph-preflight-2">)
  (#<prepare-op > . #<cl-source-file "db-agraph-preflight-2" "preflight">)
  (#<compile-op > . #<cl-source-file "db-agraph-preflight-2" "preflight">)
  (#<compile-op > . #<system "db-agraph-preflight-2">)))
Script succeeded
Using ecl, test-nested-components.script passed


Testing: test-operation-classes.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-operation-classes.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-operation-classes.script with ecl-16.1.2-e640ef1c-haiku-x86
Checking whether (MAKE-INSTANCE 'MY-UNUPDATED-OPERATION) signals OPERATION-DEFINITION-WARNING
Received signal #<a ASDF/ACTION:OPERATION-DEFINITION-WARNING>
Checking whether (MAKE-INSTANCE 'MY-INCOHERENT-OPERATION) signals OPERATION-DEFINITION-ERROR
Received signal #<a ASDF/ACTION:OPERATION-DEFINITION-ERROR>
;;; Warning: No dependency propagating scheme specified for operation class TRIVIAL-OPERATION.
The class needs to be updated for ASDF 3.1 and specify appropriate propagation mixins.
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
;;; Warning: No dependency propagating scheme specified for operation class TRIVIAL-OPERATION.
The class needs to be updated for ASDF 3.1 and specify appropriate propagation mixins.
;;; Warning: No dependency propagating scheme specified for operation class TRIVIAL-OPERATION.
The class needs to be updated for ASDF 3.1 and specify appropriate propagation mixins.
Script succeeded
Using ecl, test-operation-classes.script passed


Testing: test-package.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-package.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-package.script with ecl-16.1.2-e640ef1c-haiku-x86
; Loading system definition from /boot/home/ecl/asdf/test/test-package.asd
; Registering #<system "test-package">
; Loading system definition from /boot/home/ecl/asdf/test/test-package.asd
Script succeeded
Using ecl, test-package.script passed


Testing: test-preloaded.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-preloaded.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-preloaded.script with ecl-16.1.2-e640ef1c-haiku-x86
Consider a system that does not exist. Loading it fails.
Checking whether (LOAD-SYSTEM :THIS-SYSTEM-DOES-NOT-EXIST) signals error MISSING-COMPONENT
Now let's register it as preloaded. Loading it will work!
Now let's load a simple system. It should create a package.
Destroy the package, clear the system and load it again. The package should be back.
Destroy the package, clear the system, and register it as immutable. Try loading it again.
The package should NOT be back, because it's immutable thus it's NOT going to be loaded.
; Registering #<system "test-asdf/1">
Script succeeded
Using ecl, test-preloaded.script passed


Testing: test-program.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-program.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-program.script with ecl-16.1.2-e640ef1c-haiku-x86
FOO
  (UIOP/LISP-BUILD:CURRENT-LISP-FILE-PATHNAME) => #P"/boot/home/ecl/asdf/test/test-program.script"
; Loading system definition for hello-world-example from /boot/home/ecl/asdf/test/hello-world-example.asd
; Registering #<system "hello-world-example">
Couldn't find lisp-invocation. Probably your ASDF ext/ directory needs submodule update.
Using ecl, test-program.script failed
you can retry compilation with:
./test/run-tests.sh ecl test-program.script
or more interactively (and maybe with rlwrap or in emacs), start with:
(cd test ; ecl -norc -load sys:cmp )
then copy/paste:
'(#.(load "script-support.lisp") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load "test-program.script")))


Testing: test-redundant-recompile.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-redundant-recompile.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-redundant-recompile.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-redundant-recompile">
test-redundant-recompile 1: #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas" 3682216491
test-redundant-recompile 2: #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file2.fas" 3682216492
Script succeeded
Using ecl, test-redundant-recompile.script passed


Testing: test-retry-loading-component-1.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-retry-loading-component-1.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-retry-loading-component-1.script with ecl-16.1.2-e640ef1c-haiku-x86
Caught error Component "try-reloading-dependency" not found, required by
             #<system "try-reloading-1">
trlc1 5
;;;
;;; Compiling /boot/home/ecl/asdf/test/file3.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file3.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file1.lisp.
;;;
Script succeeded
Using ecl, test-retry-loading-component-1.script passed


Testing: test-run-program.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-run-program.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-run-program.script with ecl-16.1.2-e640ef1c-haiku-x86
Testing echo ok 1 via run-program as a list
TEST ABORTED: ("echo" "ok" "1") fell through ETYPECASE expression.
Wanted one of ().
Backtrace:
0: (#:G2351 NIL)
1: (UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX #(1910325280 33719064 1910325184))
2: (UIOP/IMAGE:PRINT-BACKTRACE NIL)
3: (UIOP/IMAGE:PRINT-CONDITION-BACKTRACE #(1 33721064 1910325684))
4: (#<bytecompiled-function ASDF-TEST:ACALL> ((ASDF-TEST::ARGS #<a SI::CASE-FAILURE> :COUNT 69 :STREAM #<output stream "stdout">) (ASDF-TEST::NAME . :PRINT-CONDITION-BACKTRACE)))
5: (#<bytecompiled-function 1a547348> ((142 . 0) (#:G238) (141 . #:G237) (ASDF-TEST::C . #<a SI::CASE-FAILURE>) (:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1a547258>>)))
6: (UIOP/RUN-PROGRAM::%NORMALIZE-COMMAND #(1 33721720 1910327328))
7: (UIOP/RUN-PROGRAM::%RUN-PROGRAM #(1 33721888 1910327748))
8: (#:G2777 #(1 33722704 1910328468 1910328472))
9: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
10: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 33722000 1910328680 1910328684 1910328696))
11: (#:G2776 NIL)
12: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
13: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 33722000 1910329384 1910329388 1910329400))
14: (#:G2775 NIL)
15: (UIOP/RUN-PROGRAM::HARD-CASE NIL)
16: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 33722000 1910330104 1910330108 1910330120))
17: (UIOP/RUN-PROGRAM::%USE-RUN-PROGRAM #(1 33722736 1910330556 1910330552 1910330548))
18: (UIOP/RUN-PROGRAM:RUN-PROGRAM #(1 33722960 1910331284))
19: (#<bytecompiled-function SI:BYTECODES> NIL)
20: (#<bytecompiled-function 1a547258> ((ASDF-TEST::NAME . "test-run-program.script") (ASDF-TEST::FILE . ASDF-TEST::|test-run-program.script|)))
21: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 33725208 1910332540))
22: (#<bytecompiled-function ASDF-TEST::CALL-WITH-TEST> ((:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1a547258>>)))
23: (#<bytecompiled-function ASDF-TEST:RUN-TEST-SCRIPT> ((ASDF-TEST::FILE . ASDF-TEST::|test-run-program.script|)))
24: (#<bytecompiled-function SI:BYTECODES> NIL)
25: (#<bytecompiled-function SI:BYTECODES> ((SI::OUTPUT-FILE . T) (SI::C-FILE) (SI::H-FILE) (SI::DATA-FILE) (SI::VERBOSE . T) (SI::SYSTEM-P) (EXT:QUIT)))
26: (#<bytecompiled-function SI:BYTECODES> NIL)
27: (NIL NIL)
Above backtrace due to this condition:
("echo" "ok" "1") fell through ETYPECASE expression.
Wanted one of ().
Script failed
Using ecl, test-run-program.script failed
you can retry compilation with:
./test/run-tests.sh ecl test-run-program.script
or more interactively (and maybe with rlwrap or in emacs), start with:
(cd test ; ecl -norc -load sys:cmp )
then copy/paste:
'(#.(load "script-support.lisp") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load "test-run-program.script")))


Testing: test-samedir-modules.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-samedir-modules.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-samedir-modules.script with ecl-16.1.2-e640ef1c-haiku-x86
loading test-samedir-modules
;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
test that it compiled
  ASDF-TEST::FILE1 => #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas"
  ASDF-TEST::FILE1-DATE => 3682216503
and loaded
Script succeeded
Using ecl, test-samedir-modules.script passed


Testing: test-source-file-type.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-source-file-type.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-source-file-type.script with ecl-16.1.2-e640ef1c-haiku-x86
; Loading system definition for test-source-file-type-1 from /boot/home/ecl/asdf/test/test-source-file-type-1.asd
; Registering #<system "test-source-file-type-1">
Hello, world!
;;;
;;; Compiling /boot/home/ecl/asdf/test/test-tmp.cl.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
compiling test-tmp.cl
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/test-tmp.cl.
;;;
loading test-tmp.cl
; Loading system definition for test-source-file-type-2 from /boot/home/ecl/asdf/test/test-source-file-type-2.asd
; Registering #<system "test-source-file-type-2">
loading test-tmp.cl
Script succeeded
Using ecl, test-source-file-type.script passed


Testing: test-stamp-propagation.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-stamp-propagation.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-stamp-propagation.script with ecl-16.1.2-e640ef1c-haiku-x86
FOO
XXX :EXECUTE :TSP
; Registering #<system "test-stamp-propagation">


Testing stamp propagation by defsystem :ASDF
loading system
ASDF-CACHE before #<hash-table 1a8890f0>
XXX :COMPILING :SYSTEM
XXX :LOADING :SYSTEM
;;;
;;; Compiling /boot/home/ecl/asdf/test/stamp-propagation/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
XXX :COMPILE-TOPLEVEL :FILE1
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/stamp-propagation/file1.lisp.
;;;
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/stamp-propagation/file1.fas"
XXX :LOAD-TOPLEVEL :FILE1
;;;
;;; Compiling /boot/home/ecl/asdf/test/stamp-propagation/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
XXX :COMPILE-TOPLEVEL :FILE2
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/stamp-propagation/file2.lisp.
;;;
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/stamp-propagation/file2.fas"
XXX :LOAD-TOPLEVEL :FILE2
ASDF-CACHE after #<hash-table 1a8890f0>
EVAL-NOTES ((:COMPILING :SYSTEM) (:LOADING :SYSTEM) (:COMPILE-TOPLEVEL :FILE1)
            (:LOAD-TOPLEVEL :FILE1) (:COMPILE-TOPLEVEL :FILE2)
            (:LOAD-TOPLEVEL :FILE2))
; Registering #<system "test-stamp-propagation">
marking all files old but first source file, and reloading
defsystem should recompile & reload everything
ASDF-CACHE before #<hash-table 1a8890f0>
XXX :COMPILING :SYSTEM
XXX :LOADING :SYSTEM
;;;
;;; Compiling /boot/home/ecl/asdf/test/stamp-propagation/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
XXX :COMPILE-TOPLEVEL :FILE1
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/stamp-propagation/file1.lisp.
;;;
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/stamp-propagation/file1.fas"
XXX :LOAD-TOPLEVEL :FILE1
;;;
;;; Compiling /boot/home/ecl/asdf/test/stamp-propagation/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
XXX :COMPILE-TOPLEVEL :FILE2
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/stamp-propagation/file2.lisp.
;;;
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/stamp-propagation/file2.fas"
XXX :LOAD-TOPLEVEL :FILE2
ASDF-CACHE after #<hash-table 1a8890f0>
EVAL-NOTES ((:COMPILING :SYSTEM) (:LOADING :SYSTEM) (:COMPILE-TOPLEVEL :FILE1)
            (:LOAD-TOPLEVEL :FILE1) (:COMPILE-TOPLEVEL :FILE2)
            (:LOAD-TOPLEVEL :FILE2))
; Registering #<system "test-stamp-propagation">
marking the old fasl new, the second one up to date
defsystem should reload it, recompile & reload the other
ASDF-CACHE before #<hash-table 1a8890f0>
XXX :COMPILING :SYSTEM
XXX :LOADING :SYSTEM
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/stamp-propagation/file1.fas"
XXX :LOAD-TOPLEVEL :FILE1
;;;
;;; Compiling /boot/home/ecl/asdf/test/stamp-propagation/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
XXX :COMPILE-TOPLEVEL :FILE2
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/stamp-propagation/file2.lisp.
;;;
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/stamp-propagation/file2.fas"
XXX :LOAD-TOPLEVEL :FILE2
ASDF-CACHE after #<hash-table 1a8890f0>
EVAL-NOTES ((:COMPILING :SYSTEM) (:LOADING :SYSTEM) (:LOAD-TOPLEVEL :FILE1)
            (:COMPILE-TOPLEVEL :FILE2) (:LOAD-TOPLEVEL :FILE2))
cleaning up
Script succeeded
Using ecl, test-stamp-propagation.script passed


Testing: test-static-and-serial.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-static-and-serial.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-static-and-serial.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "static-and-serial">
FILE1.LISP and
 (TEST-SOURCE "file1.lisp") both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/file1.lisp"
FILE2.LISP and
 (TEST-SOURCE "file2.lisp") both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/file2.lisp"
RUN-TESTS.SH and
 (TEST-SOURCE "run-tests.sh") both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/run-tests.sh"
FILE1.FASL and
 (TEST-FASL "file1") both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas"
file: #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas"
date: 3682216503
; Registering #<system "static-and-serial">
load again
  (ASDF/OPERATE:OOS 'ASDF/LISP-ACTION:LOAD-OP 'ASDF-TEST::STATIC-AND-SERIAL) => #<load-op > #<a ASDF/PLAN:SEQUENTIAL-PLAN>
Script succeeded
Using ecl, test-static-and-serial.script passed


Testing: test-symlink-loop.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-symlink-loop.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-symlink-loop.script with ecl-16.1.2-e640ef1c-haiku-x86
TEST ABORTED: No /dev/null on your OS
Backtrace:
0: (#:G2351 NIL)
1: (UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX #(1923567712 24556312 1923567616))
2: (UIOP/IMAGE:PRINT-BACKTRACE NIL)
3: (UIOP/IMAGE:PRINT-CONDITION-BACKTRACE #(1 24558312 1923568116))
4: (#<bytecompiled-function ASDF-TEST:ACALL> ((ASDF-TEST::ARGS #<a SIMPLE-ERROR> :COUNT 69 :STREAM #<output stream "stdout">) (ASDF-TEST::NAME . :PRINT-CONDITION-BACKTRACE)))
5: (#<bytecompiled-function 1980e348> ((147 . 0) (#:G238) (146 . #:G237) (ASDF-TEST::C . #<a SIMPLE-ERROR>) (:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1980e258>>)))
6: (UIOP/STREAM:NULL-DEVICE-PATHNAME NIL)
7: (UIOP/RUN-PROGRAM::REDIRECT #(1 24560024 1923569676 1923569672))
8: (UIOP/RUN-PROGRAM::%REDIRECTED-SYSTEM-COMMAND #(1 24560064 1923570016 1923570020 1923570024 1923570028 1923570032))
9: (UIOP/RUN-PROGRAM::%SYSTEM #(1 24560128 1923570260))
10: (#:G2824 #(1 24560136 1923570724 1923570728))
11: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
12: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 24559248 1923570936 1923570940 1923570952))
13: (#:G2822 #(1 24560152 1923571384))
14: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
15: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 24559248 1923571592 1923571596 1923571608))
16: (#:G2820 #(1 24560168 1923572040))
17: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
18: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 24559248 1923572248 1923572252 1923572264))
19: (UIOP/RUN-PROGRAM::%USE-SYSTEM NIL)
20: (UIOP/RUN-PROGRAM:RUN-PROGRAM #(1 24560208 1923573300))
21: (#<bytecompiled-function SI:BYTECODES> ((ASDF-TEST::SCRATCH-DIR . "/boot/home/ecl/asdf/test/looping-scratch/")))
22: (#<bytecompiled-function 1980e258> ((ASDF-TEST::NAME . "test-symlink-loop.script") (ASDF-TEST::FILE . ASDF-TEST::|test-symlink-loop.script|)))
23: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 24562456 1923574556))
24: (#<bytecompiled-function ASDF-TEST::CALL-WITH-TEST> ((:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1980e258>>)))
25: (#<bytecompiled-function ASDF-TEST:RUN-TEST-SCRIPT> ((ASDF-TEST::FILE . ASDF-TEST::|test-symlink-loop.script|)))
26: (#<bytecompiled-function SI:BYTECODES> NIL)
27: (#<bytecompiled-function SI:BYTECODES> ((SI::OUTPUT-FILE . T) (SI::C-FILE) (SI::H-FILE) (SI::DATA-FILE) (SI::VERBOSE . T) (SI::SYSTEM-P) (EXT:QUIT)))
28: (#<bytecompiled-function SI:BYTECODES> NIL)
29: (NIL NIL)
Above backtrace due to this condition:
No /dev/null on your OS
Script failed
Cleaning up
TEST ABORTED: No /dev/null on your OS
Backtrace:
0: (#:G2351 NIL)
1: (UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX #(1923567712 24556312 1923567616))
2: (UIOP/IMAGE:PRINT-BACKTRACE NIL)
3: (UIOP/IMAGE:PRINT-CONDITION-BACKTRACE #(1 24558312 1923568116))
4: (#<bytecompiled-function ASDF-TEST:ACALL> ((ASDF-TEST::ARGS #<a SIMPLE-ERROR> :COUNT 69 :STREAM #<output stream "stdout">) (ASDF-TEST::NAME . :PRINT-CONDITION-BACKTRACE)))
5: (#<bytecompiled-function 1980e348> ((1024 . 0) (#:G238) (1023 . #:G237) (ASDF-TEST::C . #<a SIMPLE-ERROR>) (:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1980e258>>)))
6: (UIOP/STREAM:NULL-DEVICE-PATHNAME NIL)
7: (UIOP/RUN-PROGRAM::REDIRECT #(1 24560024 1923569676 1923569672))
8: (UIOP/RUN-PROGRAM::%REDIRECTED-SYSTEM-COMMAND #(1 24560064 1923570016 1923570020 1923570024 1923570028 1923570032))
9: (UIOP/RUN-PROGRAM::%SYSTEM #(1 24560128 1923570260))
10: (#:G2824 #(1 24560136 1923570724 1923570728))
11: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
12: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 24559248 1923570936 1923570940 1923570952))
13: (#:G2822 #(1 24560152 1923571384))
14: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
15: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 24559248 1923571592 1923571596 1923571608))
16: (#:G2820 #(1 24560168 1923572040))
17: (UIOP/RUN-PROGRAM::EASY-CASE NIL)
18: (UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO #(1 24559248 1923572248 1923572252 1923572264))
19: (UIOP/RUN-PROGRAM::%USE-SYSTEM NIL)
20: (UIOP/RUN-PROGRAM:RUN-PROGRAM #(1 24560208 1923573300))
21: (#<bytecompiled-function SI:BYTECODES> ((ASDF-TEST::SCRATCH-DIR . "/boot/home/ecl/asdf/test/looping-scratch/")))
22: (#<bytecompiled-function 1980e258> ((ASDF-TEST::NAME . "test-symlink-loop.script") (ASDF-TEST::FILE . ASDF-TEST::|test-symlink-loop.script|)))
23: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 24562456 1923574556))
24: (#<bytecompiled-function ASDF-TEST::CALL-WITH-TEST> ((:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 1980e258>>)))
25: (#<bytecompiled-function ASDF-TEST:RUN-TEST-SCRIPT> ((ASDF-TEST::FILE . ASDF-TEST::|test-symlink-loop.script|)))
26: (#<bytecompiled-function SI:BYTECODES> NIL)
27: (#<bytecompiled-function SI:BYTECODES> ((SI::OUTPUT-FILE . T) (SI::C-FILE) (SI::H-FILE) (SI::DATA-FILE) (SI::VERBOSE . T) (SI::SYSTEM-P) (EXT:QUIT)))
28: (#<bytecompiled-function SI:BYTECODES> NIL)
29: (NIL NIL)
Above backtrace due to this condition:
No /dev/null on your OS
Script failed
Using ecl, test-symlink-loop.script failed
you can retry compilation with:
./test/run-tests.sh ecl test-symlink-loop.script
or more interactively (and maybe with rlwrap or in emacs), start with:
(cd test ; ecl -norc -load sys:cmp )
then copy/paste:
'(#.(load "script-support.lisp") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load "test-symlink-loop.script")))


Testing: test-sysdef-asdf.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-sysdef-asdf.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-sysdef-asdf.script with ecl-16.1.2-e640ef1c-haiku-x86

Using ASDF 3.1.7.9
Try load ASDF with an empty configuration
Bogus attempt at loading an old ASDF: should issue a warning and ignore
;;; Warning: You are using ASDF version 3.1.7.9 (probably from (require "asdf")
             or loaded by quicklisp) and have an older version of ASDF 1.0
             registered at #P"/boot/home/ecl/asdf/test/always-error.lisp".
             Having an ASDF installed and registered is the normal way of
             configuring ASDF to upgrade itself, and having an old version
             registered is a configuration error. ASDF will ignore this
             configured system rather than downgrade itself. In the future, you
             may want to either: (a) upgrade this configured ASDF to a newer
             version, (b) install a newer ASDF and register it in front of the
             former in your configuration, or (c) uninstall or unregister this
             and any other old version of ASDF from your configuration. Note
             that the older ASDF might be registered implicitly through
             configuration inherited from your system installation, in which
             case you might have to specify :ignore-inherited-configuration in
             your in your ~/.config/common-lisp/source-registry.conf or other
             source-registry configuration file, environment variable or lisp
             parameter. Indeed, a likely offender is an obsolete version of the
             cl-asdf debian or ubuntu package, that you might want to upgrade
             (if a recent enough version is available) or else remove
             altogether (since most implementations ship with a recent asdf);
             if you lack the system administration rights to upgrade or remove
             this package, then you might indeed want to either install and
             register a more recent version, or use
             :ignore-inherited-configuration to avoid registering the old one.
             Please consult ASDF documentation and/or experts.

2nd bogus attempt at loading same old ASDF: should ignore without a warning
Load ASDF with proper configuration: should find asdf.asd from the source above
;;;
;;; Compiling /boot/home/ecl/asdf/build/asdf.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/build/asdf.lisp.
;;;
;;; Warning: Lisp compilation had style-warnings while
             compiling #<cl-source-file "asdf" "build" "asdf">
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (SUBPATHNAME *ASDF-DIRECTORY* "asdf.asd") yields this:
  #P"/boot/home/ecl/asdf/asdf.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "boot" "home" "ecl" "asdf")
   :NAME "asdf" :TYPE "asd" :VERSION NIL)

        the other expression (SYSTEM-SOURCE-FILE (FIND-SYSTEM :ASDF)) yields that:
  #P"/boot/home/ecl/asdf/asdf.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "boot" "home" "ecl" "asdf")
   :NAME "asdf" :TYPE "asd" :VERSION :NEWEST)

Checking that the bootstrap script and asdf.asd are in synch
Testing that the Makefile and ASDF agree on the order of UIOP files
(NTH 0 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 0 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/package.lisp"
(NTH 1 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 1 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/common-lisp.lisp"
(NTH 2 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 2 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/utility.lisp"
(NTH 3 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 3 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/os.lisp"
(NTH 4 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 4 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/pathname.lisp"
(NTH 5 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 5 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/filesystem.lisp"
(NTH 6 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 6 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/stream.lisp"
(NTH 7 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 7 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/image.lisp"
(NTH 8 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 8 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/run-program.lisp"
(NTH 9 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 9 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/lisp-build.lisp"
(NTH 10 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 10 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/configuration.lisp"
(NTH 11 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 11 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/backward-driver.lisp"
(NTH 12 (SYSTEM-LISP-FILES :UIOP)) and
 (NTH 12 (BOOTSTRAP-LISP-FILES "driver_lisp")) both evaluate to same path:
  #P"uiop/driver.lisp"
Testing that the Makefile and ASDF agree on the order of ASDF/DEFSYSTEM files
(NTH 0 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 0 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"upgrade.lisp"
(NTH 1 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 1 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"component.lisp"
(NTH 2 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 2 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"system.lisp"
(NTH 3 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 3 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"cache.lisp"
(NTH 4 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 4 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"find-system.lisp"
(NTH 5 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 5 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"find-component.lisp"
(NTH 6 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 6 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"operation.lisp"
(NTH 7 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 7 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"action.lisp"
(NTH 8 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 8 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"lisp-action.lisp"
(NTH 9 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 9 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"plan.lisp"
(NTH 10 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 10 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"operate.lisp"
(NTH 11 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 11 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"output-translations.lisp"
(NTH 12 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 12 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"source-registry.lisp"
(NTH 13 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 13 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"parse-defsystem.lisp"
(NTH 14 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 14 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"bundle.lisp"
(NTH 15 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 15 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"concatenate-source.lisp"
(NTH 16 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 16 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"package-inferred-system.lisp"
(NTH 17 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 17 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"backward-internals.lisp"
(NTH 18 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 18 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"backward-interface.lisp"
(NTH 19 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 19 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"interface.lisp"
(NTH 20 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 20 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"user.lisp"
(NTH 21 (SYSTEM-LISP-FILES :ASDF/DEFSYSTEM)) and
 (NTH 21 (BOOTSTRAP-LISP-FILES "defsystem_lisp")) both evaluate to same path:
  #P"footer.lisp"
Script succeeded
Using ecl, test-sysdef-asdf.script passed


Testing: test-system-pathnames.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-system-pathnames.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-system-pathnames.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-system-pathnames">
loading test-system-pathnames
loading level1/file1
checking that test-system-pathnames loaded properly
Script succeeded
Using ecl, test-system-pathnames.script passed


Testing: test-touch-system-1.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-touch-system-1.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-touch-system-1.script with ecl-16.1.2-e640ef1c-haiku-x86
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TEST1.ASD yields this:
  #P"/boot/home/ecl/asdf/test/test1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test1" :TYPE "asd"
   :VERSION :NEWEST)

        the other expression (TEST-SOURCE "test1.asd") yields that:
  #P"/boot/home/ecl/asdf/test/test1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test1" :TYPE "asd"
   :VERSION NIL)

BLAH
  ASDF-TEST::DATE1 => 3682186213
  ASDF-TEST::DATE2 => 3682185613
  ASDF-TEST::DATE3 => 3682185913
  ASDF-TEST::DATE4 => 3682216505
  ASDF-TEST::DATE5 => 3682185613
; Loading system definition for test1 from /boot/home/ecl/asdf/test/test1.asd
; Registering #<system "test1">
Script succeeded
Using ecl, test-touch-system-1.script passed


Testing: test-touch-system-2.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-touch-system-2.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-touch-system-2.script with ecl-16.1.2-e640ef1c-haiku-x86
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TEST1.ASD yields this:
  #P"/boot/home/ecl/asdf/test/test1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test1" :TYPE "asd"
   :VERSION :NEWEST)

        the other expression (TEST-SOURCE "test1.asd") yields that:
  #P"/boot/home/ecl/asdf/test/test1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test1" :TYPE "asd"
   :VERSION NIL)

; Registering #<system "test1">
; Registering #<system "test1">
Script succeeded
Using ecl, test-touch-system-2.script passed


Testing: test-try-recompiling-1.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-try-recompiling-1.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-try-recompiling-1.script with ecl-16.1.2-e640ef1c-haiku-x86
;;;
;;; Compiling /boot/home/ecl/asdf/test/try-recompiling-1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/try-recompiling-1.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/try-recompiling-1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/try-recompiling-1.lisp.
;;;
Script succeeded
Using ecl, test-try-recompiling-1.script passed


Testing: test-try-refinding.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-try-refinding.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-try-refinding.script with ecl-16.1.2-e640ef1c-haiku-x86
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
Clearing the caches and finding.
Correctly failed to find system.
Caught MISSING-COMPONENT condition.
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/force1">
Refinding test successful.
Now trying LOAD-SYSTEM with refinding.
; Registering #<system "test-missing-dependency">
Catching MISSING-DEPENDENCY condition:
  ASDF-TEST::TRIED-ONCE => NIL
Trying to reset the central registry and retry.
Before invoking restart, CENTRAL-REGISTRY is:
  ASDF/FIND-SYSTEM:*CENTRAL-REGISTRY* => (#P"/boot/home/ecl/asdf/test/")
Script succeeded
Using ecl, test-try-refinding.script passed


Testing: test-undeferred-warnings.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-undeferred-warnings.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-undeferred-warnings.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "undefined-variables">
; Loading system definition for undefined-variables-throttled from /boot/home/ecl/asdf/test/undefined-variables-throttled.asd
; Registering #<system "undefined-variables-throttled">
Check for proper errors on warning.
Checking whether (LET ((*COMPILE-FILE-WARNINGS-BEHAVIOUR* :ERROR))
                   (LOAD-SYSTEM :UNDEFINED-VARIABLES :FORCE T)) signals error COMPILE-FILE-ERROR
;;;
;;; Compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable A was undefined. Compiler assumes it is a global.
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable B was undefined. Compiler assumes it is a global.
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;;
Check for proper warnings on warning.
Checking whether (LET ((*COMPILE-FILE-WARNINGS-BEHAVIOUR* :WARNING))
                   (LOAD-SYSTEM :UNDEFINED-VARIABLES :FORCE T)) signals error COMPILE-FILE-ERROR
;;;
;;; Compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable A was undefined. Compiler assumes it is a global.
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable B was undefined. Compiler assumes it is a global.
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;;
check for undefined variable warnings to not fail a build.
;;;
;;; Compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable A was undefined. Compiler assumes it is a global.
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable B was undefined. Compiler assumes it is a global.
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;;
check for undefined variable-warnings throttled by PERFORM around method not failing a build.
;;;
;;; Compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable A was undefined. Compiler assumes it is a global.
;;; Style warning:
;;;   in file fun-with-undefined-locals.lisp, position 117
;;;   at (DEFUN FOO ...)
;;;   ! Variable B was undefined. Compiler assumes it is a global.
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/fun-with-undefined-locals.lisp.
;;;
Script succeeded
Using ecl, test-undeferred-warnings.script passed


Testing: test-urls-1.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-urls-1.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-urls-1.script with ecl-16.1.2-e640ef1c-haiku-x86
Script succeeded
Using ecl, test-urls-1.script passed


Testing: test-urls-2.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-urls-2.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-urls-2.script with ecl-16.1.2-e640ef1c-haiku-x86
Script succeeded
Using ecl, test-urls-2.script passed


Testing: test-utilities.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-utilities.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-utilities.script with ecl-16.1.2-e640ef1c-haiku-x86
1
  (UIOP/OS:CHDIR ASDF-TEST::ASDF-DIRECTORY) => #P"/boot/home/ecl/asdf/test/"
  (SETF *DEFAULT-PATHNAME-DEFAULTS* ASDF-TEST::ASDF-DIRECTORY) => #P"/boot/home/ecl/asdf/"
DIR and
 (GET-PATHNAME-DEFAULTS) both evaluate to same path:
  #P"/boot/home/ecl/asdf/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME* #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/"
TRUE and
 (TRUENAME FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/asdf.asd"
TRUE and
 (TRUENAME* FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/asdf.asd"
TRUE and
 (PROBE-FILE* FILE :TRUENAME T) both evaluate to same path:
  #P"/boot/home/ecl/asdf/asdf.asd"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TRUE yields this:
  #P"/boot/home/ecl/asdf/asdf.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "boot" "home" "ecl" "asdf")
   :NAME "asdf" :TYPE "asd" :VERSION :NEWEST)

        the other expression (ENSURE-ABSOLUTE-PATHNAME (PROBE-FILE* FILE)
                                                       'GET-PATHNAME-DEFAULTS) yields that:
  #P"/boot/home/ecl/asdf/asdf.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "boot" "home" "ecl" "asdf")
   :NAME "asdf" :TYPE "asd" :VERSION NIL)

TRUE and
 (TRUENAME FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (TRUENAME* FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (PROBE-FILE* FILE :TRUENAME T) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TRUE yields this:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION :NEWEST)

        the other expression (ENSURE-ABSOLUTE-PATHNAME (PROBE-FILE* FILE)
                                                       'GET-PATHNAME-DEFAULTS) yields that:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION NIL)

TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
2
  (UIOP/OS:CHDIR ASDF-TEST::TEST-DIRECTORY) => #P"/boot/home/ecl/asdf/"
  (SETF *DEFAULT-PATHNAME-DEFAULTS* ASDF-TEST::TEST-DIRECTORY) => #P"/boot/home/ecl/asdf/test/"
DIR and
 (GET-PATHNAME-DEFAULTS) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME* #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
TRUE and
 (TRUENAME FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (TRUENAME* FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (PROBE-FILE* FILE :TRUENAME T) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TRUE yields this:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION :NEWEST)

        the other expression (ENSURE-ABSOLUTE-PATHNAME (PROBE-FILE* FILE)
                                                       'GET-PATHNAME-DEFAULTS) yields that:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION NIL)

TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
3
  (UIOP/OS:CHDIR ASDF-TEST::ASDF-DIRECTORY) => #P"/boot/home/ecl/asdf/test/"
  (SETF *DEFAULT-PATHNAME-DEFAULTS* ASDF-TEST::TEST-DIRECTORY) => #P"/boot/home/ecl/asdf/test/"
DIR and
 (GET-PATHNAME-DEFAULTS) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME* #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
TRUE and
 (TRUENAME FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (TRUENAME* FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (PROBE-FILE* FILE :TRUENAME T) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TRUE yields this:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION :NEWEST)

        the other expression (ENSURE-ABSOLUTE-PATHNAME (PROBE-FILE* FILE)
                                                       'GET-PATHNAME-DEFAULTS) yields that:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION NIL)

TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
4
  (SETF *DEFAULT-PATHNAME-DEFAULTS* (UIOP/PATHNAME:NIL-PATHNAME)) => #P""
  (UIOP/OS:CHDIR ASDF-TEST::ASDF-DIRECTORY) => #P"/boot/home/ecl/asdf/"
DIR and
 (GET-PATHNAME-DEFAULTS) both evaluate to same path:
  #P"/boot/home/ecl/asdf/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME* #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/"
TRUE and
 (TRUENAME FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/asdf.asd"
TRUE and
 (TRUENAME* FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/asdf.asd"
TRUE and
 (PROBE-FILE* FILE :TRUENAME T) both evaluate to same path:
  #P"/boot/home/ecl/asdf/asdf.asd"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TRUE yields this:
  #P"/boot/home/ecl/asdf/asdf.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "boot" "home" "ecl" "asdf")
   :NAME "asdf" :TYPE "asd" :VERSION :NEWEST)

        the other expression (ENSURE-ABSOLUTE-PATHNAME (PROBE-FILE* FILE)
                                                       'GET-PATHNAME-DEFAULTS) yields that:
  #P"/boot/home/ecl/asdf/asdf.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY (:ABSOLUTE "boot" "home" "ecl" "asdf")
   :NAME "asdf" :TYPE "asd" :VERSION NIL)

TRUE and
 (TRUENAME FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (TRUENAME* FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (PROBE-FILE* FILE :TRUENAME T) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TRUE yields this:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION :NEWEST)

        the other expression (ENSURE-ABSOLUTE-PATHNAME (PROBE-FILE* FILE)
                                                       'GET-PATHNAME-DEFAULTS) yields that:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION NIL)

TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/tools/"
5
  *DEFAULT-PATHNAME-DEFAULTS* => #P"/boot/home/ecl/asdf/"
  (UIOP/OS:CHDIR ASDF-TEST::TEST-DIRECTORY) => #P"/boot/home/ecl/asdf/"
DIR and
 (GET-PATHNAME-DEFAULTS) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
DIR and
 (SIMPLIFY-PATHNAME-DIRECTORY (TRUENAME* #P"")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
TRUE and
 (TRUENAME FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (TRUENAME* FILE) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
TRUE and
 (PROBE-FILE* FILE :TRUENAME T) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TRUE yields this:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION :NEWEST)

        the other expression (ENSURE-ABSOLUTE-PATHNAME (PROBE-FILE* FILE)
                                                       'GET-PATHNAME-DEFAULTS) yields that:
  #P"/boot/home/ecl/asdf/test/test-utilities.script"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test-utilities" :TYPE
   "script" :VERSION NIL)

TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (TRUENAME (ENSURE-DIRECTORY-PATHNAME FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (NEST (TRUENAME* FILE)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (LET ((PATH (PROBE-FILE* FILE :TRUENAME T)))
   PATH) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
TRUE and
 (IF-LET (X (PROBE-FILE* FILE))
         (ENSURE-ABSOLUTE-PATHNAME (ENSURE-DIRECTORY-PATHNAME X)
                                   'GET-PATHNAME-DEFAULTS)) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/stamp-propagation/"
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
;;; Warning: Requested version "666" but #<package-inferred-system "test-asdf"> has no version
First pathname test.
(NTH 0 (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("foo" "bar")))) and
 (NTH 0 '(#P"foo" #P"bar")) both evaluate to same path:
  #P"foo"
(NTH 1 (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("foo" "bar")))) and
 (NTH 1 '(#P"foo" #P"bar")) both evaluate to same path:
  #P"bar"
Second pathname test.
(NTH 0
     (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("foo" "bar"))
                                    :ENSURE-DIRECTORY
                                    T)) and
 (NTH 0 '(#P"foo/" #P"bar/")) both evaluate to same path:
  #P"foo/"
(NTH 1
     (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("foo" "bar"))
                                    :ENSURE-DIRECTORY
                                    T)) and
 (NTH 1 '(#P"foo/" #P"bar/")) both evaluate to same path:
  #P"bar/"
Third pathname test.
(NTH 0
     (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("/foo" "/bar"))
                                    :WANT-ABSOLUTE
                                    T)) and
 (NTH 0 '(#P"/foo" #P"/bar")) both evaluate to same path:
  #P"/foo"
(NTH 1
     (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("/foo" "/bar"))
                                    :WANT-ABSOLUTE
                                    T)) and
 (NTH 1 '(#P"/foo" #P"/bar")) both evaluate to same path:
  #P"/bar"
Fourth pathname test.
(NTH 0
     (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("/foo" "/bar"))
                                    :WANT-ABSOLUTE
                                    T
                                    :ENSURE-DIRECTORY
                                    T)) and
 (NTH 0 '(#P"/foo/" #P"/bar/")) both evaluate to same path:
  #P"/foo/"
(NTH 1
     (SPLIT-NATIVE-PATHNAMES-STRING (JOIN-NAMESTRINGS '("/foo" "/bar"))
                                    :WANT-ABSOLUTE
                                    T
                                    :ENSURE-DIRECTORY
                                    T)) and
 (NTH 1 '(#P"/foo/" #P"/bar/")) both evaluate to same path:
  #P"/bar/"
Fifth pathname test.
; Loading system definition for uiop from /boot/home/ecl/asdf/uiop/uiop.asd
; Registering #<system "uiop">
check to make sure DIRECTORY-FILES doesn't list subdirectories
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (NTH 0 DIRECTORY-A) yields this:
  #P"/boot/home/ecl/asdf/build/deleteme/a/1.x"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "build" "deleteme" "a") :NAME "1"
   :TYPE "x" :VERSION :NEWEST)

        the other expression (NTH 0
                                  (LIST
                                   (SUBPATHNAME *BUILD-DIRECTORY*
                                                "deleteme/a/1.x"))) yields that:
  #P"/boot/home/ecl/asdf/build/deleteme/a/1.x"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "build" "deleteme" "a") :NAME "1"
   :TYPE "x" :VERSION NIL)

;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (NTH 0 DIRECTORY-B) yields this:
  #P"/boot/home/ecl/asdf/build/deleteme/a/b/2"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "build" "deleteme" "a" "b") :NAME "2"
   :TYPE NIL :VERSION :NEWEST)

        the other expression (NTH 0
                                  (LIST
                                   (SUBPATHNAME *BUILD-DIRECTORY*
                                                "deleteme/a/b/2"))) yields that:
  #P"/boot/home/ecl/asdf/build/deleteme/a/b/2"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "build" "deleteme" "a" "b") :NAME "2"
   :TYPE NIL :VERSION NIL)

check to make sure SUBDIRECTORIES does list subdirectories
(NTH 0 DIRECTORY-A) and
 (NTH 0 (LIST (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/"))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/deleteme/a/b/"
(NTH 0
     (SORT DIRECTORY-B
           #'STRING<
           :KEY
           #'(LAMBDA (X) (CAR (LAST (PATHNAME-DIRECTORY X)))))) and
 (NTH 0
      (LIST (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/c/")
            (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/d/")
            (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/e/"))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/deleteme/a/b/c/"
(NTH 1
     (SORT DIRECTORY-B
           #'STRING<
           :KEY
           #'(LAMBDA (X) (CAR (LAST (PATHNAME-DIRECTORY X)))))) and
 (NTH 1
      (LIST (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/c/")
            (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/d/")
            (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/e/"))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/deleteme/a/b/d/"
(NTH 2
     (SORT DIRECTORY-B
           #'STRING<
           :KEY
           #'(LAMBDA (X) (CAR (LAST (PATHNAME-DIRECTORY X)))))) and
 (NTH 2
      (LIST (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/c/")
            (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/d/")
            (SUBPATHNAME *BUILD-DIRECTORY* "deleteme/a/b/e/"))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/deleteme/a/b/e/"
testing with-temporary-file
ENSURE-GETHASH
Checking whether (ENSURE-GETHASH 2 H '(ERROR PARSE-ERROR)) signals PARSE-ERROR
Received signal #<a PARSE-ERROR>
OPTIMIZATION-SETTINGS
STANDARD-CASE-SYMBOL-NAME
FIND-STANDARD-CASE-SYMBOL
Script succeeded
Using ecl, test-utilities.script passed


Testing: test-version.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-version.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-version.script with ecl-16.1.2-e640ef1c-haiku-x86
Check that there is an ASDF version that correctly parses to a non-empty list
Check that ASDF is newer than 1.234
Check that ASDF is not a compatible replacement for 1.234
Check that asdf.asd is not registered and we're using a fallback system
; Registering #<system "asdf">
Check that the fallback system bears the current asdf version
; Registering #<system "unversioned-system">
; Registering #<system "versioned-system-1">
; Registering #<system "versioned-system-2">
; Loading system definition for test-asdf from /boot/home/ecl/asdf/test/test-asdf.asd
; Registering #<system "test-asdf">
; Registering #<system "test-asdf/all">
; Registering #<system "test-asdf/1">
; Registering #<system "test-asdf/2">
; Registering #<system "test-asdf/4">
; Registering #<system "test-asdf/test9-1">
; Registering #<system "test-asdf/test-module-depend">
; Registering #<system "test-asdf/test9-2">
; Registering #<system "test-asdf/test9-3">
; Registering #<system "test-asdf/test-source-directory-1">
; Registering #<system "test-asdf/test-source-directory-2">
; Registering #<system "test-asdf/bundle-1">
; Registering #<system "test-asdf/bundle-2">
; Registering #<system "test-asdf/force">
; Registering #<system "test-asdf/force1">
; Registering #<system "versioned-system-3">
; Registering #<system "versioned-system-file-form">
; Registering #<system "versioned-system-file-line">
;;; Warning: Requested version "1" but #<system "unversioned-system"> has no version
Script succeeded
Using ecl, test-version.script passed


Testing: test-weakly-depends-on-present.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-weakly-depends-on-present.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-weakly-depends-on-present.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "test-weakly-depends-on-present">
; Loading system definition for file3-only from /boot/home/ecl/asdf/test/file3-only.asd
; Registering #<system "file3-only">
Loading
  (ASDF/OPERATE:OPERATE 'ASDF/LISP-ACTION:LOAD-OP 'ASDF-TEST::TEST-WEAKLY-DEPENDS-ON-PRESENT) => #<load-op > #<a ASDF/PLAN:SEQUENTIAL-PLAN>
The weakly-depended-on system, file3-only, should be loaded...
test1 1
  ASDF-TEST::*FILE3* => #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file3.fas"
  ASDF-TEST::*FILE3-DATE* => 3682216502
The depending system (test-weakly-depends-on-present) loads successfully. [2011/12/14:rpg]
test1 2
  ASDF-TEST::*FILE1* => #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas"
  ASDF-TEST::*FILE1-DATE* => 3682216503
Script succeeded
Using ecl, test-weakly-depends-on-present.script passed


Testing: test-weakly-depends-on-unpresent.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-weakly-depends-on-unpresent.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-weakly-depends-on-unpresent.script with ecl-16.1.2-e640ef1c-haiku-x86
test1 1: #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas" 3682216503
Script succeeded
Using ecl, test-weakly-depends-on-unpresent.script passed


Testing: test-xach-update-bug.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test-xach-update-bug.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test-xach-update-bug.script with ecl-16.1.2-e640ef1c-haiku-x86
load foo. Should load from xach-foo-1/
; Loading system definition for test-asdf-location-change from /boot/home/ecl/asdf/test/xach-foo-1/test-asdf-location-change.asd
; Registering #<system "test-asdf-location-change">
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression (SUBPATHNAME *TEST-DIRECTORY*
                                  "xach-foo-1/test-asdf-location-change.asd") yields this:
  #P"/boot/home/ecl/asdf/test/xach-foo-1/test-asdf-location-change.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test" "xach-foo-1") :NAME
   "test-asdf-location-change" :TYPE "asd" :VERSION NIL)

        the other expression (SYSTEM-SOURCE-FILE FOO1) yields that:
  #P"/boot/home/ecl/asdf/test/xach-foo-1/test-asdf-location-change.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test" "xach-foo-1") :NAME
   "test-asdf-location-change" :TYPE "asd" :VERSION :NEWEST)

(SUBPATHNAME *TEST-DIRECTORY* "xach-foo-1/a.lisp") and
 (COMPONENT-PATHNAME (FIND-COMPONENT FOO1 "a")) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/xach-foo-1/a.lisp"
;;;
;;; Compiling /boot/home/ecl/asdf/test/xach-foo-1/a.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/xach-foo-1/a.lisp.
;;;
TEST ABORTED: The variable FIRST-VERSION:LOADED is unbound.
Backtrace:
0: (#:G2351 NIL)
1: (UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX #(1906127824 30339864 1906127728))
2: (UIOP/IMAGE:PRINT-BACKTRACE NIL)
3: (UIOP/IMAGE:PRINT-CONDITION-BACKTRACE #(1 30341864 1906128228))
4: (#<bytecompiled-function ASDF-TEST:ACALL> ((ASDF-TEST::ARGS #<a UNBOUND-VARIABLE> :COUNT 69 :STREAM #<output stream "stdout">) (ASDF-TEST::NAME . :PRINT-CONDITION-BACKTRACE)))
5: (#<bytecompiled-function 194bc348> ((375 . 0) (#:G238) (374 . #:G237) (ASDF-TEST::C . #<a UNBOUND-VARIABLE>) (:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 194bc258>>)))
6: (#<bytecompiled-function 1a207af0> NIL)
7: (#<bytecompiled-function ASDF-TEST::CALL-WITH-EXPECTED-FAILURE> ((ASDF-TEST::THUNK . #<bytecompiled-function 1a207af0>) (CONDITION)))
8: (#<bytecompiled-function SI:BYTECODES> NIL)
9: (#<bytecompiled-function 194bc258> ((ASDF-TEST::NAME . "test-xach-update-bug.script") (ASDF-TEST::FILE . ASDF-TEST::|test-xach-update-bug.script|)))
10: (ASDF/CACHE:CALL-WITH-ASDF-CACHE #(1 30346008 1906131548))
11: (#<bytecompiled-function ASDF-TEST::CALL-WITH-TEST> ((:ASDF-TEST-DONE . :ASDF-TEST-DONE) (ASDF-TEST::THUNK . #<bytecompiled-closure #<bytecompiled-function 194bc258>>)))
12: (#<bytecompiled-function ASDF-TEST:RUN-TEST-SCRIPT> ((ASDF-TEST::FILE . ASDF-TEST::|test-xach-update-bug.script|)))
13: (#<bytecompiled-function SI:BYTECODES> NIL)
14: (#<bytecompiled-function SI:BYTECODES> ((SI::OUTPUT-FILE . T) (SI::C-FILE) (SI::H-FILE) (SI::DATA-FILE) (SI::VERBOSE . T) (SI::SYSTEM-P) (EXT:QUIT)))
15: (#<bytecompiled-function SI:BYTECODES> NIL)
16: (NIL NIL)
Above backtrace due to this condition:
The variable FIRST-VERSION:LOADED is unbound.
Script failed
Using ecl, test-xach-update-bug.script failed
you can retry compilation with:
./test/run-tests.sh ecl test-xach-update-bug.script
or more interactively (and maybe with rlwrap or in emacs), start with:
(cd test ; ecl -norc -load sys:cmp )
then copy/paste:
'(#.(load "script-support.lisp") #.(asdf-test::da) #.(load-asdf) #.(frob-packages) #.(asdf::with-asdf-cache () (load "test-xach-update-bug.script")))


Testing: test1.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test1.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test1.script with ecl-16.1.2-e640ef1c-haiku-x86
; Loading system definition for test1 from /boot/home/ecl/asdf/test/test1.asd
; Registering #<system "test1">
;;; Warning: These two expressions yield pathname-equal yet not equal path
the first expression TEST1.ASD yields this:
  #P"/boot/home/ecl/asdf/test/test1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test1" :TYPE "asd"
   :VERSION :NEWEST)

        the other expression (TEST-SOURCE "test1.asd") yields that:
  #P"/boot/home/ecl/asdf/test/test1.asd"
  (:HOST NIL :DEVICE NIL :DIRECTORY
   (:ABSOLUTE "boot" "home" "ecl" "asdf" "test") :NAME "test1" :TYPE "asd"
   :VERSION NIL)

FILE1.LISP and
 (TEST-SOURCE "file1.lisp") both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/file1.lisp"
FILE2.LISP and
 (TEST-SOURCE "file2.lisp") both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/file2.lisp"
FILE1.FASL and
 (TEST-FASL "file1") both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file1.fas"
FILE2.FASL and
 (TEST-FASL "file2") both evaluate to same path:
  #P"/boot/home/ecl/asdf/build/fasls/ecl-16.1.2-e640ef1c-haiku-x86/asdf/test/file2.fas"
loading test1
test that it compiled
  ASDF-TEST::*DATE* => 3682182613
  ASDF-TEST::*THEN* => 3682216505
and loaded
now remove file2 that depends-on file1
load again
;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
check that file1 is _not_ recompiled, but file2 is
now touch file1 and check that file2 _is_ also recompiled
;;;
;;; Compiling /boot/home/ecl/asdf/test/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file1.lisp.
;;;
;;;
;;; Compiling /boot/home/ecl/asdf/test/file2.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file2.lisp.
;;;
FOO
  (FILE-WRITE-DATE ASDF-TEST::FILE2.FASL) => 3682216616
  ASDF-TEST::*BEFORE* => 3682216615
Script succeeded
Using ecl, test1.script passed


Testing: test2.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test2.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test2.script with ecl-16.1.2-e640ef1c-haiku-x86
test2: loading test2b1
;;;
;;; Compiling /boot/home/ecl/asdf/test/file4.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file4.lisp.
;;;
test2: file3 and file4 were compiled
test2: loading test2b2 should fail
load failed as expected: - 
Component ASDF/USER::TEST2A does not match version 1.2, required by
#<system "test2b2">
test2: loading test2b3 should fail
load failed as expected: - 
Component ASDF/USER::BET-YOU-CANT-FIND-THIS not found, required by
#<system "test2b3">
Script succeeded
Using ecl, test2.script passed


Testing: test3.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test3.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test3.script with ecl-16.1.2-e640ef1c-haiku-x86
should load file1 but not file2
;;;
;;; Compiling /boot/home/ecl/asdf/test/file1.lisp.
;;; OPTIMIZE levels: Safety=3, Space=0, Speed=2, Debug=3
;;;
;;; End of Pass 1.
;;; Finished compiling /boot/home/ecl/asdf/test/file1.lisp.
;;;
Script succeeded
Using ecl, test3.script passed


Testing: test8.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test8.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test8.script with ecl-16.1.2-e640ef1c-haiku-x86
got missing-component as expected: - 
Component SYSTEM-DOES-NOT-EXIST not found
Script succeeded
Using ecl, test8.script passed


Testing: test9.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|test9.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running test9.script with ecl-16.1.2-e640ef1c-haiku-x86
got missing-component-of-version as expected: - 
Component :TEST-ASDF/TEST9-2 does not match version 2.0, required by
#<system "test-asdf/test9-1">
Script succeeded
Using ecl, test9.script passed


Testing: wild-module.script
ecl -norc -load sys:cmp -eval "'(#.(load(string'|script-support.lisp|))#.(asdf-test::load-asdf)#.(asdf-test::frob-packages)#.(asdf-test:run-test-script'|wild-module.script|))"
;;; Loading #P"/boot/home/ecl/output/lib/ecl-16.1.2/cmp.fas"
;;; Loading "/boot/home/ecl/asdf/test/script-support.lisp"
;;; Loading "/boot/home/ecl/asdf/build/fasls/ecl/asdf.fas"
Configuring ASDF
Enabling debugging
Being a bit verbose
Comparing directories
ASDF-TEST:*TEST-DIRECTORY* and
 (:PATHNAME-DIRECTORY-PATHNAME (NTH-VALUE 2 (:LOCATE-SYSTEM :TEST-ASDF))) both evaluate to same path:
  #P"/boot/home/ecl/asdf/test/"
Frob packages
Running wild-module.script with ecl-16.1.2-e640ef1c-haiku-x86
; Registering #<system "wild-module">
;;; Warning: completing compilation for #<wild-module "wild-module" "systems"> completed without its input file #P"/boot/home/ecl/asdf/test/*.asd"
;;; Warning: completing load for #<wild-module "wild-module" "systems"> completed without its input file #P"/boot/home/ecl/asdf/test/*.asd"
Script succeeded
Using ecl, wild-module.script passed



-#---------------------------------------
Using ecl
Ran 60 tests: 
  53 passing and 7 failing
failing test(s):  ecl-make-image.script test-bundle.script test-make-build.script test-program.script test-run-program.script test-symlink-loop.script test-xach-update-bug.script
-#---------------------------------------