From d8f454a3e649bea58e24c55fff3c5968a398d29d Mon Sep 17 00:00:00 2001 From: pfdietz Date: Sat, 17 Jan 2004 18:38:50 +0000 Subject: [PATCH] Changed classify-error forms to signals-error forms. --- ansi-tests/labels.lsp | 44 +++++++------- ansi-tests/lambda.lsp | 15 +++-- ansi-tests/last.lsp | 34 ++++++----- ansi-tests/lcm.lsp | 2 +- ansi-tests/ldb.lsp | 16 +++-- ansi-tests/ldiff.lsp | 35 +++++------ ansi-tests/length.lsp | Bin 3086 -> 3094 bytes ansi-tests/let.lsp | 4 +- ansi-tests/list-length.lsp | 24 ++++---- ansi-tests/listp.lsp | 8 +-- .../load-logical-pathname-translations.lsp | 11 ++-- ansi-tests/logand.lsp | 7 ++- ansi-tests/logandc1.lsp | 20 ++++--- ansi-tests/logandc2.lsp | 20 ++++--- ansi-tests/logbitp.lsp | 22 ++++--- ansi-tests/logcount.lsp | 14 +++-- ansi-tests/logeqv.lsp | 7 ++- ansi-tests/logical-pathname.lsp | 5 +- ansi-tests/logior.lsp | 7 ++- ansi-tests/lognand.lsp | 20 ++++--- ansi-tests/lognor.lsp | 20 ++++--- ansi-tests/lognot.lsp | 14 +++-- ansi-tests/logorc1.lsp | 20 ++++--- ansi-tests/logorc2.lsp | 20 ++++--- ansi-tests/logtest.lsp | 20 ++++--- ansi-tests/logxor.lsp | 8 ++- ansi-tests/loop.lsp | 21 +++---- ansi-tests/loop10.lsp | 56 ++++++++++-------- ansi-tests/loop12.lsp | 42 +++++++------ ansi-tests/loop2.lsp | 19 +++--- ansi-tests/loop3.lsp | 13 ++-- ansi-tests/loop4.lsp | 21 ++++--- ansi-tests/loop5.lsp | 31 ++++++---- ansi-tests/loop6.lsp | 39 ++++++------ ansi-tests/loop7.lsp | 23 ++++--- ansi-tests/loop8.lsp | 14 +++-- ansi-tests/loop9.lsp | 42 +++++++------ 37 files changed, 422 insertions(+), 316 deletions(-) diff --git a/ansi-tests/labels.lsp b/ansi-tests/labels.lsp index 04d904d..7c11482 100644 --- a/ansi-tests/labels.lsp +++ b/ansi-tests/labels.lsp @@ -74,32 +74,36 @@ ;;; Unknown keyword parameter should throw a program-error in safe code ;;; (section 3.5.1.4) (deftest labels.12 - (classify-error - (labels ((%f (&key a (b 0 b-p)) (values a b (not (not b-p))))) (%f :c 4))) - program-error) + (signals-error + (labels ((%f (&key a (b 0 b-p)) (values a b (not (not b-p))))) (%f :c 4)) + program-error) + t) ;;; Odd # of keyword args should throw a program-error in safe code ;;; (section 3.5.1.6) (deftest labels.13 - (classify-error - (labels ((%f (&key a (b 0 b-p)) (values a b (not (not b-p))))) (%f :a))) - program-error) + (signals-error + (labels ((%f (&key a (b 0 b-p)) (values a b (not (not b-p))))) (%f :a)) + program-error) + t) ;;; Too few arguments (section 3.5.1.2) (deftest labels.14 - (classify-error (labels ((%f (a) a)) (%f))) - program-error) + (signals-error (labels ((%f (a) a)) (%f)) + program-error) + t) ;;; Too many arguments (section 3.5.1.3) (deftest labels.15 - (classify-error (labels ((%f (a) a)) (%f 1 2))) - program-error) + (signals-error (labels ((%f (a) a)) (%f 1 2)) + program-error) + t) ;;; Invalid keyword argument (section 3.5.1.5) (deftest labels.16 - (classify-error (labels ((%f (&key a) a)) (%f '(foo)))) - program-error) - + (signals-error (labels ((%f (&key a) a)) (%f '(foo))) + program-error) + t) ;;; Definition of a (setf ...) function @@ -179,18 +183,18 @@ (deftest labels.24 (loop for s in *cl-non-function-macro-special-operator-symbols* - for form = `(classify-error (labels ((,s (x) (foo (1- x))) - (foo (y) - (if (<= y 0) 'a - (,s (1- y))))) - (,s 10))) + for form = `(ignore-errors (labels ((,s (x) (foo (1- x))) + (foo (y) + (if (<= y 0) 'a + (,s (1- y))))) + (,s 10))) unless (eq (eval form) 'a) collect s) nil) (deftest labels.25 (loop for s in *cl-non-function-macro-special-operator-symbols* - for form = `(classify-error + for form = `(ignore-errors (labels ((,s (x) (foo (1- x))) (foo (y) (if (<= y 0) 'a @@ -204,7 +208,7 @@ (deftest labels.26 (loop for s in *cl-non-function-macro-special-operator-symbols* - for form = `(classify-error + for form = `(ignore-errors (labels (((setf ,s) (&rest args) (declare (ignore args)) 'a)) diff --git a/ansi-tests/lambda.lsp b/ansi-tests/lambda.lsp index 2096629..ed13ae6 100644 --- a/ansi-tests/lambda.lsp +++ b/ansi-tests/lambda.lsp @@ -262,13 +262,16 @@ 10) (deftest lambda.error.1 - (classify-error (funcall (macro-function 'lambda))) - program-error) + (signals-error (funcall (macro-function 'lambda)) + program-error) + t) (deftest lambda.error.2 - (classify-error (funcall (macro-function 'lambda) '(lambda ()))) - program-error) + (signals-error (funcall (macro-function 'lambda) '(lambda ())) + program-error) + t) (deftest lambda.error.3 - (classify-error (funcall (macro-function 'lambda) '(lambda ()) nil nil)) - program-error) + (signals-error (funcall (macro-function 'lambda) '(lambda ()) nil nil) + program-error) + t) diff --git a/ansi-tests/last.lsp b/ansi-tests/last.lsp index ce6e97a..4ad339b 100644 --- a/ansi-tests/last.lsp +++ b/ansi-tests/last.lsp @@ -79,33 +79,35 @@ (d) 1) (deftest last.error.1 - (classify-error (last (list 'a 'b 'c) -1)) - type-error) + (signals-error (last (list 'a 'b 'c) -1) type-error) + t) (deftest last.error.2 - (classify-error (last (list 'a 'b 'c) 'a)) - type-error) + (signals-error (last (list 'a 'b 'c) 'a) type-error) + t) (deftest last.error.3 - (classify-error (last (list 'a 'b 'c) 10.0)) - type-error) + (signals-error (last (list 'a 'b 'c) 10.0) type-error) + t) (deftest last.error.4 - (classify-error (last (list 'a 'b 'c) -10.0)) - type-error) + (signals-error (last (list 'a 'b 'c) -10.0) type-error) + t) (deftest last.error.5 - (classify-error (last (list 'a 'b 'c) #\w)) - type-error) + (signals-error (last (list 'a 'b 'c) #\w) type-error) + t) (deftest last.error.6 - (classify-error (last)) - program-error) + (signals-error (last) program-error) + t) (deftest last.error.7 - (classify-error (last '(a b c) 2 nil)) - program-error) + (signals-error (last '(a b c) 2 nil) program-error) + t) (deftest last.error.8 - (classify-error (locally (last (list 'a 'b 'c) 'a) t)) - type-error) + (signals-error (locally (last (list 'a 'b 'c) 'a) t) + type-error) + t) + diff --git a/ansi-tests/lcm.lsp b/ansi-tests/lcm.lsp index dcc8159..cd026c4 100644 --- a/ansi-tests/lcm.lsp +++ b/ansi-tests/lcm.lsp @@ -11,7 +11,7 @@ (deftest lcm.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (lcm ',x))) 'type-error)) + (eval `(signals-error (lcm ',x) type-error))) collect x) nil) diff --git a/ansi-tests/ldb.lsp b/ansi-tests/ldb.lsp index 33205d6..f9712db 100644 --- a/ansi-tests/ldb.lsp +++ b/ansi-tests/ldb.lsp @@ -5,17 +5,21 @@ (in-package :cl-test) +;;; Error tests + (deftest ldb.error.1 - (classify-error (ldb)) - program-error) + (signals-error (ldb) program-error) + t) (deftest ldb.error.2 - (classify-error (ldb (byte 1 1))) - program-error) + (signals-error (ldb (byte 1 1)) program-error) + t) (deftest ldb.error.3 - (classify-error (ldb (byte 1 1) -1 0)) - program-error) + (signals-error (ldb (byte 1 1) -1 0) program-error) + t) + +;;; Non-error tests (deftest ldb.1 (loop for x = (random-fixnum) diff --git a/ansi-tests/ldiff.lsp b/ansi-tests/ldiff.lsp index 3c3de96..19f5939 100644 --- a/ansi-tests/ldiff.lsp +++ b/ansi-tests/ldiff.lsp @@ -108,38 +108,39 @@ ;; Error checking (deftest ldiff.error.1 - (classify-error (ldiff 10 'a)) - type-error) + (signals-error (ldiff 10 'a) type-error) + t) ;; Single atoms are not dotted lists, so the next ;; case should be a type-error (deftest ldiff.error.2 - (classify-error (ldiff 'a 'a)) - type-error) + (signals-error (ldiff 'a 'a) type-error) + t) (deftest ldiff.error.3 - (classify-error (ldiff (make-array '(10) :initial-element 'a) '(a))) - type-error) + (signals-error (ldiff (make-array '(10) :initial-element 'a) '(a)) + type-error) + t) (deftest ldiff.error.4 - (classify-error (ldiff 1.23 t)) - type-error) + (signals-error (ldiff 1.23 t) type-error) + t) (deftest ldiff.error.5 - (classify-error (ldiff #\w 'a)) - type-error) + (signals-error (ldiff #\w 'a) type-error) + t) (deftest ldiff.error.6 - (classify-error (ldiff)) - program-error) + (signals-error (ldiff) program-error) + t) (deftest ldiff.error.7 - (classify-error (ldiff nil)) - program-error) + (signals-error (ldiff nil) program-error) + t) (deftest ldiff.error.8 - (classify-error (ldiff nil nil nil)) - program-error) + (signals-error (ldiff nil nil nil) program-error) + t) ;; Note! The spec is ambiguous on whether this next test ;; is correct. The spec says that ldiff should be prepared @@ -159,6 +160,6 @@ (catch-type-error (ldiff x x))))))) (deftest ldiff-12 - (ldiff-12-body) + (ldiff-12-body) 0) |# diff --git a/ansi-tests/length.lsp b/ansi-tests/length.lsp index 039ee052de704d7d381156b7aeade4b1a6d05e89..89186e8ce070a147b8364168514c6a1f3b158f8e 100644 GIT binary patch delta 430 zcmeB^m?p77ltZ&PGd(Xcr&u?&s3^ZkK_e$MFTEr~K|N7Zp`@}P6(X$3rJztUS&&mw z&j`rUz^=v60IL>#V?0{)aOg3?tw%WqtJCDPak)z07^}PV%y8PFsZdaqpI(%hi{^VX kbDUZf@-lNk7?)Nn3v62RlM{1tDp3O+!?By~xy~~J05e91CjbBd delta 425 zcmbOx(I>G%ltUvqC$YFVGp$lLwWuh+NI@efH7~s+LqR=JQAulrrgmLTUwLsQAS&~bR4>im;yK|jq1OS6mhWP*h diff --git a/ansi-tests/let.lsp b/ansi-tests/let.lsp index e661fc1..319d8d4 100644 --- a/ansi-tests/let.lsp +++ b/ansi-tests/let.lsp @@ -105,7 +105,7 @@ ;;; in LET forms. (deftest let.15 (loop for s in *cl-non-variable-constant-symbols* - for form = `(classify-error (let ((,s 17)) ,s)) + for form = `(ignore-errors (let ((,s 17)) ,s)) unless (eql (eval form) 17) collect s) nil) @@ -214,7 +214,7 @@ ;;; in LET* forms. (deftest let*.15 (loop for s in *cl-non-variable-constant-symbols* - for form = `(classify-error (let* ((,s 17)) ,s)) + for form = `(ignore-errors (let* ((,s 17)) ,s)) unless (eql (eval form) 17) collect s) nil) diff --git a/ansi-tests/list-length.lsp b/ansi-tests/list-length.lsp index 4002dfd..50876c6 100644 --- a/ansi-tests/list-length.lsp +++ b/ansi-tests/list-length.lsp @@ -46,25 +46,25 @@ 0) (deftest list-length.error.2 - (classify-error (list-length)) - program-error) + (signals-error (list-length) program-error) + t) (deftest list-length.error.3 - (classify-error (list-length nil nil)) - program-error) + (signals-error (list-length nil nil) program-error) + t) (deftest list-length.error.4 - (classify-error (list-length 'a)) - type-error) + (signals-error (list-length 'a) type-error) + t) (deftest list-length.error.5 - (classify-error (locally (list-length 'a) t)) - type-error) + (signals-error (locally (list-length 'a) t) type-error) + t) (deftest list-length-symbol - (classify-error (list-length 'a)) - type-error) + (signals-error (list-length 'a) type-error) + t) (deftest list-length-dotted-list - (classify-error (list-length (copy-tree '(a b c d . e)))) - type-error) + (signals-error (list-length (copy-tree '(a b c d . e))) type-error) + t) diff --git a/ansi-tests/listp.lsp b/ansi-tests/listp.lsp index 0a1427f..81e4ed0 100644 --- a/ansi-tests/listp.lsp +++ b/ansi-tests/listp.lsp @@ -39,9 +39,9 @@ nil 1) (deftest listp.error.1 - (classify-error (listp)) - program-error) + (signals-error (listp) program-error) + t) (deftest listp.error.2 - (classify-error (listp nil nil)) - program-error) + (signals-error (listp nil nil) program-error) + t) diff --git a/ansi-tests/load-logical-pathname-translations.lsp b/ansi-tests/load-logical-pathname-translations.lsp index 034e4f2..c9c11bf 100644 --- a/ansi-tests/load-logical-pathname-translations.lsp +++ b/ansi-tests/load-logical-pathname-translations.lsp @@ -23,9 +23,12 @@ :good) (deftest load-logical-pathname-translations.error.2 - (classify-error (load-logical-pathname-translations)) - program-error) + (signals-error (load-logical-pathname-translations) + program-error) + t) (deftest load-logical-pathname-translations.error.3 - (classify-error (load-logical-pathname-translations "CLTESTROOT" nil)) - program-error) + (signals-error (load-logical-pathname-translations "CLTESTROOT" nil) + program-error) + t) + diff --git a/ansi-tests/logand.lsp b/ansi-tests/logand.lsp index 25fdbd0..421523a 100644 --- a/ansi-tests/logand.lsp +++ b/ansi-tests/logand.lsp @@ -7,20 +7,23 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logand.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logand ',x))) 'type-error)) + (eval `(signals-error (logand ',x) type-error))) collect x) nil) (deftest logand.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logand 0 ',x))) 'type-error)) + (eval `(signals-error (logand 0 ',x) type-error))) collect x) nil) +;;; Non-error tests (deftest logand.1 (logand) diff --git a/ansi-tests/logandc1.lsp b/ansi-tests/logandc1.lsp index 8cd680b..f53f7a8 100644 --- a/ansi-tests/logandc1.lsp +++ b/ansi-tests/logandc1.lsp @@ -7,31 +7,35 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logandc1.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logandc1 ',x 0))) 'type-error)) + (eval `(signals-error (logandc1 ',x 0) type-error))) collect x) nil) (deftest logandc1.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logandc1 0 ',x))) 'type-error)) + (eval `(signals-error (logandc1 0 ',x) type-error))) collect x) nil) (deftest logandc1.error.3 - (classify-error (logandc1)) - program-error) + (signals-error (logandc1) program-error) + t) (deftest logandc1.error.4 - (classify-error (logandc1 0)) - program-error) + (signals-error (logandc1 0) program-error) + t) (deftest logandc1.error.5 - (classify-error (logandc1 1 2 3)) - program-error) + (signals-error (logandc1 1 2 3) program-error) + t) + +;;; Non-error tests (deftest logandc1.1 (logandc1 0 0) diff --git a/ansi-tests/logandc2.lsp b/ansi-tests/logandc2.lsp index e8910d1..b8d9055 100644 --- a/ansi-tests/logandc2.lsp +++ b/ansi-tests/logandc2.lsp @@ -7,31 +7,35 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logandc2.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logandc2 ',x 0))) 'type-error)) + (eval `(signals-error (logandc2 ',x 0) type-error))) collect x) nil) (deftest logandc2.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logandc2 0 ',x))) 'type-error)) + (eval `(signals-error (logandc2 0 ',x) type-error))) collect x) nil) (deftest logandc2.error.3 - (classify-error (logandc2)) - program-error) + (signals-error (logandc2) program-error) + t) (deftest logandc2.error.4 - (classify-error (logandc2 0)) - program-error) + (signals-error (logandc2 0) program-error) + t) (deftest logandc2.error.5 - (classify-error (logandc2 1 2 3)) - program-error) + (signals-error (logandc2 1 2 3) program-error) + t) + +;;; Non-error tests (deftest logandc2.1 (logandc2 0 0) diff --git a/ansi-tests/logbitp.lsp b/ansi-tests/logbitp.lsp index 1b057d3..891118d 100644 --- a/ansi-tests/logbitp.lsp +++ b/ansi-tests/logbitp.lsp @@ -7,29 +7,33 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logbitp.error.1 - (classify-error (logbitp)) - program-error) + (signals-error (logbitp) program-error) + t) (deftest logbitp.error.2 - (classify-error (logbitp 0)) - program-error) + (signals-error (logbitp 0) program-error) + t) (deftest logbitp.error.3 - (classify-error (logbitp 0 0 0)) - program-error) + (signals-error (logbitp 0 0 0) program-error) + t) (deftest logbitp.error.4 - (classify-error (logbitp -1 0)) - type-error) + (signals-error (logbitp -1 0) type-error) + t) (deftest logbitp.error.5 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logbitp 0 ',x))) 'type-error)) + (eval `(signals-error (logbitp 0 ',x) type-error))) collect x) nil) +;;; Non-error tests + (deftest logbitp.1 (loop for x in *integers* unless (if (logbitp 0 x) (oddp x) (evenp x)) diff --git a/ansi-tests/logcount.lsp b/ansi-tests/logcount.lsp index 6831337..071903b 100644 --- a/ansi-tests/logcount.lsp +++ b/ansi-tests/logcount.lsp @@ -5,21 +5,25 @@ (in-package :cl-test) +;;; Error tests + (deftest logcount.error.1 - (classify-error (logcount)) - program-error) + (signals-error (logcount) program-error) + t) (deftest logcount.error.2 - (classify-error (logcount 0 nil)) - program-error) + (signals-error (logcount 0 nil) program-error) + t) (deftest logcount.error.3 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logcount ',x))) 'type-error)) + (eval `(signals-error (logcount ',x) type-error))) collect x) nil) +;;; Non-error tests + (deftest logcount.1 (logcount 0) 0) diff --git a/ansi-tests/logeqv.lsp b/ansi-tests/logeqv.lsp index 0a7432b..032755e 100644 --- a/ansi-tests/logeqv.lsp +++ b/ansi-tests/logeqv.lsp @@ -7,20 +7,23 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logeqv.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logeqv ',x))) 'type-error)) + (eval `(signals-error (logeqv ',x) type-error))) collect x) nil) (deftest logeqv.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logeqv 0 ',x))) 'type-error)) + (eval `(signals-error (logeqv 0 ',x) type-error))) collect x) nil) +;;; Non-error tests (deftest logeqv.1 (logeqv) diff --git a/ansi-tests/logical-pathname.lsp b/ansi-tests/logical-pathname.lsp index a401efd..683dec5 100644 --- a/ansi-tests/logical-pathname.lsp +++ b/ansi-tests/logical-pathname.lsp @@ -18,9 +18,8 @@ unless (or (stringp x) (typep x 'stream) (typep x 'logical-pathname) - (eq - (eval `(classify-error (logical-pathname ',x))) - 'type-error)) + (eval `(signals-error (logical-pathname ',x) + type-error))) collect x) nil) diff --git a/ansi-tests/logior.lsp b/ansi-tests/logior.lsp index 18ae9cf..7e9bec8 100644 --- a/ansi-tests/logior.lsp +++ b/ansi-tests/logior.lsp @@ -9,20 +9,23 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logior.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logior ',x))) 'type-error)) + (eval `(signals-error (logior ',x) type-error))) collect x) nil) (deftest logior.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logior 0 ',x))) 'type-error)) + (eval `(signals-error (logior 0 ',x) type-error))) collect x) nil) +;;; Non-error tests (deftest logior.1 (logior) diff --git a/ansi-tests/lognand.lsp b/ansi-tests/lognand.lsp index 58cc508..94740f9 100644 --- a/ansi-tests/lognand.lsp +++ b/ansi-tests/lognand.lsp @@ -7,31 +7,35 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest lognand.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (lognand ',x 0))) 'type-error)) + (eval `(signals-error (lognand ',x 0) type-error))) collect x) nil) (deftest lognand.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (lognand 0 ',x))) 'type-error)) + (eval `(signals-error (lognand 0 ',x) type-error))) collect x) nil) (deftest lognand.error.3 - (classify-error (lognand)) - program-error) + (signals-error (lognand) program-error) + t) (deftest lognand.error.4 - (classify-error (lognand 0)) - program-error) + (signals-error (lognand 0) program-error) + t) (deftest lognand.error.5 - (classify-error (lognand 1 2 3)) - program-error) + (signals-error (lognand 1 2 3) program-error) + t) + +;;; Non-error tests (deftest lognand.1 (lognand 0 0) diff --git a/ansi-tests/lognor.lsp b/ansi-tests/lognor.lsp index dfde754..58b8853 100644 --- a/ansi-tests/lognor.lsp +++ b/ansi-tests/lognor.lsp @@ -7,31 +7,35 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest lognor.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (lognor ',x 0))) 'type-error)) + (eval `(signals-error (lognor ',x 0) type-error))) collect x) nil) (deftest lognor.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (lognor 0 ',x))) 'type-error)) + (eval `(signals-error (lognor 0 ',x) type-error))) collect x) nil) (deftest lognor.error.3 - (classify-error (lognor)) - program-error) + (signals-error (lognor) program-error) + t) (deftest lognor.error.4 - (classify-error (lognor 0)) - program-error) + (signals-error (lognor 0) program-error) + t) (deftest lognor.error.5 - (classify-error (lognor 1 2 3)) - program-error) + (signals-error (lognor 1 2 3) program-error) + t) + +;;; Non-error tests (deftest lognor.1 (lognor 0 0) diff --git a/ansi-tests/lognot.lsp b/ansi-tests/lognot.lsp index 5deba39..de05eb2 100644 --- a/ansi-tests/lognot.lsp +++ b/ansi-tests/lognot.lsp @@ -7,20 +7,24 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest lognot.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (lognot ',x))) 'type-error)) + (eval `(signals-error (lognot ',x) type-error))) collect x) nil) (deftest lognot.error.2 - (classify-error (lognot)) - program-error) + (signals-error (lognot) program-error) + t) (deftest lognot.error.3 - (classify-error (lognot 0 0)) - program-error) + (signals-error (lognot 0 0) program-error) + t) + +;;; Non-error tests (deftest lognot.1 (lognot 0) diff --git a/ansi-tests/logorc1.lsp b/ansi-tests/logorc1.lsp index 3be8cad..6f57832 100644 --- a/ansi-tests/logorc1.lsp +++ b/ansi-tests/logorc1.lsp @@ -7,31 +7,35 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logorc1.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logorc1 ',x 0))) 'type-error)) + (eval `(signals-error (logorc1 ',x 0) type-error))) collect x) nil) (deftest logorc1.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logorc1 0 ',x))) 'type-error)) + (eval `(signals-error (logorc1 0 ',x) type-error))) collect x) nil) (deftest logorc1.error.3 - (classify-error (logorc1)) - program-error) + (signals-error (logorc1) program-error) + t) (deftest logorc1.error.4 - (classify-error (logorc1 0)) - program-error) + (signals-error (logorc1 0) program-error) + t) (deftest logorc1.error.5 - (classify-error (logorc1 1 2 3)) - program-error) + (signals-error (logorc1 1 2 3) program-error) + t) + +;;; Non-error tests (deftest logorc1.1 (logorc1 0 0) diff --git a/ansi-tests/logorc2.lsp b/ansi-tests/logorc2.lsp index eee8555..52c5a0c 100644 --- a/ansi-tests/logorc2.lsp +++ b/ansi-tests/logorc2.lsp @@ -7,31 +7,35 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logorc2.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logorc2 ',x 0))) 'type-error)) + (eval `(signals-error (logorc2 ',x 0) type-error))) collect x) nil) (deftest logorc2.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logorc2 0 ',x))) 'type-error)) + (eval `(signals-error (logorc2 0 ',x) type-error))) collect x) nil) (deftest logorc2.error.3 - (classify-error (logorc2)) - program-error) + (signals-error (logorc2) program-error) + t) (deftest logorc2.error.4 - (classify-error (logorc2 0)) - program-error) + (signals-error (logorc2 0) program-error) + t) (deftest logorc2.error.5 - (classify-error (logorc2 1 2 3)) - program-error) + (signals-error (logorc2 1 2 3) program-error) + t) + +;;; Non-error tests (deftest logorc2.1 (logorc2 0 0) diff --git a/ansi-tests/logtest.lsp b/ansi-tests/logtest.lsp index 138ec4a..96392f0 100644 --- a/ansi-tests/logtest.lsp +++ b/ansi-tests/logtest.lsp @@ -5,32 +5,36 @@ (in-package :cl-test) +;;; Error tests + (deftest logtest.error.1 - (classify-error (logtest)) - program-error) + (signals-error (logtest) program-error) + t) (deftest logtest.error.2 - (classify-error (logtest 0)) - program-error) + (signals-error (logtest 0) program-error) + t) (deftest logtest.error.3 - (classify-error (logtest 0 0 nil)) - program-error) + (signals-error (logtest 0 0 nil) program-error) + t) (deftest logtest.error.4 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logtest ',x -1))) 'type-error)) + (eval `(signals-error (logtest ',x -1) type-error))) collect x) nil) (deftest logtest.error.5 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logtest -1 ',x))) 'type-error)) + (eval `(signals-error (logtest -1 ',x) type-error))) collect x) nil) +;;; Non-error tests + (deftest logtest.1 (loop for x = (logand (random-fixnum) (random-fixnum)) for y = (logand (random-fixnum) (random-fixnum)) diff --git a/ansi-tests/logxor.lsp b/ansi-tests/logxor.lsp index 14c2384..5d65d46 100644 --- a/ansi-tests/logxor.lsp +++ b/ansi-tests/logxor.lsp @@ -7,21 +7,25 @@ (compile-and-load "numbers-aux.lsp") +;;; Error tests + (deftest logxor.error.1 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logxor ',x))) 'type-error)) + (eval `(signals-error (logxor ',x) type-error))) collect x) nil) (deftest logxor.error.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (eval `(classify-error (logxor 0 ',x))) 'type-error)) + (eval `(signals-error (logxor 0 ',x) type-error))) collect x) nil) +;;; Non-error tests + (deftest logxor.1 (logxor) 0) diff --git a/ansi-tests/loop.lsp b/ansi-tests/loop.lsp index 026a541..ce501bc 100644 --- a/ansi-tests/loop.lsp +++ b/ansi-tests/loop.lsp @@ -65,22 +65,19 @@ (let ((mfn (macro-function 'loop-finish env))) (cond ((not mfn) '(return-from done :fail1)) - ((not (eqt (eval `(classify-error (funcall ,mfn))) - 'program-error)) + ((not (eval `(signals-error (funcall ,mfn) + program-error))) '(return-from done :fail2)) - ((not (eqt (eval `(classify-error (funcall ,mfn - '(loop-finish)))) - 'program-error)) + ((not (eval `(signals-error (funcall ,mfn + '(loop-finish)) + program-error))) '(return-from done :fail3)) - ((not (eqt (eval `(classify-error (funcall ,mfn - '(loop-finish) - nil nil))) - 'program-error)) + ((not (eval `(signals-error (funcall ,mfn + '(loop-finish) + nil nil) + program-error))) '(return-from done :fail4)) (t '(return-from done :good)))))) (%m)))) :good) - - - \ No newline at end of file diff --git a/ansi-tests/loop10.lsp b/ansi-tests/loop10.lsp index 3198e85..74a6ffb 100644 --- a/ansi-tests/loop10.lsp +++ b/ansi-tests/loop10.lsp @@ -60,18 +60,20 @@ 4.0) (deftest loop.10.9 - (classify-error + (signals-error (loop with foo = 10 for x in '(a b c) count x into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.10.10 - (classify-error + (signals-error (loop with foo = 10 for x in '(a b c) counting x into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (declaim (special *loop-count-var*)) @@ -184,18 +186,20 @@ 10 100) (deftest loop.10.37 - (classify-error + (signals-error (loop with foo = 100 for i from 1 to 10 maximize i into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.10.38 - (classify-error + (signals-error (loop with foo = 100 for i from 1 to 10 maximizing i into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.10.39 @@ -286,18 +290,20 @@ 4 100) (deftest loop.10.57 - (classify-error + (signals-error (loop with foo = 100 for i from 1 to 10 minimize i into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.10.58 - (classify-error + (signals-error (loop with foo = 100 for i from 1 to 10 minimizing i into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.10.58a (loop for x in '(1 2 3) minimize (return 10)) @@ -400,18 +406,20 @@ 10 100) (deftest loop.10.85 - (classify-error + (signals-error (loop with foo = 100 for i from 1 to 4 sum i into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.10.86 - (classify-error + (signals-error (loop with foo = 100 for i from 1 to 4 summing i into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.10.87 (loop for i from 1 to 4 diff --git a/ansi-tests/loop12.lsp b/ansi-tests/loop12.lsp index edc3f61..4069c67 100644 --- a/ansi-tests/loop12.lsp +++ b/ansi-tests/loop12.lsp @@ -152,46 +152,52 @@ ;;; Error cases (deftest loop.12.error.50 - (classify-error + (signals-error (loop for i from 1 to 10 collect i - always (< i 20))) - program-error) + always (< i 20)) + program-error) + t) (deftest loop.12.error.50a - (classify-error + (signals-error (loop for i from 1 to 10 always (< i 20) - collect i)) - program-error) + collect i) + program-error) + t) (deftest loop.12.error.51 - (classify-error + (signals-error (loop for i from 1 to 10 collect i - never (> i 20))) - program-error) + never (> i 20)) + program-error) + t) (deftest loop.12.error.51a - (classify-error + (signals-error (loop for i from 1 to 10 never (> i 20) - collect i)) - program-error) + collect i) + program-error) + t) (deftest loop.12.error.52 - (classify-error + (signals-error (loop for i from 1 to 10 collect i - thereis (> i 20))) - program-error) + thereis (> i 20)) + program-error) + t) (deftest loop.12.error.52a - (classify-error + (signals-error (loop for i from 1 to 10 thereis (> i 20) - collect i)) - program-error) + collect i) + program-error) + t) ;;; Non-error cases diff --git a/ansi-tests/loop2.lsp b/ansi-tests/loop2.lsp index f93c566..79f7397 100644 --- a/ansi-tests/loop2.lsp +++ b/ansi-tests/loop2.lsp @@ -16,8 +16,9 @@ 2) (deftest loop.2.3 - (classify-error (loop for x in '(a . b) collect x)) - type-error) + (signals-error (loop for x in '(a . b) collect x) + type-error) + t) (deftest loop.2.4 (let ((x nil)) @@ -73,15 +74,17 @@ (3 7 11)) (deftest loop.2.14 - (classify-error + (signals-error (loop for x in '(a b c) - for x in '(d e f) collect x)) - program-error) + for x in '(d e f) collect x) + program-error) + t) (deftest loop.2.15 - (classify-error - (loop for (x . x) in '((a b) (c d)) collect x)) - program-error) + (signals-error + (loop for (x . x) in '((a b) (c d)) collect x) + program-error) + t) (deftest loop.2.16 (loop for nil in nil do (return t)) diff --git a/ansi-tests/loop3.lsp b/ansi-tests/loop3.lsp index 44ccd03..7b7a0d8 100644 --- a/ansi-tests/loop3.lsp +++ b/ansi-tests/loop3.lsp @@ -72,15 +72,16 @@ (3 7 11)) (deftest loop.3.14 - (classify-error + (signals-error (loop for x on '(a b c) - for x on '(d e f) collect x)) - program-error) + for x on '(d e f) collect x) + program-error) + t) (deftest loop.3.15 - (classify-error - (loop for (x . x) on '((a b) (c d)) collect x)) - program-error) + (signals-error (loop for (x . x) on '((a b) (c d)) collect x) + program-error) + t) (deftest loop.3.16 (loop for nil on nil do (return t)) diff --git a/ansi-tests/loop4.lsp b/ansi-tests/loop4.lsp index bd0f7e1..5edc3b2 100644 --- a/ansi-tests/loop4.lsp +++ b/ansi-tests/loop4.lsp @@ -39,19 +39,22 @@ ;;; Error cases (deftest loop.4.6 - (classify-error + (signals-error (loop for (x . x) = '(nil nil nil) - until x count t)) - program-error) + until x count t) + program-error) + t) (deftest loop.4.7 - (classify-error* + (signals-error (macroexpand '(loop for (x . x) = '(nil nil nil) - until x count t))) - program-error) + until x count t)) + program-error) + t) (deftest loop.4.8 - (classify-error* + (signals-error (macroexpand '(loop for x = '(nil nil nil) - for x = 1 count x until t))) - program-error) + for x = 1 count x until t)) + program-error) + t) diff --git a/ansi-tests/loop5.lsp b/ansi-tests/loop5.lsp index d5f2a8c..2ba42dd 100644 --- a/ansi-tests/loop5.lsp +++ b/ansi-tests/loop5.lsp @@ -147,26 +147,31 @@ ;;; Error cases (deftest loop.5.error.1 - (classify-error - (loop for (e . e) across (vector '(x . y) '(u . v)) collect e)) - program-error) + (signals-error + (loop for (e . e) across (vector '(x . y) '(u . v)) collect e) + program-error) + t) (deftest loop.5.error.2 - (classify-error + (signals-error (loop for e across (vector '(x . y) '(u . v)) - for e from 1 to 5 collect e)) - program-error) + for e from 1 to 5 collect e) + program-error) + t) (deftest loop.5.error.3 - (classify-error* - (macroexpand - '(loop for (e . e) across (vector '(x . y) '(u . v)) collect e))) - program-error) + (signals-error + (macroexpand + '(loop for (e . e) across (vector '(x . y) '(u . v)) collect e)) + program-error) + t) (deftest loop.5.error.4 - (classify-error* + (signals-error (macroexpand '(loop for e across (vector '(x . y) '(u . v)) - for e from 1 to 5 collect e))) - program-error) + for e from 1 to 5 collect e)) + program-error) + t) + diff --git a/ansi-tests/loop6.lsp b/ansi-tests/loop6.lsp index 3dc4123..f84d993 100644 --- a/ansi-tests/loop6.lsp +++ b/ansi-tests/loop6.lsp @@ -256,39 +256,40 @@ ;;; Error tests (deftest loop.6.error.1 - (classify-error + (signals-error (loop for k from 1 to 10 for k being the hash-keys of *loop.6.hash.1* - count t)) - program-error) + count t) + program-error) + t) (deftest loop.6.error.2 - (classify-error + (signals-error (loop for k being the hash-keys of *loop.6.hash.1* for k from 1 to 10 - count t)) - program-error) + count t) + program-error) + t) (deftest loop.6.error.3 - (classify-error + (signals-error (loop for (k . k) being the hash-keys of *loop.6.hash.3* - count t)) - program-error) + count t) + program-error) + t) (deftest loop.6.error.4 - (classify-error + (signals-error (loop for k being the hash-keys of *loop.6.hash.3* using (hash-value k) - count t)) - program-error) + count t) + program-error) + t) (deftest loop.6.error.5 - (classify-error + (signals-error (loop for k being the hash-values of *loop.6.hash.3* using (hash-key k) - count t)) - program-error) - - - - + count t) + program-error) + t) diff --git a/ansi-tests/loop7.lsp b/ansi-tests/loop7.lsp index 4547d6c..cabe240 100644 --- a/ansi-tests/loop7.lsp +++ b/ansi-tests/loop7.lsp @@ -126,23 +126,28 @@ (deftest loop.7.18 (let () (ignore-errors (delete-package "LOOP.MISSING.PACKAGE")) - (classify-error - (loop for x being each symbol of "LOOP.MISSING.PACKAGE" collect x))) - package-error) + (signals-error + (loop for x being each symbol of "LOOP.MISSING.PACKAGE" collect x) + package-error)) + t) (deftest loop.7.19 (let () (ignore-errors (delete-package "LOOP.MISSING.PACKAGE")) - (classify-error - (loop for x being each present-symbol of "LOOP.MISSING.PACKAGE" collect x))) - package-error) + (signals-error + (loop for x being each present-symbol of "LOOP.MISSING.PACKAGE" + collect x) + package-error)) + t) (deftest loop.7.20 (let () (ignore-errors (delete-package "LOOP.MISSING.PACKAGE")) - (classify-error - (loop for x being each external-symbol of "LOOP.MISSING.PACKAGE" collect x))) - package-error) + (signals-error + (loop for x being each external-symbol of "LOOP.MISSING.PACKAGE" + collect x) + package-error)) + t) ;;; NIL d-var-specs diff --git a/ansi-tests/loop8.lsp b/ansi-tests/loop8.lsp index 5866429..22e8df3 100644 --- a/ansi-tests/loop8.lsp +++ b/ansi-tests/loop8.lsp @@ -129,13 +129,15 @@ ;;; I am interpreting the spec as ruling out the latter as well. (deftest loop.8.error.1 - (classify-error + (signals-error (loop with a = 1 - and a = 2 return a)) - program-error) + and a = 2 return a) + program-error) + t) (deftest loop.8.error.2 - (classify-error + (signals-error (loop with a = 1 - with a = 2 return a)) - program-error) + with a = 2 return a) + program-error) + t) diff --git a/ansi-tests/loop9.lsp b/ansi-tests/loop9.lsp index fbf9478..e4b3376 100644 --- a/ansi-tests/loop9.lsp +++ b/ansi-tests/loop9.lsp @@ -60,18 +60,20 @@ (2 5 7 10 12 15 17 20)) (deftest loop.9.10 - (classify-error + (signals-error (loop with foo = '(a b) for x in '(c d) collect x into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.9.11 - (classify-error + (signals-error (loop with foo = '(a b) for x in '(c d) collecting x into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.9.12 (let ((foo '(a b))) @@ -126,18 +128,20 @@ (a a 1 b b 2 c c 3 d d 4)) (deftest loop.9.27 - (classify-error + (signals-error (loop with foo = '(a b) for x in '(c d) append (list x) into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.9.28 - (classify-error + (signals-error (loop with foo = '(a b) for x in '(c d) appending (list x) into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) ;;; NCONC, NCONCING @@ -185,18 +189,20 @@ (a a 1 b b 2 c c 3 d d 4)) (deftest loop.9.37 - (classify-error + (signals-error (loop with foo = '(a b) for x in '(c d) nconc (list x) into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) (deftest loop.9.38 - (classify-error + (signals-error (loop with foo = '(a b) for x in '(c d) nconcing (list x) into foo - finally (return foo))) - program-error) + finally (return foo)) + program-error) + t) ;;; Combinations -- GitLab