ECL (Embeddable Common-Lisp) 9.11.1

Copyright (C) 1984 Taiichi Yuasa and Masami Hagiya

Copyright (C) 1993 Giuseppe Attardi

Copyright (C) 2000 Juan J. Garcia-Ripoll

ECL is free software, and you are welcome to redistribute it

under certain conditions; see file 'Copyright' for details.

Type :h for Help.  

Top level in: #<process SI:TOP-LEVEL 00a60fc0>.

> 

;;; Loading "c:/cygwin/home/Jjgarcia/tmp/mingw32/ecl-test/bugs/doit.lsp"

;;; Loading #P"c:/cygwin/home/Jjgarcia/tmp/mingw32/cmp.fas"

;;; Loading #P"c:/cygwin/home/Jjgarcia/tmp/mingw32/sysfun.lsp"

;;; Loading #P"c:/cygwin/home/Jjgarcia/tmp/mingw32/RT.fas"

;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0

;;; End of Pass 1.

;;; Note: Invoking external command:

;;;   gcc "-Ic:/cygwin/home/Jjgarcia/tmp/mingw32" -Ic:/cygwin/home/Jjgarcia/mingw/include -g -O2   -D_THREAD_SAFE -Dmingw32 -O -w -c "C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/ECL461.c" -o "C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/ECL461.o"

;;; Note: Invoking external command:

;;;   gcc -shared -o "C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/ECL461.fas" -Wl,--export-all-symbols -L"c:/cygwin/home/Jjgarcia/tmp/mingw32" "C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/ECL461.o"    -Lc:/cygwin/home/Jjgarcia/mingw/lib  -lecl  -lgmp -lgc    -lm -lws2_32;;; Warning: Redefining test MOP-0004-DEFCLASS-OPTIONS



Doing 49 pending tests of 49 tests total.

 CL-0001-IMPORT CL-0002-MACRO-SHADOW CL-0003-APROPOS CL-0004-STREAMP

 CL-0005-SUBTYPEP-STREAM CL-0006-ENOUGH-NAMESTRING

 CL-0007-ADJUSTABLE-ARRAY CL-0008-PARSE-NAMESTRING CL-0010-HASH-ITERATOR

 CL-0011-MAKE-PATHNAME-WITH-BACK

89 

74 

88 

99 

101 

99 

101 

94 

67 

80 

34 

89 

37 

72 

41 

77 

40 

64 

64 

92 

Test CL-0012-COPY-READTABLE failed

Form: (LET ((FROM-READTABLE (COPY-READTABLE))

            (TO-READTABLE (COPY-READTABLE))

            (CHAR-LIST 'NIL))

        (DOTIMES (I 20)

          (LET* ((CODE (PRINT (+ 32 (RANDOM 70)))) (C (CODE-CHAR CODE)))

            (PUSH C CHAR-LIST)

            (SET-MACRO-CHARACTER (CODE-CHAR CODE)

                                 (EVAL

                                  (SI:QUASIQUOTE

                                   (LAMBDA (STR CH) (SI:UNQUOTE CODE))))

                                 NIL

                                 FROM-READTABLE)))

        (COPY-READTABLE FROM-READTABLE TO-READTABLE)

        (LOOP FOR

              C

              IN

              CHAR-LIST

              UNLESS

              (AND

               (EQL (CODE-CHAR C)

                    (LET ((*READTABLE* FROM-READTABLE))

                      (READ-FROM-STRING C)))

               (EQ (GET-MACRO-CHARACTER C FROM-READTABLE)

                   (GET-MACRO-CHARACTER C TO-READTABLE)))

              COLLECT

              C))

Expected value: NIL

Actual value: #<a TYPE-ERROR>.

Condition: #\\ is not of type INTEGER.rm: invalid option -- s
Try `rm --help' for more information.


Test CL-0013-TRUENAME failed

Form: (PROGN

       (SI:SYSTEM "rm -rf foo; ln -sf //usr/ foo")

       (NAMESTRING (TRUENAME "./foo")))

Expected value: "/usr/"

Actual value: #<a FILE-ERROR>.

Condition: Filesystem error with pathname "./foo".

Either

 1) the file does not exist, or

 2) we are not allow to access the file, or

 3) the pathname points to a broken symbolic link.

Test CL-0014-SHARP-DOT failed

Form: (WITH-OUTPUT-TO-STRING (*STANDARD-OUTPUT*)

        (LET ((*PRINT-CIRCLE* T))

          (READ-FROM-STRING "'#.(princ (list '#1=(1 2) '#1#))")))

Expected value: "(#1=(1 2) #1#)"

Actual value: "(#1=(1 2) (1 . #1#))".

 CL-0015-SETF-EXPANDER CL-0016-DEFSTRUCT-INCLUDE

Test CL-0017-LOAD-SPECIAL failed

Form: (HANDLER-CASE (AND (LOAD "NULL") T) (SERIOUS-CONDITION (C) NIL))

Expected value: T

Actual value: NIL.

Test CL-0018-SHARP-EQ failed

Form: (HANDLER-CASE (VALUES (READ-FROM-STRING "(#1=(0 1 2) #.(length '#1#))"))

                    (SERIOUS-CONDITION (C) NIL))

Expected value: ((0 1 2) 3)

Actual value: ((0 1 2) 4).

 CL-0019-FDEFINITION INT-0001-GLOBAL-SETQ CMP-0001-BLOCK

 CMP-0002-PATHNAME

Test CMP-0003-PATHS failed

Form: (LET* ((OUTPUT (COMPILE-FILE-PATHNAME "tmp/aux" :TYPE :FASL))

             (H-FILE (COMPILE-FILE-PATHNAME OUTPUT :TYPE :H))

             (C-FILE (COMPILE-FILE-PATHNAME OUTPUT :TYPE :C))

             (DATA-FILE (COMPILE-FILE-PATHNAME OUTPUT :TYPE :DATA)))

        (AND (ZEROP (SI:SYSTEM "rm -rf tmp; mkdir tmp"))

             (WITH-COMPILER

              ("aux-cmp-0003-paths.lsp" :OUTPUT-FILE OUTPUT :C-FILE T :H-FILE T

               :DATA-FILE T)

              '(DEFUN FOO (X) (1+ X)))

             (PROBE-FILE OUTPUT)

             (PROBE-FILE C-FILE)

             (PROBE-FILE H-FILE)

             (PROBE-FILE DATA-FILE)

             (DELETE-FILE "aux-cmp-0003-paths.lsp")

             T))

Expected value: T

Actual value: NIL.

 CMP-0004-DEFCONSTANT-WARN CMP-0005-DECLARATION

 CMP-0006-CALL-ARGUMENTS-LIMIT CMP-0007-CIRCULAR-LOAD-FORM

#<a CMP-007-CLASS> 

#<a CMP-007-CLASS> 

#<a CMP-007-CLASS> 

#<a CMP-007-CLASS>  CMP-0008-MAKE-LOAD-FORM CMP-0009-MACROLET

Test CMP-0010-MACROLET failed

Form: (FLET ((EVAL-WITH-ERROR (FORM)

               (HANDLER-CASE (EVAL FORM) (ERROR (C) 'ERROR))))

        (MAKUNBOUND 'FOO)

        (FMAKUNBOUND 'FOO)

        (LET ((FAA 1))

          (DECLARE (SPECIAL FAA))

          (MAPCAR #'EVAL-WITH-ERROR

                  '((LET ((FAA 2))

                      (MACROLET ((M ()

                                   FAA))

                        (M)))

                    (LET ((FAA 4))

                      (DECLARE (SPECIAL FAA))

                      (MACROLET ((M ()

                                   FAA))

                        (M)))

                    (LET ((FAA 4))

                      (DECLARE (SPECIAL FOO))

                      (MACROLET ((M ()

                                   FOO))

                        (M)))

                    (LET ((FAA 5))

                      (MACROLET ((M ()

                                   FOO))

                        (M)))

                    (MACROLET ((FOO ()

                                 6))

                      (MACROLET ((M ()

                                   (FOO)))

                        (M)))

                    (MACROLET ((F1 ()

                                 7)

                               (F2 ()

                                 8))

                      (MACROLET ((F1 ()

                                   9)

                                 (F2 ()

                                   10)

                                 (M ()

                                   (LIST 'QUOTE (LIST (F1) (F2)))))

                        (M)))

                    (FLET ((FOO ()

                             1))

                      (MACROLET ((M ()

                                   (FOO)))

                        (M)))

                    (LABELS ((FOO ()

                               1))

                      (MACROLET ((M ()

                                   (FOO)))

                        (M)))))))

Expected value: (ERROR 1 ERROR ERROR 6 (7 8) ERROR ERROR)

Actual value: #<a SIMPLE-ERROR>.

Condition: Cannot unbind the constant FOO.

;;; Internal error: ecl_make_cfun: function requires too many arguments.

Test CMP-0011-C-ARGUMENTS-LIMIT failed

Form: (MAPCAR

       #'(LAMBDA (NARGS)

           (LET* ((ARG-LIST

                   (LOOP FOR

                         I

                         FROM

                         0

                         BELOW

                         NARGS

                         COLLECT

                         (INTERN (FORMAT NIL "arg~d" I))))

                  (DATA (LOOP FOR I FROM 0 BELOW NARGS COLLECT I))

                  (LAMBDA-FORM

                   (SI:QUASIQUOTE

                    (LAMBDA (SI:UNQUOTE ARG-LIST)

                      (AND

                       (EQUALP (LIST (SI:UNQUOTE-SPLICE ARG-LIST))

                               '(SI:UNQUOTE DATA))

                       (SI:UNQUOTE NARGS)))))

                  (*COMPILE-VERBOSE* NIL)

                  (*COMPILE-PRINT* NIL)

                  (FUNCTION (COMPILE 'FOO LAMBDA-FORM)))

             (LIST (APPLY FUNCTION (SUBSEQ DATA 0 NARGS))

                   (HANDLER-CASE (APPLY FUNCTION (MAKE-LIST (1+ NARGS)))

                                 (ERROR (C) :ERROR))

                   (HANDLER-CASE (APPLY FUNCTION (MAKE-LIST (1- NARGS)))

                                 (ERROR (C) :ERROR)))))

       '(10 20 30 40 50 63 64 65 70))

Expected value: ((10 :ERROR :ERROR) (20 :ERROR :ERROR) (30 :ERROR :ERROR)

                 (40 :ERROR :ERROR) (50 :ERROR :ERROR) (63 :ERROR :ERROR)

                 (64 :ERROR :ERROR) (65 :ERROR :ERROR) (70 :ERROR :ERROR))

Actual value: #<a SIMPLE-PROGRAM-ERROR>.

Condition: Wrong number of arguments passed to function #<compiled-function FOO>.

 CMP-0012-COMPUTE-CLOSURE CMP-0013-FTYPE-USER-TYPE CMP-0014-COERCE

 CMP-0015-COERCE CMP-0016-LET-WITH-SPECIALS CMP-0017-DOCSTRINGS

 CMP-0018-IGNORABLE MOP-0001-FIXUP MOP-0002-METACLASSES MOP-0003-SYMBOLS

 MOP-0004-DEFCLASS-OPTIONS MOP-0005-SETF-SPECIALIZER

Test MOP-0006-METHOD-SPECIALIZER failed

Form: (PROGN

       (DEFMETHOD FOO (A))

       (PROG1 (METHOD-SPECIALIZERS (FIRST (GENERIC-FUNCTION-METHODS #'FOO)))

         (FMAKUNBOUND 'FOO)))

Expected value: '(T)

Actual value: #<a SIMPLE-PROGRAM-ERROR>.

Condition: The symbol FOO is bound to an ordinary function and is not a valid name for a generic function

 MOP-0007-SLOT-INHERITANCE MOP-0008-DEFCLASS-OPTION-QUOTE

Test MOP-0009-DEFCLASS-INITFORM failed

Form: (LOOP FOR

            QUOTING

            IN

            '(NIL T)

            COLLECT

            (LOOP FOR

                  F

                  IN

                  '(MOST-POSITIVE-FIXNUM #<bytecompiled-function 00e94e38> 12

                    "hola" :A T NIL)

                  COLLECT

                  (PROG1

                      (EVAL

                       (SI:QUASIQUOTE

                        (PROGN

                         (DEFCLASS FOO

                                   NIL

                                   ((A :INITFORM

                                     (SI:UNQUOTE

                                      (IF QUOTING (LIST 'QUOTE F) F)))))

                         (SLOT-VALUE (MAKE-INSTANCE 'FOO) 'A))))

                    (DELETE-CLASS 'FOO))))

Expected value: ((536870911

                  #<bytecompiled-closure #<bytecompiled-function 00e94e38>> 12

                  "hola" :A T NIL)

                 (MOST-POSITIVE-FIXNUM

                  #<bytecompiled-closure #<bytecompiled-function 00e94e38>> 12

                  "hola" :A T NIL))

Actual value: ((536870911 #<bytecompiled-function 00e94e38> 12 "hola" :A T NIL)

               (MOST-POSITIVE-FIXNUM #<bytecompiled-function 00e94e38> 12

                "hola" :A T NIL)).

Test FFI-001-CALLBACK failed

Form: (AND (ZEROP (SI:SYSTEM "rm -rf tmp; mkdir tmp"))

           (WITH-OPEN-FILE

               (S "tmp/a.lsp" :DIRECTION :OUTPUT :IF-EXISTS :SUPERSEDE

                :IF-DOES-NOT-EXIST :CREATE)

             (PRINT '(FFI:DEFCALLBACK FOO :VOID NIL NIL) S))

           (WITH-OPEN-FILE

               (S "tmp/b.lsp" :DIRECTION :OUTPUT :IF-EXISTS :SUPERSEDE

                :IF-DOES-NOT-EXIST :CREATE)

             (PRINT '(FFI:DEFCALLBACK FOO :VOID NIL NIL) S))

           (COMPILE-FILE "tmp/a.lsp" :SYSTEM-P T)

           (COMPILE-FILE "tmp/b.lsp" :SYSTEM-P T)

           (C:BUILD-PROGRAM "tmp/foo"

                            :LISP-FILES

                            (LIST

                             (COMPILE-FILE-PATHNAME "tmp/a.lsp" :TYPE :OBJECT)

                             (COMPILE-FILE-PATHNAME "tmp/b.lsp"

                                                    :TYPE

                                                    :OBJECT)))

           (PROBE-FILE (COMPILE-FILE-PATHNAME "tmp/foo" :TYPE :PROGRAM))

           (ZEROP (SI:SYSTEM "rm -rf tmp"))

           T)

Expected value: T

Actual value: #<a FILE-ERROR>.

Condition: Filesystem error with pathname "tmp/a.lsp".

Either

 1) the file does not exist, or

 2) we are not allow to access the file, or

 3) the pathname points to a broken symbolic link.

Test FFI-002-CALLBACK failed

Form: (AND (ZEROP (SI:SYSTEM "rm -rf tmp; mkdir tmp"))

           (WITH-OPEN-FILE

               (S "tmp/c.lsp" :DIRECTION :OUTPUT :IF-EXISTS :SUPERSEDE

                :IF-DOES-NOT-EXIST :CREATE)

             (PRINT

              '(DEFUN CALLBACK-USER (CALLBACK ARG)

                 (FFI:C-INLINE (CALLBACK ARG)

                               (:POINTER-VOID :INT)

                               :INT

                               "

int (*foo)(int) = #0;

@(return) = foo(#1);

"

                               :ONE-LINER

                               NIL

                               :SIDE-EFFECTS

                               NIL))

              S)

             (PRINT '(FFI:DEFCALLBACK FOO :INT ((A :INT)) (1+ A)) S))

           (COMPILE-FILE "tmp/c.lsp" :LOAD T)

           (EQL (CALLBACK-USER (FFI:CALLBACK 'FOO) 2) 3)

           T)

Expected value: T

Actual value: #<a FILE-ERROR>.

Condition: Filesystem error with pathname "tmp/c.lsp".

Either

 1) the file does not exist, or

 2) we are not allow to access the file, or

 3) the pathname points to a broken symbolic link.

Test MP-0001-WITH-LOCK failed

Form: (PROGN

       (DEFPARAMETER *MP-0001-WITH-LOCK-A* T)

       (DEFPARAMETER *MP-0001-WITH-LOCK-B* (MP:MAKE-LOCK))

       (MP:WITH-LOCK (*MP-0001-WITH-LOCK-B*)

                     (LET ((BACKGROUND-PROCESS

                            (MP:PROCESS-RUN-FUNCTION 'MP-0001-WITH-LOCK

                                                     (COERCE

                                                      '(LAMBDA ()

                                                         (HANDLER-CASE

                                                          (PROGN

                                                           (SETF *MP-0001-WITH-LOCK-A*

                                                                   1)

                                                           (MP:WITH-LOCK

                                                            (*MP-0001-WITH-LOCK-B*)

                                                            (SETF *MP-0001-WITH-LOCK-A*

                                                                    1)))

                                                          (ERROR (C)

                                                                 (PRINC C)

                                                                 (TERPRI)

                                                                 (SETF *MP-0001-WITH-LOCK-A*

                                                                         C)))

                                                         (SETF *MP-0001-WITH-LOCK-A*

                                                                 2))

                                                      'FUNCTION))))

                       (AND (MP:PROCESS-KILL BACKGROUND-PROCESS)

                            (PROGN

                             (SLEEP 1)

                             (NOT (MP:PROCESS-ACTIVE-P BACKGROUND-PROCESS)))

                            (EQ *MP-0001-WITH-LOCK-A* 1)))))

Expected value: T

Actual value: #<a SIMPLE-ERROR>.

Condition: Cannot interrupt the inactive process #<process MP-0001-WITH-LOCK 00a60b70>

13 out of 49 total tests failed: CL-0012-COPY-READTABLE, CL-0013-TRUENAME, CL-0014-SHARP-DOT, 

   CL-0017-LOAD-SPECIAL, CL-0018-SHARP-EQ, CMP-0003-PATHS, 

   CMP-0010-MACROLET, CMP-0011-C-ARGUMENTS-LIMIT, 

   MOP-0006-METHOD-SPECIALIZER, MOP-0009-DEFCLASS-INITFORM, 

   FFI-001-CALLBACK, FFI-002-CALLBACK, MP-0001-WITH-LOCK.

real time : 25.456 secs

run time  : 0.831 secs

gc count  : 22 times

consed    : 455971800 bytes

#P"c:/cygwin/home/Jjgarcia/tmp/mingw32/ecl-test/bugs/doit.lsp"

>