Mercurial > hg > xemacs-beta
annotate tests/automated/lisp-tests.el @ 5374:d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
src/ChangeLog addition:
2011-03-15 Aidan Kehoe <kehoea@parhasard.net>
* config.h.in (SUPPORT_CONFOUNDING_FUNCTIONS): New #define,
equivalent NEED_TO_HANDLE_21_4_CODE by default, describing whether
this XEmacs should support the old-eq, old-equal and related
functions and byte codes.
* bytecode.c (UNUSED):
Only interpret old-eq, old-equal, old-memq if
SUPPORT_CONFOUNDING_FUNCTIONS is defined.
* data.c:
Move Fold_eq to fns.c with the rest of the Fold_* functions.
* fns.c:
* fns.c (Fmemq):
* fns.c (memq_no_quit):
* fns.c (assoc_no_quit):
* fns.c (Frassq):
* fns.c (Fequal):
* fns.c (Fold_equal):
* fns.c (syms_of_fns):
Group old-eq, old-equal, old-memq etc together, surround them with
#ifdef SUPPORT_CONFOUNDING_FUNCTIONS.
lisp/ChangeLog addition:
2011-03-15 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el:
Don't generate the old-eq, old-memq, old-equal bytecodes any more,
but keep the information about them around for the sake of the
disassembler.
man/ChangeLog addition:
2011-03-15 Aidan Kehoe <kehoea@parhasard.net>
* lispref/objects.texi (Character Type):
* lispref/objects.texi (Equality Predicates):
No longer document `old-eq', `old-equal', they haven't been used
in years.
tests/ChangeLog addition:
2011-03-17 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Only test the various old-* function if old-eq is bound and a
subr.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Thu, 17 Mar 2011 20:13:00 +0000 |
| parents | 4c4b96b13f70 |
| children | 97ac18bd1fa3 ac37a5f7e5be |
| rev | line source |
|---|---|
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1 ;; Copyright (C) 1998 Free Software Foundation, Inc. -*- coding: iso-8859-1 -*- |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2 ;; Copyright (C) 2010 Ben Wing. |
| 428 | 3 |
| 4 ;; Author: Martin Buchholz <martin@xemacs.org> | |
| 5 ;; Maintainer: Martin Buchholz <martin@xemacs.org> | |
| 6 ;; Created: 1998 | |
| 7 ;; Keywords: tests | |
| 8 | |
| 9 ;; This file is part of XEmacs. | |
| 10 | |
| 11 ;; XEmacs is free software; you can redistribute it and/or modify it | |
| 12 ;; under the terms of the GNU General Public License as published by | |
| 13 ;; the Free Software Foundation; either version 2, or (at your option) | |
| 14 ;; any later version. | |
| 15 | |
| 16 ;; XEmacs is distributed in the hope that it will be useful, but | |
| 17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 19 ;; General Public License for more details. | |
| 20 | |
| 21 ;; You should have received a copy of the GNU General Public License | |
| 22 ;; along with XEmacs; see the file COPYING. If not, write to the Free | |
| 23 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | |
| 24 ;; 02111-1307, USA. | |
| 25 | |
| 26 ;;; Synched up with: Not in FSF. | |
| 27 | |
| 28 ;;; Commentary: | |
| 29 | |
| 30 ;;; Test basic Lisp engine functionality | |
| 31 ;;; See test-harness.el for instructions on how to run these tests. | |
| 32 | |
| 33 (eval-when-compile | |
| 34 (condition-case nil | |
| 35 (require 'test-harness) | |
| 36 (file-error | |
| 37 (push "." load-path) | |
| 38 (when (and (boundp 'load-file-name) (stringp load-file-name)) | |
| 39 (push (file-name-directory load-file-name) load-path)) | |
| 40 (require 'test-harness)))) | |
| 41 | |
| 42 (Check-Error wrong-number-of-arguments (setq setq-test-foo)) | |
| 43 (Check-Error wrong-number-of-arguments (setq setq-test-foo 1 setq-test-bar)) | |
| 44 (Check-Error wrong-number-of-arguments (setq-default setq-test-foo)) | |
| 45 (Check-Error wrong-number-of-arguments (setq-default setq-test-foo 1 setq-test-bar)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
46 (Assert (eq (setq) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
47 (Assert (eq (setq-default) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
48 (Assert (eq (setq setq-test-foo 42) 42)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
49 (Assert (eq (setq-default setq-test-foo 42) 42)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
50 (Assert (eq (setq setq-test-foo 42 setq-test-bar 99) 99)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
51 (Assert (eq (setq-default setq-test-foo 42 setq-test-bar 99) 99)) |
| 428 | 52 |
| 53 (macrolet ((test-setq (expected-result &rest body) | |
| 54 `(progn | |
| 55 (defun test-setq-fun () ,@body) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
56 (Assert (eq ,expected-result (test-setq-fun))) |
| 428 | 57 (byte-compile 'test-setq-fun) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
58 (Assert (eq ,expected-result (test-setq-fun)))))) |
| 428 | 59 (test-setq nil (setq)) |
| 60 (test-setq nil (setq-default)) | |
| 61 (test-setq 42 (setq test-setq-var 42)) | |
| 62 (test-setq 42 (setq-default test-setq-var 42)) | |
| 63 (test-setq 42 (setq test-setq-bar 99 test-setq-var 42)) | |
| 64 (test-setq 42 (setq-default test-setq-bar 99 test-setq-var 42)) | |
| 65 ) | |
| 66 | |
| 67 (let ((my-vector [1 2 3 4]) | |
| 68 (my-bit-vector (bit-vector 1 0 1 0)) | |
| 69 (my-string "1234") | |
| 70 (my-list '(1 2 3 4))) | |
| 71 | |
| 72 ;;(Assert (fooooo)) ;; Generate Other failure | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
73 ;;(Assert (eq 1 2)) ;; Generate Assertion failure |
| 428 | 74 |
| 75 (dolist (sequence (list my-vector my-bit-vector my-string my-list)) | |
| 76 (Assert (sequencep sequence)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
77 (Assert (eq 4 (length sequence)))) |
| 428 | 78 |
| 79 (dolist (array (list my-vector my-bit-vector my-string)) | |
| 80 (Assert (arrayp array))) | |
| 81 | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
82 (Assert (eq (elt my-vector 0) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
83 (Assert (eq (elt my-bit-vector 0) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
84 (Assert (eq (elt my-string 0) ?1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
85 (Assert (eq (elt my-list 0) 1)) |
| 428 | 86 |
| 87 (fillarray my-vector 5) | |
| 88 (fillarray my-bit-vector 1) | |
| 89 (fillarray my-string ?5) | |
| 90 | |
| 91 (dolist (array (list my-vector my-bit-vector)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
92 (Assert (eq 4 (length array)))) |
| 428 | 93 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
94 (Assert (eq (elt my-vector 0) 5)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
95 (Assert (eq (elt my-bit-vector 0) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
96 (Assert (eq (elt my-string 0) ?5)) |
| 428 | 97 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
98 (Assert (eq (elt my-vector 3) 5)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
99 (Assert (eq (elt my-bit-vector 3) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
100 (Assert (eq (elt my-string 3) ?5)) |
| 428 | 101 |
| 102 (fillarray my-bit-vector 0) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
103 (Assert (eq 4 (length my-bit-vector))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
104 (Assert (eq (elt my-bit-vector 2) 0)) |
| 428 | 105 ) |
| 106 | |
| 107 (defun make-circular-list (length) | |
| 108 "Create evil emacs-crashing circular list of length LENGTH" | |
| 109 (let ((circular-list | |
| 110 (make-list | |
| 111 length | |
| 112 'you-are-trapped-in-a-twisty-maze-of-cons-cells-all-alike))) | |
| 113 (setcdr (last circular-list) circular-list) | |
| 114 circular-list)) | |
| 115 | |
| 116 ;;----------------------------------------------------- | |
| 117 ;; Test `nconc' | |
| 118 ;;----------------------------------------------------- | |
| 119 (defun make-list-012 () (list 0 1 2)) | |
| 120 | |
| 121 (Check-Error wrong-type-argument (nconc 'foo nil)) | |
| 122 | |
| 123 (dolist (length '(1 2 3 4 1000 2000)) | |
| 124 (Check-Error circular-list (nconc (make-circular-list length) 'foo)) | |
| 125 (Check-Error circular-list (nconc '(1 . 2) (make-circular-list length) 'foo)) | |
| 126 (Check-Error circular-list (nconc '(1 . 2) '(3 . 4) (make-circular-list length) 'foo))) | |
| 127 | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
128 (Assert (eq (nconc) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
129 (Assert (eq (nconc nil) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
130 (Assert (eq (nconc nil nil) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
131 (Assert (eq (nconc nil nil nil) nil)) |
| 428 | 132 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
133 (let ((x (make-list-012))) (Assert (eq (nconc nil x) x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
134 (let ((x (make-list-012))) (Assert (eq (nconc x nil) x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
135 (let ((x (make-list-012))) (Assert (eq (nconc nil x nil) x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
136 (let ((x (make-list-012))) (Assert (eq (nconc x) x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
137 (let ((x (make-list-012))) (Assert (eq (nconc x (make-circular-list 3)) x))) |
| 428 | 138 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
139 (Assert (equal (nconc '(1 . 2) '(3 . 4) '(5 . 6)) '(1 3 5 . 6))) |
| 428 | 140 |
| 141 (let ((y (nconc (make-list-012) nil (list 3 4 5) nil))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
142 (Assert (eq (length y) 6)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
143 (Assert (eq (nth 3 y) 3))) |
| 428 | 144 |
| 145 ;;----------------------------------------------------- | |
| 146 ;; Test `last' | |
| 147 ;;----------------------------------------------------- | |
| 148 (Check-Error wrong-type-argument (last 'foo)) | |
| 149 (Check-Error wrong-number-of-arguments (last)) | |
| 150 (Check-Error wrong-number-of-arguments (last '(1 2) 1 1)) | |
| 151 (Check-Error circular-list (last (make-circular-list 1))) | |
| 152 (Check-Error circular-list (last (make-circular-list 2000))) | |
| 153 (let ((x (list 0 1 2 3))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
154 (Assert (eq (last nil) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
155 (Assert (eq (last x 0) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
156 (Assert (eq (last x ) (cdddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
157 (Assert (eq (last x 1) (cdddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
158 (Assert (eq (last x 2) (cddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
159 (Assert (eq (last x 3) (cdr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
160 (Assert (eq (last x 4) x)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
161 (Assert (eq (last x 9) x)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
162 (Assert (eq (last '(1 . 2) 0) 2)) |
| 428 | 163 ) |
| 164 | |
| 165 ;;----------------------------------------------------- | |
| 166 ;; Test `butlast' and `nbutlast' | |
| 167 ;;----------------------------------------------------- | |
| 168 (Check-Error wrong-type-argument (butlast 'foo)) | |
| 169 (Check-Error wrong-type-argument (nbutlast 'foo)) | |
| 170 (Check-Error wrong-number-of-arguments (butlast)) | |
| 171 (Check-Error wrong-number-of-arguments (nbutlast)) | |
| 172 (Check-Error wrong-number-of-arguments (butlast '(1 2) 1 1)) | |
| 173 (Check-Error wrong-number-of-arguments (nbutlast '(1 2) 1 1)) | |
| 174 (Check-Error circular-list (butlast (make-circular-list 1))) | |
| 175 (Check-Error circular-list (nbutlast (make-circular-list 1))) | |
| 176 (Check-Error circular-list (butlast (make-circular-list 2000))) | |
| 177 (Check-Error circular-list (nbutlast (make-circular-list 2000))) | |
| 178 | |
| 179 (let* ((x (list 0 1 2 3)) | |
| 180 (y (butlast x)) | |
| 181 (z (nbutlast x))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
182 (Assert (eq z x)) |
| 428 | 183 (Assert (not (eq y x))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
184 (Assert (equal y '(0 1 2))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
185 (Assert (equal z y))) |
| 428 | 186 |
| 187 (let* ((x (list 0 1 2 3 4)) | |
| 188 (y (butlast x 2)) | |
| 189 (z (nbutlast x 2))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
190 (Assert (eq z x)) |
| 428 | 191 (Assert (not (eq y x))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
192 (Assert (equal y '(0 1 2))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
193 (Assert (equal z y))) |
| 428 | 194 |
| 195 (let* ((x (list 0 1 2 3)) | |
| 196 (y (butlast x 0)) | |
| 197 (z (nbutlast x 0))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
198 (Assert (eq z x)) |
| 428 | 199 (Assert (not (eq y x))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
200 (Assert (equal y '(0 1 2 3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
201 (Assert (equal z y))) |
| 428 | 202 |
|
5285
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
203 (let* ((x (list* 0 1 2 3 4 5 6.0 ?7 ?8 (vector 'a 'b 'c))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
204 (y (butlast x 0)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
205 (z (nbutlast x 0))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
206 (Assert (eq z x)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
207 (Assert (not (eq y x))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
208 (Assert (equal y '(0 1 2 3 4 5 6.0 ?7 ?8))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
209 (Assert (equal z y))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
210 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
211 (Assert (eq (butlast '(x)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
212 (Assert (eq (nbutlast '(x)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
213 (Assert (eq (butlast '()) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
214 (Assert (eq (nbutlast '()) nil)) |
| 428 | 215 |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
216 (when (featurep 'bignum) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
217 (let* ((x (list* 0 1 2 3 4 5 6.0 ?7 ?8 (vector 'a 'b 'c))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
218 (y (butlast x (* 2 most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
219 (z (nbutlast x (* 3 most-positive-fixnum)))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
220 (Assert (eq nil y) "checking butlast with a large bignum gives nil") |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
221 (Assert (eq nil z) "checking nbutlast with a large bignum gives nil") |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
222 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
223 (nbutlast x (1- most-negative-fixnum)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
224 "checking nbutlast with a negative bignum errors"))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
225 |
| 428 | 226 ;;----------------------------------------------------- |
| 227 ;; Test `copy-list' | |
| 228 ;;----------------------------------------------------- | |
| 229 (Check-Error wrong-type-argument (copy-list 'foo)) | |
| 230 (Check-Error wrong-number-of-arguments (copy-list)) | |
| 231 (Check-Error wrong-number-of-arguments (copy-list '(1 2) 1)) | |
| 232 (Check-Error circular-list (copy-list (make-circular-list 1))) | |
| 233 (Check-Error circular-list (copy-list (make-circular-list 2000))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
234 (Assert (eq '() (copy-list '()))) |
| 428 | 235 (dolist (x '((1) (1 2) (1 2 3) (1 2 . 3))) |
| 236 (let ((y (copy-list x))) | |
| 237 (Assert (and (equal x y) (not (eq x y)))))) | |
| 238 | |
| 239 ;;----------------------------------------------------- | |
|
5285
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
240 ;; Test `ldiff' |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
241 ;;----------------------------------------------------- |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
242 (Check-Error wrong-type-argument (ldiff 'foo pi)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
243 (Check-Error wrong-number-of-arguments (ldiff)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
244 (Check-Error wrong-number-of-arguments (ldiff '(1 2))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
245 (Check-Error circular-list (ldiff (make-circular-list 1) nil)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
246 (Check-Error circular-list (ldiff (make-circular-list 2000) nil)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
247 (Assert (eq '() (ldiff '() pi))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
248 (dolist (x '((1) (1 2) (1 2 3) (1 2 . 3))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
249 (let ((y (ldiff x nil))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
250 (Assert (and (equal x y) (not (eq x y)))))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
251 |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
252 (let* ((vector (vector 'foo)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
253 (dotted `(1 2 3 ,pi 40 50 . ,vector)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
254 (dotted-pi `(1 2 3 . ,pi)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
255 without-vector without-pi) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
256 (Assert (equal dotted (ldiff dotted nil)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
257 "checking ldiff handles dotted lists properly") |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
258 (Assert (equal (butlast dotted 0) (ldiff dotted vector)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
259 "checking ldiff discards dotted elements correctly") |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
260 (Assert (equal (butlast dotted-pi 0) (ldiff dotted-pi (* 4 (atan 1)))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
261 "checking ldiff handles float equivalence correctly")) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
262 |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
263 ;;----------------------------------------------------- |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
264 ;; Test `tailp' |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
265 ;;----------------------------------------------------- |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
266 (Check-Error wrong-type-argument (tailp pi 'foo)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
267 (Check-Error wrong-number-of-arguments (tailp)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
268 (Check-Error wrong-number-of-arguments (tailp '(1 2))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
269 (Check-Error circular-list (tailp nil (make-circular-list 1))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
270 (Check-Error circular-list (tailp nil (make-circular-list 2000))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
271 (Assert (null (tailp pi '())) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
272 "checking pi is not a tail of the list nil") |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
273 (Assert (tailp 3 '(1 2 . 3)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
274 "checking #'tailp works with a dotted integer.") |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
275 (Assert (tailp pi `(1 2 . ,(* 4 (atan 1)))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
276 "checking tailp works with non-eq dotted floats.") |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
277 (let ((list (make-list 2048 nil))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
278 (Assert (tailp (nthcdr 2000 list) (nconc list list)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
279 "checking #'tailp succeeds with circular LIST containing SUBLIST")) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
280 |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
281 ;;----------------------------------------------------- |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
282 ;; Test `endp' |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
283 ;;----------------------------------------------------- |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
284 (Check-Error wrong-type-argument (endp 'foo)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
285 (Check-Error wrong-number-of-arguments (endp)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
286 (Check-Error wrong-number-of-arguments (endp '(1 2) 'foo)) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
287 (Assert (endp nil) "checking nil is recognized as the end of a list") |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
288 (Assert (not (endp (list 200 200 4 0 9))) |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
289 "checking a cons is not recognised as the end of a list") |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
290 |
|
99de5fd48e87
Tighten up Common Lisp compatibility, #'butlast, #'nbutlast, #'tailp, #'ldiff
Aidan Kehoe <kehoea@parhasard.net>
parents:
5283
diff
changeset
|
291 ;;----------------------------------------------------- |
| 428 | 292 ;; Arithmetic operations |
| 293 ;;----------------------------------------------------- | |
| 294 | |
| 295 ;; Test `+' | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
296 (Assert (eq (+ 1 1) 2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
297 (Assert (= (+ 1.0 1.0) 2.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
298 (Assert (= (+ 1.0 3.0 0.0) 4.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
299 (Assert (= (+ 1 1.0) 2.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
300 (Assert (= (+ 1.0 1) 2.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
301 (Assert (= (+ 1.0 1 1) 3.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
302 (Assert (= (+ 1 1 1.0) 3.0)) |
| 1983 | 303 (if (featurep 'bignum) |
| 304 (progn | |
| 305 (Assert (bignump (1+ most-positive-fixnum))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
306 (Assert (eq most-positive-fixnum (1- (1+ most-positive-fixnum)))) |
| 1983 | 307 (Assert (bignump (+ most-positive-fixnum 1))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
308 (Assert (eq most-positive-fixnum (- (+ most-positive-fixnum 1) 1))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
309 (Assert (= (1+ most-positive-fixnum) (- most-negative-fixnum))) |
| 1983 | 310 (Assert (zerop (+ (* 3 most-negative-fixnum) (* 3 most-positive-fixnum) |
| 311 3)))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
312 (Assert (eq (1+ most-positive-fixnum) most-negative-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
313 (Assert (eq (+ most-positive-fixnum 1) most-negative-fixnum))) |
| 1983 | 314 |
| 315 (when (featurep 'ratio) | |
| 316 (let ((threefourths (read "3/4")) | |
| 317 (threehalfs (read "3/2")) | |
| 318 (bigpos (div (+ most-positive-fixnum 2) (1+ most-positive-fixnum))) | |
| 319 (bigneg (div (+ most-positive-fixnum 2) most-negative-fixnum)) | |
| 320 (negone (div (1+ most-positive-fixnum) most-negative-fixnum))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
321 (Assert (= negone -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
322 (Assert (= threehalfs (+ threefourths threefourths))) |
| 1983 | 323 (Assert (zerop (+ bigpos bigneg))))) |
| 428 | 324 |
| 325 ;; Test `-' | |
| 326 (Check-Error wrong-number-of-arguments (-)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
327 (Assert (eq (- 0) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
328 (Assert (eq (- 1) -1)) |
| 428 | 329 (dolist (one `(1 1.0 ?\1 ,(Int-to-Marker 1))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
330 (Assert (= (+ 1 one) 2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
331 (Assert (= (+ one) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
332 (Assert (= (+ one) one)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
333 (Assert (= (- one) -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
334 (Assert (= (- one one) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
335 (Assert (= (- one one one) -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
336 (Assert (= (- 0 one) -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
337 (Assert (= (- 0 one one) -2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
338 (Assert (= (+ one 1) 2)) |
| 428 | 339 (dolist (zero '(0 0.0 ?\0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
340 (Assert (= (+ 1 zero) 1) zero) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
341 (Assert (= (+ zero 1) 1) zero) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
342 (Assert (= (- zero) zero) zero) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
343 (Assert (= (- zero) 0) zero) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
344 (Assert (= (- zero zero) 0) zero) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
345 (Assert (= (- zero one one) -2) zero))) |
| 428 | 346 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
347 (Assert (= (- 1.5 1) .5)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
348 (Assert (= (- 1 1.5) (- .5))) |
| 428 | 349 |
| 1983 | 350 (if (featurep 'bignum) |
| 351 (progn | |
| 352 (Assert (bignump (1- most-negative-fixnum))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
353 (Assert (eq most-negative-fixnum (1+ (1- most-negative-fixnum)))) |
| 1983 | 354 (Assert (bignump (- most-negative-fixnum 1))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
355 (Assert (eq most-negative-fixnum (+ (- most-negative-fixnum 1) 1))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
356 (Assert (= (1- most-negative-fixnum) (- 0 most-positive-fixnum 2))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
357 (Assert (eq (- (- most-positive-fixnum most-negative-fixnum) |
| 1983 | 358 (* 2 most-positive-fixnum)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
359 1))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
360 (Assert (eq (1- most-negative-fixnum) most-positive-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
361 (Assert (eq (- most-negative-fixnum 1) most-positive-fixnum))) |
| 1983 | 362 |
| 363 (when (featurep 'ratio) | |
| 364 (let ((threefourths (read "3/4")) | |
| 365 (threehalfs (read "3/2")) | |
| 366 (bigpos (div (+ most-positive-fixnum 2) (1+ most-positive-fixnum))) | |
| 367 (bigneg (div most-positive-fixnum most-negative-fixnum)) | |
| 368 (negone (div (1+ most-positive-fixnum) most-negative-fixnum))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
369 (Assert (= (- negone) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
370 (Assert (= threefourths (- threehalfs threefourths))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
371 (Assert (= (- bigpos bigneg) 2)))) |
| 428 | 372 |
| 373 ;; Test `/' | |
| 374 | |
| 375 ;; Test division by zero errors | |
| 376 (dolist (zero '(0 0.0 ?\0)) | |
| 377 (Check-Error arith-error (/ zero)) | |
| 378 (dolist (n1 `(42 42.0 ?\042 ,(Int-to-Marker 42))) | |
| 379 (Check-Error arith-error (/ n1 zero)) | |
| 380 (dolist (n2 `(3 3.0 ?\03 ,(Int-to-Marker 3))) | |
| 381 (Check-Error arith-error (/ n1 n2 zero))))) | |
| 382 | |
| 383 ;; Other tests for `/' | |
| 384 (Check-Error wrong-number-of-arguments (/)) | |
| 385 (let (x) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
386 (Assert (= (/ (setq x 2)) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
387 (Assert (= (/ (setq x 2.0)) 0.5))) |
| 428 | 388 |
| 389 (dolist (six '(6 6.0 ?\06)) | |
| 390 (dolist (two '(2 2.0 ?\02)) | |
| 391 (dolist (three '(3 3.0 ?\03)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
392 (Assert (= (/ six two) three) (list six two three))))) |
| 428 | 393 |
| 394 (dolist (three '(3 3.0 ?\03)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
395 (Assert (= (/ three 2.0) 1.5) three)) |
| 428 | 396 (dolist (two '(2 2.0 ?\02)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
397 (Assert (= (/ 3.0 two) 1.5) two)) |
| 428 | 398 |
| 1983 | 399 (when (featurep 'bignum) |
| 400 (let* ((million 1000000) | |
| 401 (billion (* million 1000)) ;; American, not British, billion | |
| 402 (trillion (* billion 1000))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
403 (Assert (= (/ billion 1000) (/ trillion million) million 1000000.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
404 (Assert (= (/ billion -1000) (/ trillion (- million)) (- million))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
405 (Assert (= (/ trillion 1000) billion 1000000000.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
406 (Assert (= (/ trillion -1000) (- billion) -1000000000.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
407 (Assert (= (/ trillion 10) (* 100 billion) 100000000000.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
408 (Assert (= (/ (- trillion) 10) (* -100 billion) -100000000000.0)))) |
| 1983 | 409 |
| 410 (when (featurep 'ratio) | |
| 411 (let ((half (div 1 2)) | |
| 412 (fivefourths (div 5 4)) | |
| 413 (fivehalfs (div 5 2))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
414 (Assert (= half (read "3000000000/6000000000"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
415 (Assert (= (/ fivehalfs fivefourths) 2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
416 (Assert (= (/ fivefourths fivehalfs) half)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
417 (Assert (= (- half) (read "-3000000000/6000000000"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
418 (Assert (= (/ fivehalfs (- fivefourths)) -2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
419 (Assert (= (/ (- fivefourths) fivehalfs) (- half))))) |
| 1983 | 420 |
| 428 | 421 ;; Test `*' |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
422 (Assert (= 1 (*))) |
| 428 | 423 |
| 424 (dolist (one `(1 1.0 ?\01 ,(Int-to-Marker 1))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
425 (Assert (= 1 (* one)) one)) |
| 428 | 426 |
| 427 (dolist (two '(2 2.0 ?\02)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
428 (Assert (= 2 (* two)) two)) |
| 428 | 429 |
| 430 (dolist (six '(6 6.0 ?\06)) | |
| 431 (dolist (two '(2 2.0 ?\02)) | |
| 432 (dolist (three '(3 3.0 ?\03)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
433 (Assert (= (* three two) six) (list three two six))))) |
| 428 | 434 |
| 435 (dolist (three '(3 3.0 ?\03)) | |
| 436 (dolist (two '(2 2.0 ?\02)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
437 (Assert (= (* 1.5 two) three) (list two three)) |
| 428 | 438 (dolist (five '(5 5.0 ?\05)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
439 (Assert (= 30 (* five two three)) (list five two three))))) |
| 428 | 440 |
| 1983 | 441 (when (featurep 'bignum) |
| 442 (let ((64K 65536)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
443 (Assert (= (* 64K 64K) (read "4294967296"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
444 (Assert (= (* (- 64K) 64K) (read "-4294967296"))) |
| 1983 | 445 (Assert (/= (* -1 most-negative-fixnum) most-negative-fixnum)))) |
| 446 | |
| 447 (when (featurep 'ratio) | |
| 448 (let ((half (div 1 2)) | |
| 449 (fivefourths (div 5 4)) | |
| 450 (twofifths (div 2 5))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
451 (Assert (= (* fivefourths twofifths) half)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
452 (Assert (= (* half twofifths) (read "3/15"))))) |
| 1983 | 453 |
| 428 | 454 ;; Test `+' |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
455 (Assert (= 0 (+))) |
| 428 | 456 |
| 457 (dolist (one `(1 1.0 ?\01 ,(Int-to-Marker 1))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
458 (Assert (= 1 (+ one)) one)) |
| 428 | 459 |
| 460 (dolist (two '(2 2.0 ?\02)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
461 (Assert (= 2 (+ two)) two)) |
| 428 | 462 |
| 463 (dolist (five '(5 5.0 ?\05)) | |
| 464 (dolist (two '(2 2.0 ?\02)) | |
| 465 (dolist (three '(3 3.0 ?\03)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
466 (Assert (= (+ three two) five) (list three two five)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
467 (Assert (= 10 (+ five two three)) (list five two three))))) |
| 428 | 468 |
| 469 ;; Test `max', `min' | |
| 470 (dolist (one `(1 1.0 ?\01 ,(Int-to-Marker 1))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
471 (Assert (= one (max one)) one) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
472 (Assert (= one (max one one)) one) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
473 (Assert (= one (max one one one)) one) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
474 (Assert (= one (min one)) one) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
475 (Assert (= one (min one one)) one) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
476 (Assert (= one (min one one one)) one) |
| 428 | 477 (dolist (two `(2 2.0 ?\02 ,(Int-to-Marker 2))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
478 (Assert (= one (min one two)) (list one two)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
479 (Assert (= one (min one two two)) (list one two)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
480 (Assert (= one (min two two one)) (list one two)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
481 (Assert (= two (max one two)) (list one two)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
482 (Assert (= two (max one two two)) (list one two)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
483 (Assert (= two (max two two one)) (list one two)))) |
| 428 | 484 |
| 1983 | 485 (when (featurep 'bignum) |
| 486 (let ((big (1+ most-positive-fixnum)) | |
| 487 (small (1- most-negative-fixnum))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
488 (Assert (= big (max 1 1000000.0 most-positive-fixnum big))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
489 (Assert (= small (min -1 -1000000.0 most-negative-fixnum small))))) |
| 1983 | 490 |
| 491 (when (featurep 'ratio) | |
| 492 (let* ((big (1+ most-positive-fixnum)) | |
| 493 (small (1- most-negative-fixnum)) | |
| 494 (bigr (div (* 5 (1+ most-positive-fixnum)) 4)) | |
| 495 (smallr (- bigr))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
496 (Assert (= bigr (max 1 1000000.0 most-positive-fixnum big bigr))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
497 (Assert (= smallr (min -1 -1000000.0 most-negative-fixnum small smallr))))) |
| 1983 | 498 |
| 446 | 499 ;; The byte compiler has special handling for these constructs: |
| 500 (let ((three 3) (five 5)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
501 (Assert (= (+ three five 1) 9)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
502 (Assert (= (+ 1 three five) 9)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
503 (Assert (= (+ three five -1) 7)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
504 (Assert (= (+ -1 three five) 7)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
505 (Assert (= (+ three 1) 4)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
506 (Assert (= (+ three -1) 2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
507 (Assert (= (+ -1 three) 2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
508 (Assert (= (+ -1 three) 2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
509 (Assert (= (- three five 1) -3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
510 (Assert (= (- 1 three five) -7)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
511 (Assert (= (- three five -1) -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
512 (Assert (= (- -1 three five) -9)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
513 (Assert (= (- three 1) 2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
514 (Assert (= (- three 2 1) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
515 (Assert (= (- 2 three 1) -2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
516 (Assert (= (- three -1) 4)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
517 (Assert (= (- three 0) 3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
518 (Assert (= (- three 0 five) -2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
519 (Assert (= (- 0 three 0 five) -8)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
520 (Assert (= (- 0 three five) -8)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
521 (Assert (= (* three 2) 6)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
522 (Assert (= (* three -1 five) -15)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
523 (Assert (= (* three 1 five) 15)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
524 (Assert (= (* three 0 five) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
525 (Assert (= (* three 2 five) 30)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
526 (Assert (= (/ three 1) 3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
527 (Assert (= (/ three -1) -3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
528 (Assert (= (/ (* five five) 2 2) 6)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
529 (Assert (= (/ 64 five 2) 6))) |
| 446 | 530 |
| 531 | |
| 428 | 532 ;;----------------------------------------------------- |
| 533 ;; Logical bit-twiddling operations | |
| 534 ;;----------------------------------------------------- | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
535 (Assert (= (logxor) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
536 (Assert (= (logior) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
537 (Assert (= (logand) -1)) |
| 428 | 538 |
| 539 (Check-Error wrong-type-argument (logxor 3.0)) | |
| 540 (Check-Error wrong-type-argument (logior 3.0)) | |
| 541 (Check-Error wrong-type-argument (logand 3.0)) | |
| 542 | |
| 543 (dolist (three '(3 ?\03)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
544 (Assert (eq 3 (logand three)) three) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
545 (Assert (eq 3 (logxor three)) three) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
546 (Assert (eq 3 (logior three)) three) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
547 (Assert (eq 3 (logand three three)) three) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
548 (Assert (eq 0 (logxor three three)) three) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
549 (Assert (eq 3 (logior three three))) three) |
| 428 | 550 |
| 551 (dolist (one `(1 ?\01 ,(Int-to-Marker 1))) | |
| 552 (dolist (two '(2 ?\02)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
553 (Assert (eq 0 (logand one two)) (list one two)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
554 (Assert (eq 3 (logior one two)) (list one two)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
555 (Assert (eq 3 (logxor one two)) (list one two))) |
| 428 | 556 (dolist (three '(3 ?\03)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
557 (Assert (eq 1 (logand one three)) (list one three)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
558 (Assert (eq 3 (logior one three)) (list one three)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
559 (Assert (eq 2 (logxor one three)) (list one three)))) |
| 428 | 560 |
| 561 ;;----------------------------------------------------- | |
| 562 ;; Test `%', mod | |
| 563 ;;----------------------------------------------------- | |
| 564 (Check-Error wrong-number-of-arguments (%)) | |
| 565 (Check-Error wrong-number-of-arguments (% 1)) | |
| 566 (Check-Error wrong-number-of-arguments (% 1 2 3)) | |
| 567 | |
| 568 (Check-Error wrong-number-of-arguments (mod)) | |
| 569 (Check-Error wrong-number-of-arguments (mod 1)) | |
| 570 (Check-Error wrong-number-of-arguments (mod 1 2 3)) | |
| 571 | |
| 572 (Check-Error wrong-type-argument (% 10.0 2)) | |
| 573 (Check-Error wrong-type-argument (% 10 2.0)) | |
| 574 | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
575 (flet ((test1 (x) (Assert (eql x (+ (% x 17) (* (/ x 17) 17))) x)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
576 (test2 (x) (Assert (eql (- x) (+ (% (- x) 17) (* (/ (- x) 17) 17))) x)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
577 (test3 (x) (Assert (eql x (+ (% (- x) 17) (* (/ (- x) 17) 17))) x)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
578 (test4 (x) (Assert (eql (% x -17) (- (% (- x) 17))) x)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
579 (test5 (x) (Assert (eql (% x -17) (% (- x) 17))) x)) |
| 2056 | 580 (test1 most-negative-fixnum) |
| 581 (if (featurep 'bignum) | |
| 2075 | 582 (progn |
| 583 (test2 most-negative-fixnum) | |
| 584 (test4 most-negative-fixnum)) | |
| 585 (test3 most-negative-fixnum) | |
| 586 (test5 most-negative-fixnum)) | |
| 2056 | 587 (test1 most-positive-fixnum) |
| 588 (test2 most-positive-fixnum) | |
| 589 (test4 most-positive-fixnum) | |
| 590 (dotimes (j 30) | |
| 591 (let ((x (random))) | |
| 592 (if (eq x most-negative-fixnum) (setq x (1+ x))) | |
| 593 (if (eq x most-positive-fixnum) (setq x (1- x))) | |
| 594 (test1 x) | |
| 595 (test2 x) | |
| 596 (test4 x)))) | |
| 428 | 597 |
| 598 (macrolet | |
| 599 ((division-test (seven) | |
| 600 `(progn | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
601 (Assert (eq (% ,seven 2) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
602 (Assert (eq (% ,seven -2) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
603 (Assert (eq (% (- ,seven) 2) -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
604 (Assert (eq (% (- ,seven) -2) -1)) |
| 428 | 605 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
606 (Assert (eq (% ,seven 4) 3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
607 (Assert (eq (% ,seven -4) 3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
608 (Assert (eq (% (- ,seven) 4) -3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
609 (Assert (eq (% (- ,seven) -4) -3)) |
| 428 | 610 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
611 (Assert (eq (% 35 ,seven) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
612 (Assert (eq (% -35 ,seven) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
613 (Assert (eq (% 35 (- ,seven)) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
614 (Assert (eq (% -35 (- ,seven)) 0)) |
| 428 | 615 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
616 (Assert (eq (mod ,seven 2) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
617 (Assert (eq (mod ,seven -2) -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
618 (Assert (eq (mod (- ,seven) 2) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
619 (Assert (eq (mod (- ,seven) -2) -1)) |
| 428 | 620 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
621 (Assert (eq (mod ,seven 4) 3)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
622 (Assert (eq (mod ,seven -4) -1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
623 (Assert (eq (mod (- ,seven) 4) 1)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
624 (Assert (eq (mod (- ,seven) -4) -3)) |
| 428 | 625 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
626 (Assert (eq (mod 35 ,seven) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
627 (Assert (eq (mod -35 ,seven) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
628 (Assert (eq (mod 35 (- ,seven)) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
629 (Assert (eq (mod -35 (- ,seven)) 0)) |
| 428 | 630 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
631 (Assert (= (mod ,seven 2.0) 1.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
632 (Assert (= (mod ,seven -2.0) -1.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
633 (Assert (= (mod (- ,seven) 2.0) 1.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
634 (Assert (= (mod (- ,seven) -2.0) -1.0)) |
| 428 | 635 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
636 (Assert (= (mod ,seven 4.0) 3.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
637 (Assert (= (mod ,seven -4.0) -1.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
638 (Assert (= (mod (- ,seven) 4.0) 1.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
639 (Assert (= (mod (- ,seven) -4.0) -3.0)) |
| 428 | 640 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
641 (Assert (eq (% 0 ,seven) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
642 (Assert (eq (% 0 (- ,seven)) 0)) |
| 428 | 643 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
644 (Assert (eq (mod 0 ,seven) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
645 (Assert (eq (mod 0 (- ,seven)) 0)) |
| 428 | 646 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
647 (Assert (= (mod 0.0 ,seven) 0.0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
648 (Assert (= (mod 0.0 (- ,seven)) 0.0))))) |
| 428 | 649 |
| 650 (division-test 7) | |
| 651 (division-test ?\07) | |
| 652 (division-test (Int-to-Marker 7))) | |
| 653 | |
| 1983 | 654 (when (featurep 'bignum) |
| 655 (let ((big (+ (* 7 most-positive-fixnum 6))) | |
| 656 (negbig (- (* 7 most-negative-fixnum 6)))) | |
| 657 (= (% big (1+ most-positive-fixnum)) most-positive-fixnum) | |
| 658 (= (% negbig (1- most-negative-fixnum)) most-negative-fixnum) | |
| 659 (= (mod big (1+ most-positive-fixnum)) most-positive-fixnum) | |
| 660 (= (mod negbig (1- most-negative-fixnum)) most-negative-fixnum))) | |
| 428 | 661 |
| 662 ;;----------------------------------------------------- | |
| 663 ;; Arithmetic comparison operations | |
| 664 ;;----------------------------------------------------- | |
| 665 (Check-Error wrong-number-of-arguments (=)) | |
| 666 (Check-Error wrong-number-of-arguments (<)) | |
| 667 (Check-Error wrong-number-of-arguments (>)) | |
| 668 (Check-Error wrong-number-of-arguments (<=)) | |
| 669 (Check-Error wrong-number-of-arguments (>=)) | |
| 670 (Check-Error wrong-number-of-arguments (/=)) | |
| 671 | |
| 672 ;; One argument always yields t | |
| 673 (loop for x in `(1 1.0 ,(Int-to-Marker 1) ?z) do | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
674 (Assert (eq t (= x)) x) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
675 (Assert (eq t (< x)) x) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
676 (Assert (eq t (> x)) x) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
677 (Assert (eq t (>= x)) x) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
678 (Assert (eq t (<= x)) x) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
679 (Assert (eq t (/= x)) x) |
| 428 | 680 ) |
| 681 | |
| 682 ;; Type checking | |
| 683 (Check-Error wrong-type-argument (= 'foo 1)) | |
| 684 (Check-Error wrong-type-argument (<= 'foo 1)) | |
| 685 (Check-Error wrong-type-argument (>= 'foo 1)) | |
| 686 (Check-Error wrong-type-argument (< 'foo 1)) | |
| 687 (Check-Error wrong-type-argument (> 'foo 1)) | |
| 688 (Check-Error wrong-type-argument (/= 'foo 1)) | |
| 689 | |
| 690 ;; Meat | |
| 691 (dolist (one `(1 1.0 ,(Int-to-Marker 1) ?\01)) | |
| 692 (dolist (two '(2 2.0 ?\02)) | |
| 2056 | 693 (Assert (< one two) (list one two)) |
| 694 (Assert (<= one two) (list one two)) | |
| 695 (Assert (<= two two) two) | |
| 696 (Assert (> two one) (list one two)) | |
| 697 (Assert (>= two one) (list one two)) | |
| 698 (Assert (>= two two) two) | |
| 699 (Assert (/= one two) (list one two)) | |
| 700 (Assert (not (/= two two)) two) | |
| 701 (Assert (not (< one one)) one) | |
| 702 (Assert (not (> one one)) one) | |
| 703 (Assert (<= one one two two) (list one two)) | |
| 704 (Assert (not (< one one two two)) (list one two)) | |
| 705 (Assert (>= two two one one) (list one two)) | |
| 706 (Assert (not (> two two one one)) (list one two)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
707 (Assert (= one one one) one) |
| 2056 | 708 (Assert (not (= one one one two)) (list one two)) |
| 709 (Assert (not (/= one two one)) (list one two)) | |
| 428 | 710 )) |
| 711 | |
| 712 (dolist (one `(1 1.0 ,(Int-to-Marker 1) ?\01)) | |
| 713 (dolist (two '(2 2.0 ?\02)) | |
| 2056 | 714 (Assert (< one two) (list one two)) |
| 715 (Assert (<= one two) (list one two)) | |
| 716 (Assert (<= two two) two) | |
| 717 (Assert (> two one) (list one two)) | |
| 718 (Assert (>= two one) (list one two)) | |
| 719 (Assert (>= two two) two) | |
| 720 (Assert (/= one two) (list one two)) | |
| 721 (Assert (not (/= two two)) two) | |
| 722 (Assert (not (< one one)) one) | |
| 723 (Assert (not (> one one)) one) | |
| 724 (Assert (<= one one two two) (list one two)) | |
| 725 (Assert (not (< one one two two)) (list one two)) | |
| 726 (Assert (>= two two one one) (list one two)) | |
| 727 (Assert (not (> two two one one)) (list one two)) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
728 (Assert (= one one one) one) |
| 2056 | 729 (Assert (not (= one one one two)) (list one two)) |
| 730 (Assert (not (/= one two one)) (list one two)) | |
| 428 | 731 )) |
| 732 | |
| 733 ;; ad-hoc | |
| 734 (Assert (< 1 2)) | |
| 735 (Assert (< 1 2 3 4 5 6)) | |
| 736 (Assert (not (< 1 1))) | |
| 737 (Assert (not (< 2 1))) | |
| 738 | |
| 739 | |
| 740 (Assert (not (< 1 1))) | |
| 741 (Assert (< 1 2 3 4 5 6)) | |
| 742 (Assert (<= 1 2 3 4 5 6)) | |
| 743 (Assert (<= 1 2 3 4 5 6 6)) | |
| 744 (Assert (not (< 1 2 3 4 5 6 6))) | |
| 745 (Assert (<= 1 1)) | |
| 746 | |
| 747 (Assert (not (eq (point) (point-marker)))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
748 (Assert (= 1 (Int-to-Marker 1))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
749 (Assert (= (point) (point-marker))) |
| 428 | 750 |
| 1983 | 751 (when (featurep 'bignum) |
| 752 (let ((big1 (1+ most-positive-fixnum)) | |
| 753 (big2 (* 10 most-positive-fixnum)) | |
| 754 (small1 (1- most-negative-fixnum)) | |
| 755 (small2 (* 10 most-negative-fixnum))) | |
| 756 (Assert (< small2 small1 most-negative-fixnum most-positive-fixnum big1 | |
| 757 big2)) | |
| 758 (Assert (<= small2 small1 most-negative-fixnum most-positive-fixnum big1 | |
| 759 big2)) | |
| 760 (Assert (> big2 big1 most-positive-fixnum most-negative-fixnum small1 | |
| 761 small2)) | |
| 762 (Assert (>= big2 big1 most-positive-fixnum most-negative-fixnum small1 | |
| 763 small2)) | |
| 764 (Assert (/= small2 small1 most-negative-fixnum most-positive-fixnum big1 | |
| 765 big2)))) | |
| 766 | |
| 767 (when (featurep 'ratio) | |
| 768 (let ((big1 (div (* 10 most-positive-fixnum) 4)) | |
| 769 (big2 (div (* 5 most-positive-fixnum) 2)) | |
| 770 (big3 (div (* 7 most-positive-fixnum) 2)) | |
| 771 (small1 (div (* 10 most-negative-fixnum) 4)) | |
| 772 (small2 (div (* 5 most-negative-fixnum) 2)) | |
| 773 (small3 (div (* 7 most-negative-fixnum) 2))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
774 (Assert (= big1 big2)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
775 (Assert (= small1 small2)) |
| 1983 | 776 (Assert (< small3 small1 most-negative-fixnum most-positive-fixnum big1 |
| 777 big3)) | |
| 778 (Assert (<= small3 small2 small1 most-negative-fixnum most-positive-fixnum | |
| 779 big1 big2 big3)) | |
| 780 (Assert (> big3 big1 most-positive-fixnum most-negative-fixnum small1 | |
| 781 small3)) | |
| 782 (Assert (>= big3 big2 big1 most-positive-fixnum most-negative-fixnum | |
| 783 small1 small2 small3)) | |
| 784 (Assert (/= big3 big1 most-positive-fixnum most-negative-fixnum small1 | |
| 785 small3)))) | |
| 786 | |
| 428 | 787 ;;----------------------------------------------------- |
| 788 ;; testing list-walker functions | |
| 789 ;;----------------------------------------------------- | |
| 790 (macrolet | |
| 791 ((test-fun | |
| 792 (fun) | |
| 793 `(progn | |
| 794 (Check-Error wrong-number-of-arguments (,fun)) | |
| 795 (Check-Error wrong-number-of-arguments (,fun nil)) | |
|
5346
b4ef3128160c
Fix some testsuite failures, #'delete, #'delq, #'remove, #'remq.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5339
diff
changeset
|
796 (Check-Error (malformed-list wrong-type-argument) (,fun nil 1)) |
| 428 | 797 ,@(loop for n in '(1 2 2000) |
| 798 collect `(Check-Error circular-list (,fun 1 (make-circular-list ,n)))))) | |
|
5374
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
799 (test-funs (&rest funs) `(progn ,@(loop for fun in funs collect `(test-fun ,fun)))) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
800 (test-old-funs (&rest funs) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
801 `(when (and (fboundp 'old-eq) (subrp (symbol-function 'old-eq))) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
802 ,@(loop for fun in funs collect `(test-fun ,fun))))) |
|
5346
b4ef3128160c
Fix some testsuite failures, #'delete, #'delq, #'remove, #'remq.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5339
diff
changeset
|
803 (test-funs member* member memq |
|
b4ef3128160c
Fix some testsuite failures, #'delete, #'delq, #'remove, #'remq.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5339
diff
changeset
|
804 assoc* assoc assq |
|
b4ef3128160c
Fix some testsuite failures, #'delete, #'delq, #'remove, #'remq.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5339
diff
changeset
|
805 rassoc* rassoc rassq |
|
b4ef3128160c
Fix some testsuite failures, #'delete, #'delq, #'remove, #'remq.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5339
diff
changeset
|
806 delete* delete delq |
|
b4ef3128160c
Fix some testsuite failures, #'delete, #'delq, #'remove, #'remq.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5339
diff
changeset
|
807 remove* remove remq |
|
5374
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
808 remassoc remassq remrassoc remrassq) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
809 (test-old-funs old-member old-memq old-assoc old-assq old-rassoc old-rassq |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
810 old-delete old-delq)) |
| 428 | 811 |
| 812 (let ((x '((1 . 2) 3 (4 . 5)))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
813 (Assert (eq (assoc 1 x) (car x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
814 (Assert (eq (assq 1 x) (car x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
815 (Assert (eq (rassoc 1 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
816 (Assert (eq (rassq 1 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
817 (Assert (eq (assoc 2 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
818 (Assert (eq (assq 2 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
819 (Assert (eq (rassoc 2 x) (car x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
820 (Assert (eq (rassq 2 x) (car x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
821 (Assert (eq (assoc 3 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
822 (Assert (eq (assq 3 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
823 (Assert (eq (rassoc 3 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
824 (Assert (eq (rassq 3 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
825 (Assert (eq (assoc 4 x) (caddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
826 (Assert (eq (assq 4 x) (caddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
827 (Assert (eq (rassoc 4 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
828 (Assert (eq (rassq 4 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
829 (Assert (eq (assoc 5 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
830 (Assert (eq (assq 5 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
831 (Assert (eq (rassoc 5 x) (caddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
832 (Assert (eq (rassq 5 x) (caddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
833 (Assert (eq (assoc 6 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
834 (Assert (eq (assq 6 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
835 (Assert (eq (rassoc 6 x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
836 (Assert (eq (rassq 6 x) nil))) |
| 428 | 837 |
| 838 (let ((x '(("1" . "2") "3" ("4" . "5")))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
839 (Assert (eq (assoc "1" x) (car x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
840 (Assert (eq (assq "1" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
841 (Assert (eq (rassoc "1" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
842 (Assert (eq (rassq "1" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
843 (Assert (eq (assoc "2" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
844 (Assert (eq (assq "2" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
845 (Assert (eq (rassoc "2" x) (car x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
846 (Assert (eq (rassq "2" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
847 (Assert (eq (assoc "3" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
848 (Assert (eq (assq "3" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
849 (Assert (eq (rassoc "3" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
850 (Assert (eq (rassq "3" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
851 (Assert (eq (assoc "4" x) (caddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
852 (Assert (eq (assq "4" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
853 (Assert (eq (rassoc "4" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
854 (Assert (eq (rassq "4" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
855 (Assert (eq (assoc "5" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
856 (Assert (eq (assq "5" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
857 (Assert (eq (rassoc "5" x) (caddr x))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
858 (Assert (eq (rassq "5" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
859 (Assert (eq (assoc "6" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
860 (Assert (eq (assq "6" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
861 (Assert (eq (rassoc "6" x) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
862 (Assert (eq (rassq "6" x) nil))) |
| 428 | 863 |
| 864 (flet ((a () (list '(1 . 2) 3 '(4 . 5)))) | |
| 865 (Assert (let* ((x (a)) (y (remassoc 1 x))) (and (not (eq x y)) (equal y '(3 (4 . 5)))))) | |
| 866 (Assert (let* ((x (a)) (y (remassq 1 x))) (and (not (eq x y)) (equal y '(3 (4 . 5)))))) | |
| 867 (Assert (let* ((x (a)) (y (remrassoc 1 x))) (and (eq x y) (equal y (a))))) | |
| 868 (Assert (let* ((x (a)) (y (remrassq 1 x))) (and (eq x y) (equal y (a))))) | |
| 869 | |
| 870 (Assert (let* ((x (a)) (y (remassoc 2 x))) (and (eq x y) (equal y (a))))) | |
| 871 (Assert (let* ((x (a)) (y (remassq 2 x))) (and (eq x y) (equal y (a))))) | |
| 872 (Assert (let* ((x (a)) (y (remrassoc 2 x))) (and (not (eq x y)) (equal y '(3 (4 . 5)))))) | |
| 873 (Assert (let* ((x (a)) (y (remrassq 2 x))) (and (not (eq x y)) (equal y '(3 (4 . 5)))))) | |
| 874 | |
| 875 (Assert (let* ((x (a)) (y (remassoc 3 x))) (and (eq x y) (equal y (a))))) | |
| 876 (Assert (let* ((x (a)) (y (remassq 3 x))) (and (eq x y) (equal y (a))))) | |
| 877 (Assert (let* ((x (a)) (y (remrassoc 3 x))) (and (eq x y) (equal y (a))))) | |
| 878 (Assert (let* ((x (a)) (y (remrassq 3 x))) (and (eq x y) (equal y (a))))) | |
| 879 | |
| 880 (Assert (let* ((x (a)) (y (remassoc 4 x))) (and (eq x y) (equal y '((1 . 2) 3))))) | |
| 881 (Assert (let* ((x (a)) (y (remassq 4 x))) (and (eq x y) (equal y '((1 . 2) 3))))) | |
| 882 (Assert (let* ((x (a)) (y (remrassoc 4 x))) (and (eq x y) (equal y (a))))) | |
| 883 (Assert (let* ((x (a)) (y (remrassq 4 x))) (and (eq x y) (equal y (a))))) | |
| 884 | |
| 885 (Assert (let* ((x (a)) (y (remassoc 5 x))) (and (eq x y) (equal y (a))))) | |
| 886 (Assert (let* ((x (a)) (y (remassq 5 x))) (and (eq x y) (equal y (a))))) | |
| 887 (Assert (let* ((x (a)) (y (remrassoc 5 x))) (and (eq x y) (equal y '((1 . 2) 3))))) | |
| 888 (Assert (let* ((x (a)) (y (remrassq 5 x))) (and (eq x y) (equal y '((1 . 2) 3))))) | |
| 889 | |
| 890 (Assert (let* ((x (a)) (y (remassoc 6 x))) (and (eq x y) (equal y (a))))) | |
| 891 (Assert (let* ((x (a)) (y (remassq 6 x))) (and (eq x y) (equal y (a))))) | |
| 892 (Assert (let* ((x (a)) (y (remrassoc 6 x))) (and (eq x y) (equal y (a))))) | |
| 893 (Assert (let* ((x (a)) (y (remrassq 6 x))) (and (eq x y) (equal y (a))))) | |
| 894 (Assert (let* ((x (a)) (y (delete 3 x))) (and (eq x y) (equal y '((1 . 2) (4 . 5)))))) | |
| 895 (Assert (let* ((x (a)) (y (delq 3 x))) (and (eq x y) (equal y '((1 . 2) (4 . 5)))))) | |
| 896 (Assert (let* ((x (a)) (y (delete '(1 . 2) x))) (and (not (eq x y)) (equal y '(3 (4 . 5)))))) | |
| 897 (Assert (let* ((x (a)) (y (delq '(1 . 2) x))) (and (eq x y) (equal y (a))))) | |
|
5374
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
898 (when (and (fboundp 'old-eq) (subrp (symbol-function 'old-eq))) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
899 (Assert (let* ((x (a)) (y (old-delete '(1 . 2) x))) (and (not (eq x y)) (equal y '(3 (4 . 5)))))) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
900 (Assert (let* ((x (a)) (y (old-delq '(1 . 2) x))) (and (eq x y) (equal y (a))))) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
901 (Assert (let* ((x (a)) (y (old-delete 3 x))) (and (eq x y) (equal y '((1 . 2) (4 . 5)))))) |
|
d967d96ca043
Conditionalise the old-* functions and byte codes at compile time.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5370
diff
changeset
|
902 (Assert (let* ((x (a)) (y (old-delq 3 x))) (and (eq x y) (equal y '((1 . 2) (4 . 5)))))))) |
| 428 | 903 |
| 904 (flet ((a () (list '("1" . "2") "3" '("4" . "5")))) | |
| 905 (Assert (let* ((x (a)) (y (remassoc "1" x))) (and (not (eq x y)) (equal y '("3" ("4" . "5")))))) | |
| 906 (Assert (let* ((x (a)) (y (remassq "1" x))) (and (eq x y) (equal y (a))))) | |
| 907 (Assert (let* ((x (a)) (y (remrassoc "1" x))) (and (eq x y) (equal y (a))))) | |
| 908 (Assert (let* ((x (a)) (y (remrassq "1" x))) (and (eq x y) (equal y (a))))) | |
| 909 | |
| 910 (Assert (let* ((x (a)) (y (remassoc "2" x))) (and (eq x y) (equal y (a))))) | |
| 911 (Assert (let* ((x (a)) (y (remassq "2" x))) (and (eq x y) (equal y (a))))) | |
| 912 (Assert (let* ((x (a)) (y (remrassoc "2" x))) (and (not (eq x y)) (equal y '("3" ("4" . "5")))))) | |
| 913 (Assert (let* ((x (a)) (y (remrassq "2" x))) (and (eq x y) (equal y (a))))) | |
| 914 | |
| 915 (Assert (let* ((x (a)) (y (remassoc "3" x))) (and (eq x y) (equal y (a))))) | |
| 916 (Assert (let* ((x (a)) (y (remassq "3" x))) (and (eq x y) (equal y (a))))) | |
| 917 (Assert (let* ((x (a)) (y (remrassoc "3" x))) (and (eq x y) (equal y (a))))) | |
| 918 (Assert (let* ((x (a)) (y (remrassq "3" x))) (and (eq x y) (equal y (a))))) | |
| 919 | |
| 920 (Assert (let* ((x (a)) (y (remassoc "4" x))) (and (eq x y) (equal y '(("1" . "2") "3"))))) | |
| 921 (Assert (let* ((x (a)) (y (remassq "4" x))) (and (eq x y) (equal y (a))))) | |
| 922 (Assert (let* ((x (a)) (y (remrassoc "4" x))) (and (eq x y) (equal y (a))))) | |
| 923 (Assert (let* ((x (a)) (y (remrassq "4" x))) (and (eq x y) (equal y (a))))) | |
| 924 | |
| 925 (Assert (let* ((x (a)) (y (remassoc "5" x))) (and (eq x y) (equal y (a))))) | |
| 926 (Assert (let* ((x (a)) (y (remassq "5" x))) (and (eq x y) (equal y (a))))) | |
| 927 (Assert (let* ((x (a)) (y (remrassoc "5" x))) (and (eq x y) (equal y '(("1" . "2") "3"))))) | |
| 928 (Assert (let* ((x (a)) (y (remrassq "5" x))) (and (eq x y) (equal y (a))))) | |
| 929 | |
| 930 (Assert (let* ((x (a)) (y (remassoc "6" x))) (and (eq x y) (equal y (a))))) | |
| 931 (Assert (let* ((x (a)) (y (remassq "6" x))) (and (eq x y) (equal y (a))))) | |
| 932 (Assert (let* ((x (a)) (y (remrassoc "6" x))) (and (eq x y) (equal y (a))))) | |
| 933 (Assert (let* ((x (a)) (y (remrassq "6" x))) (and (eq x y) (equal y (a)))))) | |
| 934 | |
| 935 ;;----------------------------------------------------- | |
| 936 ;; function-max-args, function-min-args | |
| 937 ;;----------------------------------------------------- | |
| 938 (defmacro check-function-argcounts (fun min max) | |
| 939 `(progn | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
940 (Assert (eq (function-min-args ,fun) ,min)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
941 (Assert (eq (function-max-args ,fun) ,max)))) |
| 428 | 942 |
| 943 (check-function-argcounts 'prog1 1 nil) ; special form | |
| 944 (check-function-argcounts 'command-execute 1 3) ; normal subr | |
| 945 (check-function-argcounts 'funcall 1 nil) ; `MANY' subr | |
| 946 (check-function-argcounts 'garbage-collect 0 0) ; no args subr | |
| 947 | |
| 948 ;; Test interpreted and compiled functions | |
| 949 (loop for (arglist min max) in | |
| 950 '(((arg1 arg2 &rest args) 2 nil) | |
| 951 ((arg1 arg2 &optional arg3 arg4) 2 4) | |
| 952 ((arg1 arg2 &optional arg3 arg4 &rest args) 2 nil) | |
| 953 (() 0 0)) | |
| 954 do | |
| 955 (eval | |
| 956 `(progn | |
| 957 (defun test-fun ,arglist nil) | |
| 958 (check-function-argcounts '(lambda ,arglist nil) ,min ,max) | |
| 959 (check-function-argcounts (byte-compile '(lambda ,arglist nil)) ,min ,max)))) | |
| 960 | |
|
4575
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
961 ;; Test subr-arity. |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
962 (loop for (function-name arity) in |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
963 '((let (1 . unevalled)) |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
964 (prog1 (1 . unevalled)) |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
965 (list (0 . many)) |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
966 (type-of (1 . 1)) |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
967 (garbage-collect (0 . 0))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
968 do (Assert (equal (subr-arity (symbol-function function-name)) arity))) |
|
4575
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
969 |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
970 (Check-Error wrong-type-argument (subr-arity |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
971 (lambda () (message "Hi there!")))) |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
972 |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
973 (Check-Error wrong-type-argument (subr-arity nil)) |
|
eecd28508f4a
Add #'subr-arity, API taken from GNU, implementation our own.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4396
diff
changeset
|
974 |
| 428 | 975 ;;----------------------------------------------------- |
| 976 ;; Detection of cyclic variable indirection loops | |
| 977 ;;----------------------------------------------------- | |
| 978 (fset 'test-sym1 'test-sym1) | |
| 979 (Check-Error cyclic-function-indirection (test-sym1)) | |
| 980 | |
| 981 (fset 'test-sym1 'test-sym2) | |
| 982 (fset 'test-sym2 'test-sym1) | |
| 983 (Check-Error cyclic-function-indirection (test-sym1)) | |
| 984 (fmakunbound 'test-sym1) ; else macroexpand-internal infloops! | |
| 985 (fmakunbound 'test-sym2) | |
| 986 | |
| 987 ;;----------------------------------------------------- | |
| 988 ;; Test `type-of' | |
| 989 ;;----------------------------------------------------- | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
990 (Assert (eq (type-of load-path) 'cons)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
991 (Assert (eq (type-of obarray) 'vector)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
992 (Assert (eq (type-of 42) 'integer)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
993 (Assert (eq (type-of ?z) 'character)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
994 (Assert (eq (type-of "42") 'string)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
995 (Assert (eq (type-of 'foo) 'symbol)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
996 (Assert (eq (type-of (selected-device)) 'device)) |
| 428 | 997 |
| 998 ;;----------------------------------------------------- | |
| 999 ;; Test mapping functions | |
| 1000 ;;----------------------------------------------------- | |
| 1001 (Check-Error wrong-type-argument (mapcar #'identity (current-buffer))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1002 (Assert (equal (mapcar #'identity load-path) load-path)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1003 (Assert (equal (mapcar #'identity '(1 2 3)) '(1 2 3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1004 (Assert (equal (mapcar #'identity "123") '(?1 ?2 ?3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1005 (Assert (equal (mapcar #'identity [1 2 3]) '(1 2 3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1006 (Assert (equal (mapcar #'identity #*010) '(0 1 0))) |
| 428 | 1007 |
| 1008 (let ((z 0) (list (make-list 1000 1))) | |
| 1009 (mapc (lambda (x) (incf z x)) list) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1010 (Assert (eq 1000 z))) |
| 428 | 1011 |
| 1012 (Check-Error wrong-type-argument (mapvector #'identity (current-buffer))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1013 (Assert (equal (mapvector #'identity '(1 2 3)) [1 2 3])) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1014 (Assert (equal (mapvector #'identity "123") [?1 ?2 ?3])) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1015 (Assert (equal (mapvector #'identity [1 2 3]) [1 2 3])) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1016 (Assert (equal (mapvector #'identity #*010) [0 1 0])) |
| 428 | 1017 |
| 1018 (Check-Error wrong-type-argument (mapconcat #'identity (current-buffer) "foo")) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1019 (Assert (equal (mapconcat #'identity '("1" "2" "3") "|") "1|2|3")) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1020 (Assert (equal (mapconcat #'identity ["1" "2" "3"] "|") "1|2|3")) |
| 428 | 1021 |
| 434 | 1022 ;; The following 2 functions used to crash XEmacs via mapcar1(). |
| 1023 ;; We don't test the actual values of the mapcar, since they're undefined. | |
| 446 | 1024 (Assert |
| 434 | 1025 (let ((x (list (cons 1 1) (cons 2 2) (cons 3 3)))) |
| 1026 (mapcar | |
| 1027 (lambda (y) | |
| 1028 "Devious evil mapping function" | |
| 1029 (when (eq (car y) 2) ; go out onto a limb | |
| 1030 (setcdr x nil) ; cut it off behind us | |
| 1031 (garbage-collect)) ; are we riding a magic broomstick? | |
| 1032 (car y)) ; sorry, hard landing | |
| 1033 x))) | |
| 1034 | |
| 446 | 1035 (Assert |
| 434 | 1036 (let ((x (list (cons 1 1) (cons 2 2) (cons 3 3)))) |
| 1037 (mapcar | |
| 1038 (lambda (y) | |
| 1039 "Devious evil mapping function" | |
| 1040 (when (eq (car y) 1) | |
| 1041 (setcdr (cdr x) 42)) ; drop a brick wall onto the freeway | |
| 1042 (car y)) | |
| 1043 x))) | |
| 1044 | |
|
5355
70b15ac66ee5
Correct a bug with circularity checking in #'mapcar*, #'map, etc.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5353
diff
changeset
|
1045 (Assert |
|
70b15ac66ee5
Correct a bug with circularity checking in #'mapcar*, #'map, etc.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5353
diff
changeset
|
1046 (equal |
|
70b15ac66ee5
Correct a bug with circularity checking in #'mapcar*, #'map, etc.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5353
diff
changeset
|
1047 (let ((list (list pi))) (mapcar* #'cons [1 2 3 4] (nconc list list))) |
|
70b15ac66ee5
Correct a bug with circularity checking in #'mapcar*, #'map, etc.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5353
diff
changeset
|
1048 `((1 . ,pi) (2 . ,pi) (3 . ,pi) (4 . ,pi))) |
|
70b15ac66ee5
Correct a bug with circularity checking in #'mapcar*, #'map, etc.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5353
diff
changeset
|
1049 "checking mapcar* behaves correctly when only one arg is circular") |
|
70b15ac66ee5
Correct a bug with circularity checking in #'mapcar*, #'map, etc.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5353
diff
changeset
|
1050 |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1051 (Assert (eql |
|
5034
1b96882bdf37
Fix a multiple-value bug, mapcarX; correct a comment and a label name.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4906
diff
changeset
|
1052 (length (multiple-value-list |
|
1b96882bdf37
Fix a multiple-value bug, mapcarX; correct a comment and a label name.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4906
diff
changeset
|
1053 (car (mapcar #'(lambda (argument) (floor argument)) (list pi e))))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1054 1) |
|
5034
1b96882bdf37
Fix a multiple-value bug, mapcarX; correct a comment and a label name.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4906
diff
changeset
|
1055 "checking multiple values are correctly discarded in mapcar") |
|
1b96882bdf37
Fix a multiple-value bug, mapcarX; correct a comment and a label name.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4906
diff
changeset
|
1056 |
|
5299
28651c24b3f8
Error in #'list-length if LIST is dotted; check for this error with #'mapcar
Aidan Kehoe <kehoea@parhasard.net>
parents:
5295
diff
changeset
|
1057 (let ((malformed-list '(1 2 3 4 hi there . tail))) |
|
28651c24b3f8
Error in #'list-length if LIST is dotted; check for this error with #'mapcar
Aidan Kehoe <kehoea@parhasard.net>
parents:
5295
diff
changeset
|
1058 (Check-Error malformed-list (mapcar #'identity malformed-list)) |
|
28651c24b3f8
Error in #'list-length if LIST is dotted; check for this error with #'mapcar
Aidan Kehoe <kehoea@parhasard.net>
parents:
5295
diff
changeset
|
1059 (Check-Error malformed-list (map nil #'eq [1 2 3 4] |
|
28651c24b3f8
Error in #'list-length if LIST is dotted; check for this error with #'mapcar
Aidan Kehoe <kehoea@parhasard.net>
parents:
5295
diff
changeset
|
1060 malformed-list)) |
|
28651c24b3f8
Error in #'list-length if LIST is dotted; check for this error with #'mapcar
Aidan Kehoe <kehoea@parhasard.net>
parents:
5295
diff
changeset
|
1061 (Check-Error malformed-list (list-length malformed-list))) |
|
28651c24b3f8
Error in #'list-length if LIST is dotted; check for this error with #'mapcar
Aidan Kehoe <kehoea@parhasard.net>
parents:
5295
diff
changeset
|
1062 |
| 428 | 1063 ;;----------------------------------------------------- |
| 1064 ;; Test vector functions | |
| 1065 ;;----------------------------------------------------- | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1066 (Assert (equal [1 2 3] [1 2 3])) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1067 (Assert (equal [] [])) |
| 428 | 1068 (Assert (not (equal [1 2 3] []))) |
| 1069 (Assert (not (equal [1 2 3] [1 2 4]))) | |
| 1070 (Assert (not (equal [0 2 3] [1 2 3]))) | |
| 1071 (Assert (not (equal [1 2 3] [1 2 3 4]))) | |
| 1072 (Assert (not (equal [1 2 3 4] [1 2 3]))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1073 (Assert (equal (vector 1 2 3) [1 2 3])) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1074 (Assert (equal (make-vector 3 1) [1 1 1])) |
| 428 | 1075 |
| 1076 ;;----------------------------------------------------- | |
| 1077 ;; Test bit-vector functions | |
| 1078 ;;----------------------------------------------------- | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1079 (Assert (equal #*010 #*010)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1080 (Assert (equal #* #*)) |
| 428 | 1081 (Assert (not (equal #*010 #*011))) |
| 1082 (Assert (not (equal #*010 #*))) | |
| 1083 (Assert (not (equal #*110 #*010))) | |
| 1084 (Assert (not (equal #*010 #*0100))) | |
| 1085 (Assert (not (equal #*0101 #*010))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1086 (Assert (equal (bit-vector 0 1 0) #*010)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1087 (Assert (equal (make-bit-vector 3 1) #*111)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1088 (Assert (equal (make-bit-vector 3 0) #*000)) |
| 428 | 1089 |
| 1090 ;;----------------------------------------------------- | |
| 1091 ;; Test buffer-local variables used as (ugh!) function parameters | |
| 1092 ;;----------------------------------------------------- | |
| 1093 (make-local-variable 'test-emacs-buffer-local-variable) | |
| 1094 (byte-compile | |
| 1095 (defun test-emacs-buffer-local-parameter (test-emacs-buffer-local-variable) | |
| 1096 (setq test-emacs-buffer-local-variable nil))) | |
| 1097 (test-emacs-buffer-local-parameter nil) | |
| 1098 | |
| 1099 ;;----------------------------------------------------- | |
| 1100 ;; Test split-string | |
| 1101 ;;----------------------------------------------------- | |
| 1425 | 1102 ;; Keep nulls, explicit SEPARATORS |
| 1103 ;; Hrvoje didn't like the next 3 tests so I'm disabling them for now. -sb | |
| 1104 ;; I assume Hrvoje worried about the possibility of infloops. -sjt | |
| 1105 (when test-harness-risk-infloops | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1106 (Assert (equal (split-string "foo" "") '("" "f" "o" "o" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1107 (Assert (equal (split-string "foo" "^") '("" "foo"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1108 (Assert (equal (split-string "foo" "$") '("foo" "")))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1109 (Assert (equal (split-string "foo,bar" ",") '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1110 (Assert (equal (split-string ",foo,bar," ",") '("" "foo" "bar" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1111 (Assert (equal (split-string ",foo,bar," "^,") '("" "foo,bar,"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1112 (Assert (equal (split-string ",foo,bar," ",$") '(",foo,bar" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1113 (Assert (equal (split-string ",foo,,bar," ",") '("" "foo" "" "bar" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1114 (Assert (equal (split-string "foo,,,bar" ",") '("foo" "" "" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1115 (Assert (equal (split-string "foo,,bar,," ",") '("foo" "" "bar" "" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1116 (Assert (equal (split-string "foo,,bar" ",+") '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1117 (Assert (equal (split-string ",foo,,bar," ",+") '("" "foo" "bar" ""))) |
| 1425 | 1118 ;; Omit nulls, explicit SEPARATORS |
| 1119 (when test-harness-risk-infloops | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1120 (Assert (equal (split-string "foo" "" t) '("f" "o" "o"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1121 (Assert (equal (split-string "foo" "^" t) '("foo"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1122 (Assert (equal (split-string "foo" "$" t) '("foo")))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1123 (Assert (equal (split-string "foo,bar" "," t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1124 (Assert (equal (split-string ",foo,bar," "," t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1125 (Assert (equal (split-string ",foo,bar," "^," t) '("foo,bar,"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1126 (Assert (equal (split-string ",foo,bar," ",$" t) '(",foo,bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1127 (Assert (equal (split-string ",foo,,bar," "," t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1128 (Assert (equal (split-string "foo,,,bar" "," t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1129 (Assert (equal (split-string "foo,,bar,," "," t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1130 (Assert (equal (split-string "foo,,bar" ",+" t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1131 (Assert (equal (split-string ",foo,,bar," ",+" t) '("foo" "bar"))) |
| 1425 | 1132 ;; "Double-default" case |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1133 (Assert (equal (split-string "foo bar") '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1134 (Assert (equal (split-string " foo bar ") '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1135 (Assert (equal (split-string " foo bar ") '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1136 (Assert (equal (split-string "foo bar") '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1137 (Assert (equal (split-string "foo bar ") '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1138 (Assert (equal (split-string "foobar") '("foobar"))) |
| 1425 | 1139 ;; Semantics are identical to "double-default" case! Fool ya? |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1140 (Assert (equal (split-string "foo bar" nil t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1141 (Assert (equal (split-string " foo bar " nil t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1142 (Assert (equal (split-string " foo bar " nil t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1143 (Assert (equal (split-string "foo bar" nil t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1144 (Assert (equal (split-string "foo bar " nil t) '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1145 (Assert (equal (split-string "foobar" nil t) '("foobar"))) |
| 1425 | 1146 ;; Perverse "anti-double-default" case |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1147 (Assert (equal (split-string "foo bar" split-string-default-separators) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1148 '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1149 (Assert (equal (split-string " foo bar " split-string-default-separators) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1150 '("" "foo" "bar" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1151 (Assert (equal (split-string " foo bar " split-string-default-separators) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1152 '("" "foo" "bar" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1153 (Assert (equal (split-string "foo bar" split-string-default-separators) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1154 '("foo" "bar"))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1155 (Assert (equal (split-string "foo bar " split-string-default-separators) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1156 '("foo" "bar" ""))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1157 (Assert (equal (split-string "foobar" split-string-default-separators) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1158 '("foobar"))) |
| 434 | 1159 |
| 1160 ;;----------------------------------------------------- | |
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1161 ;; Test split-string-by-char |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1162 ;;----------------------------------------------------- |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1163 |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1164 (Assert |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1165 (equal |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1166 (split-string-by-char |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1167 #r"re\:ee:this\\is\\text\\\\:oo\ps: |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1168 Eine Sprache, die stagnirt, ist zu vergleichen mit einem See, dem der |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1169 bisherige Quellenzufluß versiegt oder abgeleitet wird. Aus dem Wasser, |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1170 worüber der Geist Gottes schwebte, wird Sumpf und Moder, worüber die |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1171 unreinen\: Geister brüten.\\ |
|
5036
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1172 Serum concentrations of vitamin E: (alpha-tocopherol) depend on the liver, |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1173 which takes up the nutrient after the various forms are absorbed from the |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1174 small intestine. The liver preferentially resecretes only alpha-tocopherol |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1175 via the hepatic alpha-tocopherol transfer protein" |
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1176 ?: ?\\) |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1177 '("re:ee" "this\\is\\text\\\\" "oops" " |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1178 Eine Sprache, die stagnirt, ist zu vergleichen mit einem See, dem der |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1179 bisherige Quellenzufluß versiegt oder abgeleitet wird. Aus dem Wasser, |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1180 worüber der Geist Gottes schwebte, wird Sumpf und Moder, worüber die |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1181 unreinen: Geister brüten.\\ |
|
5036
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1182 Serum concentrations of vitamin E" " (alpha-tocopherol) depend on the liver, |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1183 which takes up the nutrient after the various forms are absorbed from the |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1184 small intestine. The liver preferentially resecretes only alpha-tocopherol |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1185 via the hepatic alpha-tocopherol transfer protein"))) |
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1186 (Assert |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1187 (equal |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1188 (split-string-by-char |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1189 #r"re\:ee:this\\is\\text\\\\:oo\ps: |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1190 Eine Sprache, die stagnirt, ist zu vergleichen mit einem See, dem der |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1191 bisherige Quellenzufluß versiegt oder abgeleitet wird. Aus dem Wasser, |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1192 worüber der Geist Gottes schwebte, wird Sumpf und Moder, worüber die |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1193 unreinen\: Geister brüten.\\ |
|
5036
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1194 Serum concentrations of vitamin E: (alpha-tocopherol) depend on the liver, |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1195 which takes up the nutrient after the various forms are absorbed from the |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1196 small intestine. The liver preferentially resecretes only alpha-tocopherol |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1197 via the hepatic alpha-tocopherol transfer protein" |
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1198 ?: ?\x00) |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1199 '("re\\" "ee" "this\\\\is\\\\text\\\\\\\\" "oo\\ps" " |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1200 Eine Sprache, die stagnirt, ist zu vergleichen mit einem See, dem der |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1201 bisherige Quellenzufluß versiegt oder abgeleitet wird. Aus dem Wasser, |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1202 worüber der Geist Gottes schwebte, wird Sumpf und Moder, worüber die |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1203 unreinen\\" " Geister brüten.\\\\ |
|
5036
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1204 Serum concentrations of vitamin E" " (alpha-tocopherol) depend on the liver, |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1205 which takes up the nutrient after the various forms are absorbed from the |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1206 small intestine. The liver preferentially resecretes only alpha-tocopherol |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1207 via the hepatic alpha-tocopherol transfer protein"))) |
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1208 (Assert |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1209 (equal |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1210 (split-string-by-char |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1211 #r"re\:ee:this\\is\\text\\\\:oo\ps: |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1212 Eine Sprache, die stagnirt, ist zu vergleichen mit einem See, dem der |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1213 bisherige Quellenzufluß versiegt oder abgeleitet wird. Aus dem Wasser, |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1214 worüber der Geist Gottes schwebte, wird Sumpf und Moder, worüber die |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1215 unreinen\: Geister brüten.\\ |
|
5036
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1216 Serum concentrations of vitamin E: (alpha-tocopherol) depend on the liver, |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1217 which takes up the nutrient after the various forms are absorbed from the |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1218 small intestine. The liver preferentially resecretes only alpha-tocopherol |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1219 via the hepatic alpha-tocopherol transfer protein" ?\\) |
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1220 '("re" ":ee:this" "" "is" "" "text" "" "" "" ":oo" "ps: |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1221 Eine Sprache, die stagnirt, ist zu vergleichen mit einem See, dem der |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1222 bisherige Quellenzufluß versiegt oder abgeleitet wird. Aus dem Wasser, |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1223 worüber der Geist Gottes schwebte, wird Sumpf und Moder, worüber die |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1224 unreinen" ": Geister brüten." "" " |
|
5036
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1225 Serum concentrations of vitamin E: (alpha-tocopherol) depend on the liver, |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1226 which takes up the nutrient after the various forms are absorbed from the |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1227 small intestine. The liver preferentially resecretes only alpha-tocopherol |
|
9624523604c5
Use better types when ESCAPECHAR is specified, split_string_by_ichar_1
Aidan Kehoe <kehoea@parhasard.net>
parents:
5035
diff
changeset
|
1228 via the hepatic alpha-tocopherol transfer protein"))) |
|
5035
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1229 |
|
b1e48555be7d
Add a new optional ESCAPE-CHAR argument to #'split-string-by-char.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5034
diff
changeset
|
1230 ;;----------------------------------------------------- |
| 434 | 1231 ;; Test near-text buffer functions. |
| 1232 ;;----------------------------------------------------- | |
| 1233 (with-temp-buffer | |
| 1234 (erase-buffer) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1235 (Assert (eq (char-before) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1236 (Assert (eq (char-before (point)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1237 (Assert (eq (char-before (point-marker)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1238 (Assert (eq (char-before (point) (current-buffer)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1239 (Assert (eq (char-before (point-marker) (current-buffer)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1240 (Assert (eq (char-after) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1241 (Assert (eq (char-after (point)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1242 (Assert (eq (char-after (point-marker)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1243 (Assert (eq (char-after (point) (current-buffer)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1244 (Assert (eq (char-after (point-marker) (current-buffer)) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1245 (Assert (eq (preceding-char) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1246 (Assert (eq (preceding-char (current-buffer)) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1247 (Assert (eq (following-char) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1248 (Assert (eq (following-char (current-buffer)) 0)) |
| 434 | 1249 (insert "foobar") |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1250 (Assert (eq (char-before) ?r)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1251 (Assert (eq (char-after) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1252 (Assert (eq (preceding-char) ?r)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1253 (Assert (eq (following-char) 0)) |
| 434 | 1254 (goto-char (point-min)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1255 (Assert (eq (char-before) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1256 (Assert (eq (char-after) ?f)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1257 (Assert (eq (preceding-char) 0)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1258 (Assert (eq (following-char) ?f)) |
| 434 | 1259 ) |
| 440 | 1260 |
| 1261 ;;----------------------------------------------------- | |
| 1262 ;; Test plist manipulation functions. | |
| 1263 ;;----------------------------------------------------- | |
| 1264 (let ((sym (make-symbol "test-symbol"))) | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1265 (Assert (eq t (get* sym t t))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1266 (Assert (eq t (get sym t t))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1267 (Assert (eq t (getf nil t t))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1268 (Assert (eq t (plist-get nil t t))) |
| 440 | 1269 (put sym 'bar 'baz) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1270 (Assert (eq 'baz (get sym 'bar))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1271 (Assert (eq 'baz (getf '(bar baz) 'bar))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1272 (Assert (eq 'baz (getf (symbol-plist sym) 'bar))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1273 (Assert (eq 2 (getf '(1 2) 1))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1274 (Assert (eq 4 (put sym 3 4))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1275 (Assert (eq 4 (get sym 3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1276 (Assert (eq t (remprop sym 3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1277 (Assert (eq nil (remprop sym 3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1278 (Assert (eq 5 (get sym 3 5))) |
| 440 | 1279 ) |
| 442 | 1280 |
| 1281 (loop for obj in | |
| 1282 (list (make-symbol "test-symbol") | |
| 1283 "test-string" | |
| 1284 (make-extent nil nil nil) | |
| 1285 (make-face 'test-face)) | |
| 1286 do | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1287 (Assert (eq 2 (get obj ?1 2)) obj) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1288 (Assert (eq 4 (put obj ?3 4)) obj) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1289 (Assert (eq 4 (get obj ?3)) obj) |
| 442 | 1290 (when (or (stringp obj) (symbolp obj)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1291 (Assert (equal '(?3 4) (object-plist obj)) obj)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1292 (Assert (eq t (remprop obj ?3)) obj) |
| 442 | 1293 (when (or (stringp obj) (symbolp obj)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1294 (Assert (eq '() (object-plist obj)) obj)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1295 (Assert (eq nil (remprop obj ?3)) obj) |
| 442 | 1296 (when (or (stringp obj) (symbolp obj)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1297 (Assert (eq '() (object-plist obj)) obj)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1298 (Assert (eq 5 (get obj ?3 5)) obj) |
| 442 | 1299 ) |
| 1300 | |
| 1301 (Check-Error-Message | |
| 1302 error "Object type has no properties" | |
| 1303 (get 2 'property)) | |
| 1304 | |
| 1305 (Check-Error-Message | |
| 1306 error "Object type has no settable properties" | |
| 1307 (put (current-buffer) 'property 'value)) | |
| 1308 | |
| 1309 (Check-Error-Message | |
| 1310 error "Object type has no removable properties" | |
| 1311 (remprop ?3 'property)) | |
| 1312 | |
| 1313 (Check-Error-Message | |
| 1314 error "Object type has no properties" | |
| 1315 (object-plist (symbol-function 'car))) | |
| 1316 | |
| 1317 (Check-Error-Message | |
| 1318 error "Can't remove property from object" | |
| 1319 (remprop (make-extent nil nil nil) 'detachable)) | |
| 1320 | |
| 1321 ;;----------------------------------------------------- | |
| 1322 ;; Test subseq | |
| 1323 ;;----------------------------------------------------- | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1324 (Assert (equal (subseq nil 0) nil)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1325 (Assert (equal (subseq [1 2 3] 0) [1 2 3])) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1326 (Assert (equal (subseq [1 2 3] 1 -1) [2])) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1327 (Assert (equal (subseq "123" 0) "123")) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1328 (Assert (equal (subseq "1234" -3 -1) "23")) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1329 (Assert (equal (subseq #*0011 0) #*0011)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1330 (Assert (equal (subseq #*0011 -3 3) #*01)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1331 (Assert (equal (subseq '(1 2 3) 0) '(1 2 3))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1332 (Assert (equal (subseq '(1 2 3 4) -3 nil) '(2 3 4))) |
| 442 | 1333 |
| 446 | 1334 (Check-Error wrong-type-argument (subseq 3 2)) |
| 1335 (Check-Error args-out-of-range (subseq [1 2 3] -42)) | |
| 1336 (Check-Error args-out-of-range (subseq [1 2 3] 0 42)) | |
| 442 | 1337 |
|
5370
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1338 (let ((string "hi there")) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1339 (Assert (equal (substring-no-properties "123" 0) "123")) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1340 (Assert (equal (substring-no-properties "1234" -3 -1) "23")) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1341 (Assert (equal (substring-no-properties "hi there" 0) "hi there")) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1342 (put-text-property 0 (length string) 'foo 'bar string) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1343 (Assert (eq 'bar (get-text-property 0 'foo string))) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1344 (Assert (not |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1345 (get-text-property 0 'foo (substring-no-properties "hi there" 0)))) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1346 (Check-Error wrong-type-argument (substring-no-properties nil 4)) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1347 (Check-Error wrong-type-argument (substring-no-properties "hi there" pi)) |
|
4c4b96b13f70
Address the easy test failures in tests/automated.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5360
diff
changeset
|
1348 (Check-Error wrong-type-argument (substring-no-properties "hi there" 0.0))) |
|
5360
46b53e84ea7a
#'substring-no-properties: check STRING's type, get_string_range_char won't.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5355
diff
changeset
|
1349 |
| 442 | 1350 ;;----------------------------------------------------- |
| 1351 ;; Time-related tests | |
| 1352 ;;----------------------------------------------------- | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1353 (Assert (= (length (current-time-string)) 24)) |
| 444 | 1354 |
| 1355 ;;----------------------------------------------------- | |
| 1356 ;; format test | |
| 1357 ;;----------------------------------------------------- | |
| 1358 (Assert (string= (format "%d" 10) "10")) | |
| 1359 (Assert (string= (format "%o" 8) "10")) | |
|
5295
2474dce7304e
Make sure (format "%b" 0) is non-zero length, print.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
5285
diff
changeset
|
1360 (Assert (string= (format "%b" 2) "10")) |
| 444 | 1361 (Assert (string= (format "%x" 31) "1f")) |
| 1362 (Assert (string= (format "%X" 31) "1F")) | |
|
5295
2474dce7304e
Make sure (format "%b" 0) is non-zero length, print.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
5285
diff
changeset
|
1363 (Assert (string= (format "%b" 0) "0")) |
|
2474dce7304e
Make sure (format "%b" 0) is non-zero length, print.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
5285
diff
changeset
|
1364 (Assert (string= (format "%b" 3) "11")) |
| 826 | 1365 ;; MS-Windows uses +002 in its floating-point numbers. #### We should |
| 1366 ;; perhaps fix this, but writing our own floating-point support in doprnt.c | |
| 1367 ;; is very hard. | |
| 1368 (Assert (or (string= (format "%e" 100) "1.000000e+02") | |
| 1369 (string= (format "%e" 100) "1.000000e+002"))) | |
| 1370 (Assert (or (string= (format "%E" 100) "1.000000E+02") | |
| 1371 (string= (format "%E" 100) "1.000000E+002"))) | |
| 1372 (Assert (or (string= (format "%E" 100) "1.000000E+02") | |
| 1373 (string= (format "%E" 100) "1.000000E+002"))) | |
| 444 | 1374 (Assert (string= (format "%f" 100) "100.000000")) |
| 448 | 1375 (Assert (string= (format "%7.3f" 12.12345) " 12.123")) |
| 1376 (Assert (string= (format "%07.3f" 12.12345) "012.123")) | |
| 1377 (Assert (string= (format "%-7.3f" 12.12345) "12.123 ")) | |
| 1378 (Assert (string= (format "%-07.3f" 12.12345) "12.123 ")) | |
| 444 | 1379 (Assert (string= (format "%g" 100.0) "100")) |
| 826 | 1380 (Assert (or (string= (format "%g" 0.000001) "1e-06") |
| 1381 (string= (format "%g" 0.000001) "1e-006"))) | |
| 444 | 1382 (Assert (string= (format "%g" 0.0001) "0.0001")) |
| 1383 (Assert (string= (format "%G" 100.0) "100")) | |
| 826 | 1384 (Assert (or (string= (format "%G" 0.000001) "1E-06") |
| 1385 (string= (format "%G" 0.000001) "1E-006"))) | |
| 444 | 1386 (Assert (string= (format "%G" 0.0001) "0.0001")) |
| 1387 | |
| 1388 (Assert (string= (format "%2$d%1$d" 10 20) "2010")) | |
| 1389 (Assert (string= (format "%-d" 10) "10")) | |
| 1390 (Assert (string= (format "%-4d" 10) "10 ")) | |
| 1391 (Assert (string= (format "%+d" 10) "+10")) | |
| 1392 (Assert (string= (format "%+d" -10) "-10")) | |
| 1393 (Assert (string= (format "%+4d" 10) " +10")) | |
| 1394 (Assert (string= (format "%+4d" -10) " -10")) | |
| 1395 (Assert (string= (format "% d" 10) " 10")) | |
| 1396 (Assert (string= (format "% d" -10) "-10")) | |
| 1397 (Assert (string= (format "% 4d" 10) " 10")) | |
| 1398 (Assert (string= (format "% 4d" -10) " -10")) | |
| 1399 (Assert (string= (format "%0d" 10) "10")) | |
| 1400 (Assert (string= (format "%0d" -10) "-10")) | |
| 1401 (Assert (string= (format "%04d" 10) "0010")) | |
| 1402 (Assert (string= (format "%04d" -10) "-010")) | |
| 1403 (Assert (string= (format "%*d" 4 10) " 10")) | |
| 1404 (Assert (string= (format "%*d" 4 -10) " -10")) | |
| 1405 (Assert (string= (format "%*d" -4 10) "10 ")) | |
| 1406 (Assert (string= (format "%*d" -4 -10) "-10 ")) | |
| 1407 (Assert (string= (format "%#d" 10) "10")) | |
| 1408 (Assert (string= (format "%#o" 8) "010")) | |
| 1409 (Assert (string= (format "%#x" 16) "0x10")) | |
| 826 | 1410 (Assert (or (string= (format "%#e" 100) "1.000000e+02") |
| 1411 (string= (format "%#e" 100) "1.000000e+002"))) | |
| 1412 (Assert (or (string= (format "%#E" 100) "1.000000E+02") | |
| 1413 (string= (format "%#E" 100) "1.000000E+002"))) | |
| 444 | 1414 (Assert (string= (format "%#f" 100) "100.000000")) |
| 1415 (Assert (string= (format "%#g" 100.0) "100.000")) | |
| 826 | 1416 (Assert (or (string= (format "%#g" 0.000001) "1.00000e-06") |
| 1417 (string= (format "%#g" 0.000001) "1.00000e-006"))) | |
| 444 | 1418 (Assert (string= (format "%#g" 0.0001) "0.000100000")) |
| 1419 (Assert (string= (format "%#G" 100.0) "100.000")) | |
| 826 | 1420 (Assert (or (string= (format "%#G" 0.000001) "1.00000E-06") |
| 1421 (string= (format "%#G" 0.000001) "1.00000E-006"))) | |
| 444 | 1422 (Assert (string= (format "%#G" 0.0001) "0.000100000")) |
| 1423 (Assert (string= (format "%.1d" 10) "10")) | |
| 1424 (Assert (string= (format "%.4d" 10) "0010")) | |
| 1425 ;; Combination of `-', `+', ` ', `0', `#', `.', `*' | |
| 448 | 1426 (Assert (string= (format "%-04d" 10) "10 ")) |
| 444 | 1427 (Assert (string= (format "%-*d" 4 10) "10 ")) |
| 1428 ;; #### Correctness of this behavior is questionable. | |
| 1429 ;; It might be better to signal error. | |
| 1430 (Assert (string= (format "%-*d" -4 10) "10 ")) | |
| 1431 ;; These behavior is not specified. | |
| 1432 ;; (format "%-+d" 10) | |
| 1433 ;; (format "%- d" 10) | |
| 1434 ;; (format "%-01d" 10) | |
| 1435 ;; (format "%-#4x" 10) | |
| 1436 ;; (format "%-.1d" 10) | |
| 1437 | |
| 1438 (Assert (string= (format "%01.1d" 10) "10")) | |
| 448 | 1439 (Assert (string= (format "%03.1d" 10) " 10")) |
| 1440 (Assert (string= (format "%01.3d" 10) "010")) | |
| 1441 (Assert (string= (format "%1.3d" 10) "010")) | |
| 444 | 1442 (Assert (string= (format "%3.1d" 10) " 10")) |
| 446 | 1443 |
| 448 | 1444 ;;; The following two tests used to use 1000 instead of 100, |
| 1445 ;;; but that merely found buffer overflow bugs in Solaris sprintf(). | |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1446 (Assert (= 102 (length (format "%.100f" 3.14)))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1447 (Assert (= 100 (length (format "%100f" 3.14)))) |
| 448 | 1448 |
| 446 | 1449 ;;; Check for 64-bit cleanness on LP64 platforms. |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1450 (Assert (= (read (format "%d" most-positive-fixnum)) most-positive-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1451 (Assert (= (read (format "%ld" most-positive-fixnum)) most-positive-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1452 (Assert (= (read (format "%u" most-positive-fixnum)) most-positive-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1453 (Assert (= (read (format "%lu" most-positive-fixnum)) most-positive-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1454 (Assert (= (read (format "%d" most-negative-fixnum)) most-negative-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1455 (Assert (= (read (format "%ld" most-negative-fixnum)) most-negative-fixnum)) |
| 446 | 1456 |
| 4287 | 1457 ;; These used to crash. |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1458 (Assert (eql (read (format "%f" 1.2e+302)) 1.2e+302)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1459 (Assert (eql (read (format "%.1000d" 1)) 1)) |
| 4287 | 1460 |
| 446 | 1461 ;;; "%u" is undocumented, and Emacs Lisp has no unsigned type. |
| 1462 ;;; What to do if "%u" is used with a negative number? | |
| 1983 | 1463 ;;; For non-bignum XEmacsen, the most reasonable thing seems to be to print an |
| 1464 ;;; un-read-able number. The printed value might be useful to a human, if not | |
| 1465 ;;; to Emacs Lisp. | |
| 1466 ;;; For bignum XEmacsen, we make %u with a negative value throw an error. | |
| 1467 (if (featurep 'bignum) | |
| 1468 (progn | |
| 1469 (Check-Error wrong-type-argument (format "%u" most-negative-fixnum)) | |
| 1470 (Check-Error wrong-type-argument (format "%u" -1))) | |
| 1471 (Check-Error invalid-read-syntax (read (format "%u" most-negative-fixnum))) | |
| 1472 (Check-Error invalid-read-syntax (read (format "%u" -1)))) | |
| 448 | 1473 |
| 1474 ;; Check all-completions ignore element start with space. | |
| 1475 (Assert (not (all-completions "" '((" hidden" . "object"))))) | |
| 1476 (Assert (all-completions " " '((" hidden" . "object")))) | |
|
4394
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1477 |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1478 (let* ((literal-with-uninterned |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1479 '(first-element |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1480 [#1=#:G32976 #2=#:G32974 #3=#:G32971 #4=#:G32969 alias |
|
4396
e97f16fb2e25
Don't assume lisp-tests.el will be correctly read as UTF-8.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4394
diff
changeset
|
1481 #s(hash-table size 256 data (969 ?\xF9 55 ?7 166 ?\xA6)) |
|
4394
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1482 #5=#:G32970 #6=#:G32972])) |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1483 (print-readably t) |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1484 (print-gensym t) |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1485 (printed-with-uninterned (prin1-to-string literal-with-uninterned)) |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1486 (awkward-regexp "#1=#") |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1487 (first-match-start (string-match awkward-regexp |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1488 printed-with-uninterned))) |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1489 (Assert (null (string-match awkward-regexp printed-with-uninterned |
|
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4287
diff
changeset
|
1490 (1+ first-match-start))))) |
|
4580
1d11ecca9cd0
Print char table values correctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4575
diff
changeset
|
1491 |
|
1d11ecca9cd0
Print char table values correctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4575
diff
changeset
|
1492 (let ((char-table-with-string #s(char-table data (?\x00 "text"))) |
|
1d11ecca9cd0
Print char table values correctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4575
diff
changeset
|
1493 (char-table-with-symbol #s(char-table data (?\x00 text)))) |
|
4582
00ed9903a988
Fix make check after my last change.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4580
diff
changeset
|
1494 (Assert (not (string-equal (prin1-to-string char-table-with-string) |
|
00ed9903a988
Fix make check after my last change.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4580
diff
changeset
|
1495 (prin1-to-string char-table-with-symbol))) |
|
4580
1d11ecca9cd0
Print char table values correctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4575
diff
changeset
|
1496 "Check that char table elements are quoted correctly when printing")) |
|
1d11ecca9cd0
Print char table values correctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4575
diff
changeset
|
1497 |
|
4608
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1498 |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1499 (let ((test-file-name |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1500 (make-temp-file (expand-file-name "sR4KDwU" (temp-directory)) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1501 nil ".el"))) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1502 (find-file test-file-name) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1503 (erase-buffer) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1504 (insert |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1505 "\ |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1506 ;; Lisp should not be able to modify #$, which is |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1507 ;; Vload_file_name_internal of lread.c. |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1508 (Check-Error setting-constant (aset #$ 0 ?\\ )) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1509 |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1510 ;; But modifying load-file-name should work: |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1511 (let ((new-char ?\\ ) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1512 old-char) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1513 (setq old-char (aref load-file-name 0)) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1514 (if (= new-char old-char) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1515 (setq new-char ?/)) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1516 (aset load-file-name 0 new-char) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1517 (Assert (= new-char (aref load-file-name 0)) |
|
4608
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1518 \"Check that we can modify the string value of load-file-name\")) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1519 |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1520 (let* ((new-load-file-name \"hi there\") |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1521 (load-file-name new-load-file-name)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1522 (Assert (eq new-load-file-name load-file-name) |
|
4608
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1523 \"Checking that we can bind load-file-name successfully.\")) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1524 |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1525 ") |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1526 (write-region (point-min) (point-max) test-file-name nil 'quiet) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1527 (set-buffer-modified-p nil) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1528 (kill-buffer nil) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1529 (load test-file-name nil t nil) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1530 (delete-file test-file-name)) |
|
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
1531 |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1532 (flet ((cl-floor (x &optional y) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1533 (let ((q (floor x y))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1534 (list q (- x (if y (* y q) q))))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1535 (cl-ceiling (x &optional y) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1536 (let ((res (cl-floor x y))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1537 (if (= (car (cdr res)) 0) res |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1538 (list (1+ (car res)) (- (car (cdr res)) (or y 1)))))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1539 (cl-truncate (x &optional y) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1540 (if (eq (>= x 0) (or (null y) (>= y 0))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1541 (cl-floor x y) (cl-ceiling x y))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1542 (cl-round (x &optional y) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1543 (if y |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1544 (if (and (integerp x) (integerp y)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1545 (let* ((hy (/ y 2)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1546 (res (cl-floor (+ x hy) y))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1547 (if (and (= (car (cdr res)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1548 (= (+ hy hy) y) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1549 (/= (% (car res) 2) 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1550 (list (1- (car res)) hy) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1551 (list (car res) (- (car (cdr res)) hy)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1552 (let ((q (round (/ x y)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1553 (list q (- x (* q y))))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1554 (if (integerp x) (list x 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1555 (let ((q (round x))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1556 (list q (- x q)))))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1557 (Assert-rounding (first second &key |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1558 one-floor-result two-floor-result |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1559 one-ffloor-result two-ffloor-result |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1560 one-ceiling-result two-ceiling-result |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1561 one-fceiling-result two-fceiling-result |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1562 one-round-result two-round-result |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1563 one-fround-result two-fround-result |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1564 one-truncate-result two-truncate-result |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1565 one-ftruncate-result two-ftruncate-result) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1566 (Assert (equal one-floor-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1567 (floor first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1568 (format "checking (floor %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1569 first one-floor-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1570 (Assert (equal one-floor-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1571 (floor first 1))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1572 (format "checking (floor %S 1) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1573 first one-floor-result)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1574 (Check-Error arith-error (floor first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1575 (Check-Error arith-error (floor first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1576 (Assert (equal two-floor-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1577 (floor first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1578 (format |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1579 "checking (floor %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1580 first second two-floor-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1581 (Assert (equal (cl-floor first second) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1582 (multiple-value-list (floor first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1583 (format |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1584 "checking (floor %S %S) gives the same as the old code" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1585 first second)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1586 (Assert (equal one-ffloor-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1587 (ffloor first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1588 (format "checking (ffloor %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1589 first one-ffloor-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1590 (Assert (equal one-ffloor-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1591 (ffloor first 1))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1592 (format "checking (ffloor %S 1) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1593 first one-ffloor-result)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1594 (Check-Error arith-error (ffloor first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1595 (Check-Error arith-error (ffloor first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1596 (Assert (equal two-ffloor-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1597 (ffloor first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1598 (format "checking (ffloor %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1599 first second two-ffloor-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1600 (Assert (equal one-ceiling-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1601 (ceiling first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1602 (format "checking (ceiling %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1603 first one-ceiling-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1604 (Assert (equal one-ceiling-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1605 (ceiling first 1))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1606 (format "checking (ceiling %S 1) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1607 first one-ceiling-result)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1608 (Check-Error arith-error (ceiling first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1609 (Check-Error arith-error (ceiling first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1610 (Assert (equal two-ceiling-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1611 (ceiling first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1612 (format "checking (ceiling %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1613 first second two-ceiling-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1614 (Assert (equal (cl-ceiling first second) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1615 (multiple-value-list (ceiling first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1616 (format |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1617 "checking (ceiling %S %S) gives the same as the old code" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1618 first second)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1619 (Assert (equal one-fceiling-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1620 (fceiling first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1621 (format "checking (fceiling %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1622 first one-fceiling-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1623 (Assert (equal one-fceiling-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1624 (fceiling first 1))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1625 (format "checking (fceiling %S 1) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1626 first one-fceiling-result)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1627 (Check-Error arith-error (fceiling first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1628 (Check-Error arith-error (fceiling first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1629 (Assert (equal two-fceiling-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1630 (fceiling first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1631 (format "checking (fceiling %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1632 first second two-fceiling-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1633 (Assert (equal one-round-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1634 (round first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1635 (format "checking (round %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1636 first one-round-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1637 (Assert (equal one-round-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1638 (round first 1))) |
|
4686
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
1639 (format "checking (round %S 1) gives %S" |
|
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
1640 first one-round-result)) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1641 (Check-Error arith-error (round first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1642 (Check-Error arith-error (round first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1643 (Assert (equal two-round-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1644 (round first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1645 (format "checking (round %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1646 first second two-round-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1647 (Assert (equal one-fround-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1648 (fround first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1649 (format "checking (fround %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1650 first one-fround-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1651 (Assert (equal one-fround-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1652 (fround first 1))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1653 (format "checking (fround %S 1) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1654 first one-fround-result)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1655 (Check-Error arith-error (fround first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1656 (Check-Error arith-error (fround first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1657 (Assert (equal two-fround-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1658 (fround first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1659 (format "checking (fround %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1660 first second two-fround-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1661 (Assert (equal (cl-round first second) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1662 (multiple-value-list (round first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1663 (format |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1664 "checking (round %S %S) gives the same as the old code" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1665 first second)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1666 (Assert (equal one-truncate-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1667 (truncate first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1668 (format "checking (truncate %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1669 first one-truncate-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1670 (Assert (equal one-truncate-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1671 (truncate first 1))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1672 (format "checking (truncate %S 1) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1673 first one-truncate-result)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1674 (Check-Error arith-error (truncate first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1675 (Check-Error arith-error (truncate first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1676 (Assert (equal two-truncate-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1677 (truncate first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1678 (format "checking (truncate %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1679 first second two-truncate-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1680 (Assert (equal (cl-truncate first second) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1681 (multiple-value-list (truncate first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1682 (format |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1683 "checking (truncate %S %S) gives the same as the old code" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1684 first second)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1685 (Assert (equal one-ftruncate-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1686 (ftruncate first))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1687 (format "checking (ftruncate %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1688 first one-ftruncate-result)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1689 (Assert (equal one-ftruncate-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1690 (ftruncate first 1))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1691 (format "checking (ftruncate %S 1) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1692 first one-ftruncate-result)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1693 (Check-Error arith-error (ftruncate first 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1694 (Check-Error arith-error (ftruncate first 0.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1695 (Assert (equal two-ftruncate-result (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
1696 (ftruncate first second))) |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1697 (format "checking (ftruncate %S %S) gives %S" |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1698 first second two-ftruncate-result))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1699 (Assert-rounding-floating (pie ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1700 (let ((pie-type (type-of pie))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1701 (assert (eq pie-type (type-of ee)) t |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1702 "This code assumes the two arguments have the same type.") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1703 (Assert-rounding pie ee |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1704 :one-floor-result (list 3 (- pie 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1705 :two-floor-result (list 1 (- pie (* 1 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1706 :one-ffloor-result (list (coerce 3 pie-type) (- pie 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1707 :two-ffloor-result (list (coerce 1 pie-type) (- pie (* 1.0 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1708 :one-ceiling-result (list 4 (- pie 4)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1709 :two-ceiling-result (list 2 (- pie (* 2 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1710 :one-fceiling-result (list (coerce 4 pie-type) (- pie 4.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1711 :two-fceiling-result (list (coerce 2 pie-type) (- pie (* 2.0 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1712 :one-round-result (list 3 (- pie 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1713 :two-round-result (list 1 (- pie (* 1 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1714 :one-fround-result (list (coerce 3 pie-type) (- pie 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1715 :two-fround-result (list (coerce 1 pie-type) (- pie (* 1.0 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1716 :one-truncate-result (list 3 (- pie 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1717 :two-truncate-result (list 1 (- pie (* 1 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1718 :one-ftruncate-result (list (coerce 3 pie-type) (- pie 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1719 :two-ftruncate-result (list (coerce 1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1720 (- pie (* 1.0 ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1721 (Assert-rounding pie (- ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1722 :one-floor-result (list 3 (- pie 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1723 :two-floor-result (list -2 (- pie (* -2 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1724 :one-ffloor-result (list (coerce 3 pie-type) (- pie 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1725 :two-ffloor-result (list (coerce -2 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1726 (- pie (* -2.0 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1727 :one-ceiling-result (list 4 (- pie 4)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1728 :two-ceiling-result (list -1 (- pie (* -1 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1729 :one-fceiling-result (list (coerce 4 pie-type) (- pie 4.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1730 :two-fceiling-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1731 (- pie (* -1.0 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1732 :one-round-result (list 3 (- pie 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1733 :two-round-result (list -1 (- pie (* -1 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1734 :one-fround-result (list (coerce 3 pie-type) (- pie 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1735 :two-fround-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1736 (- pie (* -1.0 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1737 :one-truncate-result (list 3 (- pie 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1738 :two-truncate-result (list -1 (- pie (* -1 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1739 :one-ftruncate-result (list (coerce 3 pie-type) (- pie 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1740 :two-ftruncate-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1741 (- pie (* -1.0 (- ee))))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1742 (Assert-rounding (- pie) ee |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1743 :one-floor-result (list -4 (- (- pie) -4)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1744 :two-floor-result (list -2 (- (- pie) (* -2 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1745 :one-ffloor-result (list (coerce -4 pie-type) (- (- pie) -4.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1746 :two-ffloor-result (list (coerce -2 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1747 (- (- pie) (* -2.0 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1748 :one-ceiling-result (list -3 (- (- pie) -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1749 :two-ceiling-result (list -1 (- (- pie) (* -1 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1750 :one-fceiling-result (list (coerce -3 pie-type) (- (- pie) -3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1751 :two-fceiling-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1752 (- (- pie) (* -1.0 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1753 :one-round-result (list -3 (- (- pie) -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1754 :two-round-result (list -1 (- (- pie) (* -1 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1755 :one-fround-result (list (coerce -3 pie-type) (- (- pie) -3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1756 :two-fround-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1757 (- (- pie) (* -1.0 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1758 :one-truncate-result (list -3 (- (- pie) -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1759 :two-truncate-result (list -1 (- (- pie) (* -1 ee))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1760 :one-ftruncate-result (list (coerce -3 pie-type) (- (- pie) -3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1761 :two-ftruncate-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1762 (- (- pie) (* -1.0 ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1763 (Assert-rounding (- pie) (- ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1764 :one-floor-result (list -4 (- (- pie) -4)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1765 :two-floor-result (list 1 (- (- pie) (* 1 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1766 :one-ffloor-result (list (coerce -4 pie-type) (- (- pie) -4.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1767 :two-ffloor-result (list (coerce 1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1768 (- (- pie) (* 1.0 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1769 :one-ceiling-result (list -3 (- (- pie) -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1770 :two-ceiling-result (list 2 (- (- pie) (* 2 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1771 :one-fceiling-result (list (coerce -3 pie-type) (- (- pie) -3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1772 :two-fceiling-result (list (coerce 2 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1773 (- (- pie) (* 2.0 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1774 :one-round-result (list -3 (- (- pie) -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1775 :two-round-result (list 1 (- (- pie) (* 1 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1776 :one-fround-result (list (coerce -3 pie-type) (- (- pie) -3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1777 :two-fround-result (list (coerce 1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1778 (- (- pie) (* 1.0 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1779 :one-truncate-result (list -3 (- (- pie) -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1780 :two-truncate-result (list 1 (- (- pie) (* 1 (- ee)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1781 :one-ftruncate-result (list (coerce -3 pie-type) (- (- pie) -3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1782 :two-ftruncate-result (list (coerce 1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1783 (- (- pie) (* 1.0 (- ee))))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1784 (Assert-rounding ee pie |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1785 :one-floor-result (list 2 (- ee 2)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1786 :two-floor-result (list 0 ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1787 :one-ffloor-result (list (coerce 2 pie-type) (- ee 2.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1788 :two-ffloor-result (list (coerce 0 pie-type) ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1789 :one-ceiling-result (list 3 (- ee 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1790 :two-ceiling-result (list 1 (- ee pie)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1791 :one-fceiling-result (list (coerce 3 pie-type) (- ee 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1792 :two-fceiling-result (list (coerce 1 pie-type) (- ee pie)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1793 :one-round-result (list 3 (- ee 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1794 :two-round-result (list 1 (- ee (* 1 pie))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1795 :one-fround-result (list (coerce 3 pie-type) (- ee 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1796 :two-fround-result (list (coerce 1 pie-type) (- ee (* 1.0 pie))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1797 :one-truncate-result (list 2 (- ee 2)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1798 :two-truncate-result (list 0 ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1799 :one-ftruncate-result (list (coerce 2 pie-type) (- ee 2.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1800 :two-ftruncate-result (list (coerce 0 pie-type) ee)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1801 (Assert-rounding ee (- pie) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1802 :one-floor-result (list 2 (- ee 2)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1803 :two-floor-result (list -1 (- ee (* -1 (- pie)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1804 :one-ffloor-result (list (coerce 2 pie-type) (- ee 2.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1805 :two-ffloor-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1806 (- ee (* -1.0 (- pie)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1807 :one-ceiling-result (list 3 (- ee 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1808 :two-ceiling-result (list 0 ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1809 :one-fceiling-result (list (coerce 3 pie-type) (- ee 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1810 :two-fceiling-result (list (coerce 0 pie-type) ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1811 :one-round-result (list 3 (- ee 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1812 :two-round-result (list -1 (- ee (* -1 (- pie)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1813 :one-fround-result (list (coerce 3 pie-type) (- ee 3.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1814 :two-fround-result (list (coerce -1 pie-type) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1815 (- ee (* -1.0 (- pie)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1816 :one-truncate-result (list 2 (- ee 2)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1817 :two-truncate-result (list 0 ee) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1818 :one-ftruncate-result (list (coerce 2 pie-type) (- ee 2.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1819 :two-ftruncate-result (list (coerce 0 pie-type) ee))))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1820 ;; First, two integers: |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1821 (Assert-rounding 27 8 :one-floor-result '(27 0) :two-floor-result '(3 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1822 :one-ffloor-result '(27.0 0) :two-ffloor-result '(3.0 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1823 :one-ceiling-result '(27 0) :two-ceiling-result '(4 -5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1824 :one-fceiling-result '(27.0 0) :two-fceiling-result '(4.0 -5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1825 :one-round-result '(27 0) :two-round-result '(3 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1826 :one-fround-result '(27.0 0) :two-fround-result '(3.0 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1827 :one-truncate-result '(27 0) :two-truncate-result '(3 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1828 :one-ftruncate-result '(27.0 0) :two-ftruncate-result '(3.0 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1829 (Assert-rounding 27 -8 :one-floor-result '(27 0) :two-floor-result '(-4 -5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1830 :one-ffloor-result '(27.0 0) :two-ffloor-result '(-4.0 -5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1831 :one-ceiling-result '(27 0) :two-ceiling-result '(-3 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1832 :one-fceiling-result '(27.0 0) :two-fceiling-result '(-3.0 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1833 :one-round-result '(27 0) :two-round-result '(-3 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1834 :one-fround-result '(27.0 0) :two-fround-result '(-3.0 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1835 :one-truncate-result '(27 0) :two-truncate-result '(-3 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1836 :one-ftruncate-result '(27.0 0) :two-ftruncate-result '(-3.0 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1837 (Assert-rounding -27 8 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1838 :one-floor-result '(-27 0) :two-floor-result '(-4 5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1839 :one-ffloor-result '(-27.0 0) :two-ffloor-result '(-4.0 5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1840 :one-ceiling-result '(-27 0) :two-ceiling-result '(-3 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1841 :one-fceiling-result '(-27.0 0) :two-fceiling-result '(-3.0 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1842 :one-round-result '(-27 0) :two-round-result '(-3 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1843 :one-fround-result '(-27.0 0) :two-fround-result '(-3.0 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1844 :one-truncate-result '(-27 0) :two-truncate-result '(-3 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1845 :one-ftruncate-result '(-27.0 0) :two-ftruncate-result '(-3.0 -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1846 (Assert-rounding -27 -8 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1847 :one-floor-result '(-27 0) :two-floor-result '(3 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1848 :one-ffloor-result '(-27.0 0) :two-ffloor-result '(3.0 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1849 :one-ceiling-result '(-27 0) :two-ceiling-result '(4 5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1850 :one-fceiling-result '(-27.0 0) :two-fceiling-result '(4.0 5) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1851 :one-round-result '(-27 0) :two-round-result '(3 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1852 :one-fround-result '(-27.0 0) :two-fround-result '(3.0 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1853 :one-truncate-result '(-27 0) :two-truncate-result '(3 -3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1854 :one-ftruncate-result '(-27.0 0) :two-ftruncate-result '(3.0 -3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1855 (Assert-rounding 8 27 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1856 :one-floor-result '(8 0) :two-floor-result '(0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1857 :one-ffloor-result '(8.0 0) :two-ffloor-result '(0.0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1858 :one-ceiling-result '(8 0) :two-ceiling-result '(1 -19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1859 :one-fceiling-result '(8.0 0) :two-fceiling-result '(1.0 -19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1860 :one-round-result '(8 0) :two-round-result '(0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1861 :one-fround-result '(8.0 0) :two-fround-result '(0.0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1862 :one-truncate-result '(8 0) :two-truncate-result '(0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1863 :one-ftruncate-result '(8.0 0) :two-ftruncate-result '(0.0 8)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1864 (Assert-rounding 8 -27 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1865 :one-floor-result '(8 0) :two-floor-result '(-1 -19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1866 :one-ffloor-result '(8.0 0) :two-ffloor-result '(-1.0 -19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1867 :one-ceiling-result '(8 0) :two-ceiling-result '(0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1868 :one-fceiling-result '(8.0 0) :two-fceiling-result '(0.0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1869 :one-round-result '(8 0) :two-round-result '(0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1870 :one-fround-result '(8.0 0) :two-fround-result '(0.0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1871 :one-truncate-result '(8 0) :two-truncate-result '(0 8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1872 :one-ftruncate-result '(8.0 0) :two-ftruncate-result '(0.0 8)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1873 (Assert-rounding -8 27 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1874 :one-floor-result '(-8 0) :two-floor-result '(-1 19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1875 :one-ffloor-result '(-8.0 0) :two-ffloor-result '(-1.0 19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1876 :one-ceiling-result '(-8 0) :two-ceiling-result '(0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1877 :one-fceiling-result '(-8.0 0) :two-fceiling-result '(0.0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1878 :one-round-result '(-8 0) :two-round-result '(0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1879 :one-fround-result '(-8.0 0) :two-fround-result '(0.0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1880 :one-truncate-result '(-8 0) :two-truncate-result '(0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1881 :one-ftruncate-result '(-8.0 0) :two-ftruncate-result '(0.0 -8)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1882 (Assert-rounding -8 -27 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1883 :one-floor-result '(-8 0) :two-floor-result '(0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1884 :one-ffloor-result '(-8.0 0) :two-ffloor-result '(0.0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1885 :one-ceiling-result '(-8 0) :two-ceiling-result '(1 19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1886 :one-fceiling-result '(-8.0 0) :two-fceiling-result '(1.0 19) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1887 :one-round-result '(-8 0) :two-round-result '(0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1888 :one-fround-result '(-8.0 0) :two-fround-result '(0.0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1889 :one-truncate-result '(-8 0) :two-truncate-result '(0 -8) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1890 :one-ftruncate-result '(-8.0 0) :two-ftruncate-result '(0.0 -8)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1891 (Assert-rounding 32 4 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1892 :one-floor-result '(32 0) :two-floor-result '(8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1893 :one-ffloor-result '(32.0 0) :two-ffloor-result '(8.0 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1894 :one-ceiling-result '(32 0) :two-ceiling-result '(8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1895 :one-fceiling-result '(32.0 0) :two-fceiling-result '(8.0 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1896 :one-round-result '(32 0) :two-round-result '(8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1897 :one-fround-result '(32.0 0) :two-fround-result '(8.0 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1898 :one-truncate-result '(32 0) :two-truncate-result '(8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1899 :one-ftruncate-result '(32.0 0) :two-ftruncate-result '(8.0 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1900 (Assert-rounding 32 -4 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1901 :one-floor-result '(32 0) :two-floor-result '(-8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1902 :one-ffloor-result '(32.0 0) :two-ffloor-result '(-8.0 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1903 :one-ceiling-result '(32 0) :two-ceiling-result '(-8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1904 :one-fceiling-result '(32.0 0) :two-fceiling-result '(-8.0 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1905 :one-round-result '(32 0) :two-round-result '(-8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1906 :one-fround-result '(32.0 0) :two-fround-result '(-8.0 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1907 :one-truncate-result '(32 0) :two-truncate-result '(-8 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1908 :one-ftruncate-result '(32.0 0) :two-ftruncate-result '(-8.0 0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1909 (Assert-rounding 12 9 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1910 :one-floor-result '(12 0) :two-floor-result '(1 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1911 :one-ffloor-result '(12.0 0) :two-ffloor-result '(1.0 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1912 :one-ceiling-result '(12 0) :two-ceiling-result '(2 -6) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1913 :one-fceiling-result '(12.0 0) :two-fceiling-result '(2.0 -6) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1914 :one-round-result '(12 0) :two-round-result '(1 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1915 :one-fround-result '(12.0 0) :two-fround-result '(1.0 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1916 :one-truncate-result '(12 0) :two-truncate-result '(1 3) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1917 :one-ftruncate-result '(12.0 0) :two-ftruncate-result '(1.0 3)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1918 (Assert-rounding 10 4 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1919 :one-floor-result '(10 0) :two-floor-result '(2 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1920 :one-ffloor-result '(10.0 0) :two-ffloor-result '(2.0 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1921 :one-ceiling-result '(10 0) :two-ceiling-result '(3 -2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1922 :one-fceiling-result '(10.0 0) :two-fceiling-result '(3.0 -2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1923 :one-round-result '(10 0) :two-round-result '(2 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1924 :one-fround-result '(10.0 0) :two-fround-result '(2.0 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1925 :one-truncate-result '(10 0) :two-truncate-result '(2 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1926 :one-ftruncate-result '(10.0 0) :two-ftruncate-result '(2.0 2)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1927 (Assert-rounding 14 4 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1928 :one-floor-result '(14 0) :two-floor-result '(3 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1929 :one-ffloor-result '(14.0 0) :two-ffloor-result '(3.0 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1930 :one-ceiling-result '(14 0) :two-ceiling-result '(4 -2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1931 :one-fceiling-result '(14.0 0) :two-fceiling-result '(4.0 -2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1932 :one-round-result '(14 0) :two-round-result '(4 -2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1933 :one-fround-result '(14.0 0) :two-fround-result '(4.0 -2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1934 :one-truncate-result '(14 0) :two-truncate-result '(3 2) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1935 :one-ftruncate-result '(14.0 0) :two-ftruncate-result '(3.0 2)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1936 ;; Now, two floats: |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1937 (Assert-rounding-floating pi e) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1938 (when (featurep 'bigfloat) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1939 (Assert-rounding-floating (coerce pi 'bigfloat) (coerce e 'bigfloat))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1940 (when (featurep 'bignum) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1941 (assert (not (evenp most-positive-fixnum)) t |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1942 "In the unlikely event that most-positive-fixnum is even, rewrite this.") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1943 (Assert-rounding (1+ most-positive-fixnum) (* 2 most-positive-fixnum) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1944 :one-floor-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1945 :two-floor-result `(0 ,(1+ most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1946 :one-ffloor-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1947 :two-ffloor-result `(0.0 ,(1+ most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1948 :one-ceiling-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1949 :two-ceiling-result `(1 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1950 :one-fceiling-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1951 :two-fceiling-result `(1.0 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1952 :one-round-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1953 :two-round-result `(1 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1954 :one-fround-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1955 :two-fround-result `(1.0 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1956 :one-truncate-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1957 :two-truncate-result `(0 ,(1+ most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1958 :one-ftruncate-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1959 :two-ftruncate-result `(0.0 ,(1+ most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1960 (Assert-rounding (1+ most-positive-fixnum) (- (* 2 most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1961 :one-floor-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1962 :two-floor-result `(-1 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1963 :one-ffloor-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1964 :two-ffloor-result `(-1.0 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1965 :one-ceiling-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1966 :two-ceiling-result `(0 ,(1+ most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1967 :one-fceiling-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1968 :two-fceiling-result `(0.0 ,(1+ most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1969 :one-round-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1970 :two-round-result `(-1 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1971 :one-fround-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1972 :two-fround-result `(-1.0 ,(1+ (- most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1973 :one-truncate-result `(,(1+ most-positive-fixnum) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1974 :two-truncate-result `(0 ,(1+ most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1975 :one-ftruncate-result `(,(float (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1976 :two-ftruncate-result `(0.0 ,(1+ most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1977 (Assert-rounding (- (1+ most-positive-fixnum)) (* 2 most-positive-fixnum) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1978 :one-floor-result `(,(- (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1979 :two-floor-result `(-1 ,(1- most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1980 :one-ffloor-result `(,(float (- (1+ most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1981 :two-ffloor-result `(-1.0 ,(1- most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1982 :one-ceiling-result `(,(- (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1983 :two-ceiling-result `(0 ,(- (1+ most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1984 :one-fceiling-result `(,(float (- (1+ most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1985 :two-fceiling-result `(0.0 ,(- (1+ most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1986 :one-round-result `(,(- (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1987 :two-round-result `(-1 ,(1- most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1988 :one-fround-result `(,(float (- (1+ most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1989 :two-fround-result `(-1.0 ,(1- most-positive-fixnum)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1990 :one-truncate-result `(,(- (1+ most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1991 :two-truncate-result `(0 ,(- (1+ most-positive-fixnum))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1992 :one-ftruncate-result `(,(float (- (1+ most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1993 :two-ftruncate-result `(0.0 ,(- (1+ most-positive-fixnum)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1994 ;; Test the handling of values with .5: |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1995 (Assert-rounding (1+ (* 2 most-positive-fixnum)) 2 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1996 :one-floor-result `(,(1+ (* 2 most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1997 :two-floor-result `(,most-positive-fixnum 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1998 :one-ffloor-result `(,(float (1+ (* 2 most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
1999 ;; We can't just call #'float here; we must use code that converts a |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2000 ;; bignum with value most-positive-fixnum (the creation of which is |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2001 ;; not directly possible in Lisp) to a float, not code that converts |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2002 ;; the fixnum with value most-positive-fixnum to a float. The eval is |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2003 ;; to avoid compile-time optimisation that can break this. |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2004 :two-ffloor-result `(,(eval '(- (1+ most-positive-fixnum) 1 0.0)) 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2005 :one-ceiling-result `(,(1+ (* 2 most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2006 :two-ceiling-result `(,(1+ most-positive-fixnum) -1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2007 :one-fceiling-result `(,(float (1+ (* 2 most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2008 :two-fceiling-result `(,(float (1+ most-positive-fixnum)) -1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2009 :one-round-result `(,(1+ (* 2 most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2010 :two-round-result `(,(1+ most-positive-fixnum) -1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2011 :one-fround-result `(,(float (1+ (* 2 most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2012 :two-fround-result `(,(float (1+ most-positive-fixnum)) -1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2013 :one-truncate-result `(,(1+ (* 2 most-positive-fixnum)) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2014 :two-truncate-result `(,most-positive-fixnum 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2015 :one-ftruncate-result `(,(float (1+ (* 2 most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2016 ;; See the comment above on :two-ffloor-result: |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2017 :two-ftruncate-result `(,(eval '(- (1+ most-positive-fixnum) 1 0.0)) 1)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2018 (Assert-rounding (1+ (* 2 (1- most-positive-fixnum))) 2 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2019 :one-floor-result `(,(1+ (* 2 (1- most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2020 :two-floor-result `(,(1- most-positive-fixnum) 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2021 :one-ffloor-result `(,(float (1+ (* 2 (1- most-positive-fixnum)))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2022 ;; See commentary above on float conversions. |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2023 :two-ffloor-result `(,(eval '(- (1+ most-positive-fixnum) 2 0.0)) 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2024 :one-ceiling-result `(,(1+ (* 2 (1- most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2025 :two-ceiling-result `(,most-positive-fixnum -1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2026 :one-fceiling-result `(,(float (1+ (* 2 (1- most-positive-fixnum)))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2027 :two-fceiling-result `(,(eval '(- (1+ most-positive-fixnum) 1 0.0)) -1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2028 :one-round-result `(,(1+ (* 2 (1- most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2029 :two-round-result `(,(1- most-positive-fixnum) 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2030 :one-fround-result `(,(float (1+ (* 2 (1- most-positive-fixnum)))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2031 :two-fround-result `(,(eval '(- (1+ most-positive-fixnum) 2 0.0)) 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2032 :one-truncate-result `(,(1+ (* 2 (1- most-positive-fixnum))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2033 :two-truncate-result `(,(1- most-positive-fixnum) 1) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2034 :one-ftruncate-result `(,(float (1+ (* 2 (1- most-positive-fixnum)))) 0) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2035 ;; See commentary above |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2036 :two-ftruncate-result `(,(eval '(- (1+ most-positive-fixnum) 2 0.0)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2037 1))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2038 (when (featurep 'ratio) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2039 (Assert-rounding (read "4/3") (read "8/7") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2040 :one-floor-result '(1 1/3) :two-floor-result '(1 4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2041 :one-ffloor-result '(1.0 1/3) :two-ffloor-result '(1.0 4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2042 :one-ceiling-result '(2 -2/3) :two-ceiling-result '(2 -20/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2043 :one-fceiling-result '(2.0 -2/3) :two-fceiling-result '(2.0 -20/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2044 :one-round-result '(1 1/3) :two-round-result '(1 4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2045 :one-fround-result '(1.0 1/3) :two-fround-result '(1.0 4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2046 :one-truncate-result '(1 1/3) :two-truncate-result '(1 4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2047 :one-ftruncate-result '(1.0 1/3) :two-ftruncate-result '(1.0 4/21)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2048 (Assert-rounding (read "-4/3") (read "8/7") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2049 :one-floor-result '(-2 2/3) :two-floor-result '(-2 20/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2050 :one-ffloor-result '(-2.0 2/3) :two-ffloor-result '(-2.0 20/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2051 :one-ceiling-result '(-1 -1/3) :two-ceiling-result '(-1 -4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2052 :one-fceiling-result '(-1.0 -1/3) :two-fceiling-result '(-1.0 -4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2053 :one-round-result '(-1 -1/3) :two-round-result '(-1 -4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2054 :one-fround-result '(-1.0 -1/3) :two-fround-result '(-1.0 -4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2055 :one-truncate-result '(-1 -1/3) :two-truncate-result '(-1 -4/21) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2056 :one-ftruncate-result '(-1.0 -1/3) :two-ftruncate-result '(-1.0 -4/21)))) |
|
4608
1e3cf11fa27d
Make #$ truly read-only for Lisp; check this in the test suite.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4582
diff
changeset
|
2057 |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2058 ;; Run this function in a Common Lisp with two arguments to get results that |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2059 ;; we should compare against, above. Though note the dancing-around with the |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2060 ;; bigfloats and bignums above, too; you can't necessarily just use the |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2061 ;; output here. |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2062 |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2063 (defun generate-rounding-output (first second) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2064 (let ((print-readably t)) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2065 (princ first) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2066 (princ " ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2067 (princ second) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2068 (princ " :one-floor-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2069 (princ (list 'quote (multiple-value-list (floor first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2070 (princ " :two-floor-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2071 (princ (list 'quote (multiple-value-list (floor first second)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2072 (princ " :one-ffloor-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2073 (princ (list 'quote (multiple-value-list (ffloor first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2074 (princ " :two-ffloor-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2075 (princ (list 'quote (multiple-value-list (ffloor first second)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2076 (princ " :one-ceiling-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2077 (princ (list 'quote (multiple-value-list (ceiling first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2078 (princ " :two-ceiling-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2079 (princ (list 'quote (multiple-value-list (ceiling first second)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2080 (princ " :one-fceiling-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2081 (princ (list 'quote (multiple-value-list (fceiling first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2082 (princ " :two-fceiling-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2083 (princ (list 'quote (multiple-value-list (fceiling first second)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2084 (princ " :one-round-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2085 (princ (list 'quote (multiple-value-list (round first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2086 (princ " :two-round-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2087 (princ (list 'quote (multiple-value-list (round first second)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2088 (princ " :one-fround-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2089 (princ (list 'quote (multiple-value-list (fround first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2090 (princ " :two-fround-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2091 (princ (list 'quote (multiple-value-list (fround first second)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2092 (princ " :one-truncate-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2093 (princ (list 'quote (multiple-value-list (truncate first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2094 (princ " :two-truncate-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2095 (princ (list 'quote (multiple-value-list (truncate first second)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2096 (princ " :one-ftruncate-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2097 (princ (list 'quote (multiple-value-list (ftruncate first)))) |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2098 (princ " :two-ftruncate-result ") |
|
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4608
diff
changeset
|
2099 (princ (list 'quote (multiple-value-list (ftruncate first second)))))) |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2100 |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2101 ;; Multiple value tests. |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2102 |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2103 (flet ((foo (x y) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2104 (floor (+ x y) y)) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2105 (foo-zero (x y) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2106 (values (floor (+ x y) y))) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2107 (multiple-value-function-returning-t () |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2108 (values t pi e degrees-to-radians radians-to-degrees)) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2109 (multiple-value-function-returning-nil () |
|
4686
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
2110 (values nil pi e radians-to-degrees degrees-to-radians)) |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2111 (function-throwing-multiple-values () |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2112 (let* ((listing '(0 3 4 nil "string" symbol)) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2113 (tail listing) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2114 elt) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2115 (while t |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2116 (setq tail (cdr listing) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2117 elt (car listing) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2118 listing tail) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2119 (when (null elt) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2120 (throw 'VoN61Lo4Y (multiple-value-function-returning-t))))))) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2121 (Assert |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2122 (= (+ (floor 5 3) (floor 19 4)) (+ 1 4) 5) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2123 "Checking that multiple values are discarded correctly as func args") |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2124 (Assert |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2125 (= 2 (length (multiple-value-list (foo 400 (1+ most-positive-fixnum))))) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2126 "Checking multiple values are passed through correctly as return values") |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2127 (Assert |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2128 (= 1 (length (multiple-value-list |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2129 (foo-zero 400 (1+ most-positive-fixnum))))) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2130 "Checking multiple values are discarded correctly when forced") |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2131 (Check-Error setting-constant (setq multiple-values-limit 20)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2132 (Assert (equal '(-1 1) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2133 (multiple-value-list (floor -3 4))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2134 "Checking #'multiple-value-list gives a sane result") |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2135 (let ((ey 40000) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2136 (bee "this is a string") |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2137 (cee #s(hash-table size 256 data (969 ?\xF9)))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2138 (Assert (equal |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2139 (multiple-value-list (values ey bee cee)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2140 (multiple-value-list (values-list (list ey bee cee)))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2141 "Checking that #'values and #'values-list are correctly related") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2142 (Assert (equal |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2143 (multiple-value-list (values-list (list ey bee cee))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2144 (multiple-value-list (apply #'values (list ey bee cee)))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2145 "Checking #'values-list and #'apply with #values are correctly related")) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2146 (Assert (= (multiple-value-call #'+ (floor 5 3) (floor 19 4)) 10) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2147 "Checking #'multiple-value-call gives reasonable results.") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2148 (Assert (= (multiple-value-call (values '+ '*) (floor 5 3) (floor 19 4)) 10) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2149 "Checking #'multiple-value-call correct when first arg multiple.") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2150 (Assert (= 1 (length (multiple-value-list (prog1 (floor pi) "hi there")))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2151 "Checking #'prog1 does not pass back multiple values") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2152 (Assert (= 2 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2153 (multiple-value-prog1 (floor pi) "hi there")))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2154 "Checking #'multiple-value-prog1 passes back multiple values") |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2155 (multiple-value-bind (floored remainder this-is-nil) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2156 (floor pi 1.0) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2157 (Assert (= floored 3) |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2158 "Checking floored bound correctly") |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2159 (Assert (eql remainder (- pi 3.0)) |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2160 "Checking remainder bound correctly") |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2161 (Assert (null this-is-nil) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2162 "Checking trailing arg bound but nil")) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2163 (let ((ey 40000) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2164 (bee "this is a string") |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2165 (cee #s(hash-table size 256 data (969 ?\xF9)))) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2166 (multiple-value-setq (ey bee cee) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2167 (ffloor e 1.0)) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2168 (Assert (eql 2.0 ey) "Checking ey set correctly") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2169 (Assert (eql bee (- e 2.0)) "Checking bee set correctly") |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2170 (Assert (null cee) "Checking cee set to nil correctly")) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2171 (Assert (= 3 (length (multiple-value-list (eval '(values nil t pi))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2172 "Checking #'eval passes back multiple values") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2173 (Assert (= 2 (length (multiple-value-list (apply #'floor '(5 3))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2174 "Checking #'apply passes back multiple values") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2175 (Assert (= 2 (length (multiple-value-list (funcall #'floor 5 3)))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2176 "Checking #'funcall passes back multiple values") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2177 (Assert (equal '(1 2) (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2178 (multiple-value-call #'floor (values 5 3)))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2179 "Checking #'multiple-value-call passes back multiple values correctly") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2180 (Assert (= 1 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2181 (and (multiple-value-function-returning-nil) t)))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2182 "Checking multiple values from non-trailing forms discarded by #'and") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2183 (Assert (= 5 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2184 (and t (multiple-value-function-returning-nil))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2185 "Checking multiple values from final forms not discarded by #'and") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2186 (Assert (= 1 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2187 (or (multiple-value-function-returning-t) t)))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2188 "Checking multiple values from non-trailing forms discarded by #'and") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2189 (Assert (= 5 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2190 (or nil (multiple-value-function-returning-t))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2191 "Checking multiple values from final forms not discarded by #'and") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2192 (Assert (= 1 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2193 (cond ((multiple-value-function-returning-t)))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2194 "Checking cond doesn't pass back multiple values in tests.") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2195 (Assert (equal (list nil pi e radians-to-degrees degrees-to-radians) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2196 (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2197 (cond (t (multiple-value-function-returning-nil))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2198 "Checking cond passes back multiple values in clauses.") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2199 (Assert (= 1 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2200 (prog1 (multiple-value-function-returning-nil))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2201 "Checking prog1 discards multiple values correctly.") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2202 (Assert (= 5 (length (multiple-value-list |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2203 (multiple-value-prog1 |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2204 (multiple-value-function-returning-nil))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2205 "Checking multiple-value-prog1 passes back multiple values correctly.") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2206 (Assert (equal (list t pi e degrees-to-radians radians-to-degrees) |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2207 (multiple-value-list |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2208 (catch 'VoN61Lo4Y (function-throwing-multiple-values))))) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2209 (Assert (equal (list t pi e degrees-to-radians radians-to-degrees) |
|
4679
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2210 (multiple-value-list |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2211 (loop |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2212 for eye in `(a b c d ,e f g ,nil ,pi) |
|
2c64d2bbb316
Test the multiple-value functionality.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4678
diff
changeset
|
2213 do (when (null eye) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2214 (return (multiple-value-function-returning-t)))))) |
|
4686
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
2215 "Checking #'loop passes back multiple values correctly.") |
|
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
2216 (Assert |
|
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
2217 (null (or)) |
|
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
2218 "Checking #'or behaves correctly with zero arguments.") |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2219 (Assert (eq t (and)) |
|
4686
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
2220 "Checking #'and behaves correctly with zero arguments.") |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2221 (Assert (= (* 3.0 (- pi 3.0)) |
|
4742
4cf435fcebbc
Make #'letf not error if handed a #'values form.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4732
diff
changeset
|
2222 (letf (((values three one-four-one-five-nine) (floor pi))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2223 (* three one-four-one-five-nine))) |
|
4742
4cf435fcebbc
Make #'letf not error if handed a #'values form.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4732
diff
changeset
|
2224 "checking letf handles #'values in a basic sense")) |
|
4686
cdabd56ce1b5
Fix various small issues with the multiple-value implementation.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4679
diff
changeset
|
2225 |
|
4792
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2226 ;; #'equalp tests. |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2227 (let ((string-variable "aBcDeeFgH\u00Edj") |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2228 (eacute-character ?\u00E9) |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2229 (Eacute-character ?\u00c9) |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2230 (+base-chars+ (loop |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2231 with res = (make-string 96 ?\x20) |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2232 for int-char from #x20 to #x7f |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2233 for char being each element in-ref res |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2234 do (setf char (int-to-char int-char)) |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2235 finally return res))) |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2236 |
|
5188
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2237 (macrolet |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2238 ((equalp-equal-list-tests (equal-list) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2239 (let (res) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2240 (setq equal-lists (eval equal-list)) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2241 (loop for li in equal-lists do |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2242 (loop for (x . tail) on li do |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2243 (loop for y in tail do |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2244 (push `(Assert (equalp ,(quote-maybe x) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2245 ,(quote-maybe y))) res) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2246 (push `(Assert (equalp ,(quote-maybe y) |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2247 ,(quote-maybe x))) res) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2248 (push `(Assert (eql (equalp-hash ,(quote-maybe y)) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2249 (equalp-hash ,(quote-maybe x)))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2250 res)))) |
|
5188
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2251 (cons 'progn (nreverse res)))) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2252 (equalp-diff-list-tests (diff-list) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2253 (let (res) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2254 (setq diff-list (eval diff-list)) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2255 (loop for (x . tail) on diff-list do |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2256 (loop for y in tail do |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2257 (push `(Assert (not (equalp ,(quote-maybe x) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2258 ,(quote-maybe y)))) res) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2259 (push `(Assert (not (equalp ,(quote-maybe y) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2260 ,(quote-maybe x)))) res))) |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2261 (cons 'progn (nreverse res)))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2262 (Assert-equalp (object-one object-two &optional failing-case description) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2263 `(progn |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2264 (Assert (equalp ,object-one ,object-two) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2265 ,@(if failing-case |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2266 (list failing-case description))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2267 (Assert (eql (equalp-hash ,object-one) (equalp-hash ,object-two)))))) |
|
5188
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2268 (equalp-equal-list-tests |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2269 `(,@(when (featurep 'bignum) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2270 (read "((111111111111111111111111111111111111111111111111111 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2271 111111111111111111111111111111111111111111111111111.0))")) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2272 (0 0.0 0.000 -0 -0.0 -0.000 #b0 ,@(when (featurep 'ratio) '(0/5 -0/5))) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2273 (21845 #b101010101010101 #x5555) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2274 (1.5 1.500000000000000000000000000000000000000000000000000000000 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2275 ,@(when (featurep 'ratio) '(3/2))) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2276 ;; Can't use this, these values aren't `='. |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2277 ;;(-12345678901234567890123457890123457890123457890123457890123457890 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2278 ;; -12345678901234567890123457890123457890123457890123457890123457890.0) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2279 (-55 -55.000 ,@(when (featurep 'ratio) '(-110/2))))) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2280 (equalp-diff-list-tests |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2281 `(0 1 2 3 1000 5000000000 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2282 ,@(when (featurep 'bignum) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2283 (read "(5555555555555555555555555555555555555 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2284 -5555555555555555555555555555555555555)")) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2285 -1 -2 -3 -1000 -5000000000 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2286 1/2 1/3 2/3 8/2 355/113 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2287 ,@(when (featurep 'ratio) (mapcar* #'/ '(3/2 3/2) '(0.2 0.7))) |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2288 55555555555555555555555555555555555555555/2718281828459045 |
|
000287f8053b
Be more careful about parentheses and number features, #'equalp tests
Aidan Kehoe <kehoea@parhasard.net>
parents:
5136
diff
changeset
|
2289 0.111111111111111111111111111111111111111111111111111111111111111 |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2290 1e+300 1e+301 -1e+300 -1e+301)) |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2291 |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2292 (Assert-equalp "hi there" "Hi There" |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2293 "checking equalp isn't case-sensitive") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2294 (Assert-equalp |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2295 99 99.0 |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2296 "checking equalp compares numerical values of different types") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2297 (Assert (null (equalp 99 ?c)) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2298 "checking equalp does not convert characters to numbers") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2299 ;; Fixed in Hg d0ea57eb3de4. |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2300 (Assert (null (equalp "hi there" [hi there])) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2301 "checking equalp doesn't error with string and non-string") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2302 (Assert-equalp |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2303 "ABCDEEFGH\u00CDJ" string-variable |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2304 "checking #'equalp is case-insensitive with an upcased constant") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2305 (Assert-equalp |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2306 "abcdeefgh\xedj" string-variable |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2307 "checking #'equalp is case-insensitive with a downcased constant") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2308 (Assert-equalp string-variable string-variable |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2309 "checking #'equalp works when handed the same string twice") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2310 (Assert (equalp string-variable "aBcDeeFgH\u00Edj") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2311 "check #'equalp is case-insensitive with a variable-cased constant") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2312 (Assert-equalp "" (bit-vector) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2313 "check empty string and empty bit-vector are #'equalp.") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2314 (Assert-equalp |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2315 (string) (bit-vector) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2316 "check empty string and empty bit-vector are #'equalp, no constants") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2317 (Assert-equalp "hi there" (vector ?h ?i ?\ ?t ?h ?e ?r ?e) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2318 "check string and vector with same contents #'equalp") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2319 (Assert-equalp |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2320 (string ?h ?i ?\ ?t ?h ?e ?r ?e) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2321 (vector ?h ?i ?\ ?t ?h ?e ?r ?e) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2322 "check string and vector with same contents #'equalp, no constants") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2323 (Assert-equalp |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2324 [?h ?i ?\ ?t ?h ?e ?r ?e] |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2325 (string ?h ?i ?\ ?t ?h ?e ?r ?e) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2326 "check string and vector with same contents #'equalp, vector constant") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2327 (Assert-equalp [0 1.0 0.0 0 1] |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2328 (bit-vector 0 1 0 0 1) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2329 "check vector and bit-vector with same contents #'equalp,\ |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4897
diff
changeset
|
2330 vector constant") |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2331 (Assert (not (equalp [0 2 0.0 0 1] |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2332 (bit-vector 0 1 0 0 1))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2333 "check vector and bit-vector with different contents not #'equalp,\ |
|
4792
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2334 vector constant") |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2335 (Assert-equalp #*01001 |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2336 (vector 0 1.0 0.0 0 1) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2337 "check vector and bit-vector with same contents #'equalp,\ |
|
4792
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2338 bit-vector constant") |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2339 (Assert-equalp ?\u00E9 Eacute-character |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2340 "checking characters are case-insensitive, one constant") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2341 (Assert (not (equalp ?\u00E9 (aref (format "%c" ?a) 0))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2342 "checking distinct characters are not equalp, one constant") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2343 (Assert-equalp t (and) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2344 "checking symbols are correctly #'equalp") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2345 (Assert (not (equalp t (or nil '#:t))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2346 "checking distinct symbols with the same name are not #'equalp") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2347 (Assert-equalp #s(char-table type generic data (?\u0080 "hi-there")) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2348 (let ((aragh (make-char-table 'generic))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2349 (put-char-table ?\u0080 "hi-there" aragh) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2350 aragh) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2351 "checking #'equalp succeeds correctly, char-tables") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2352 (Assert-equalp #s(char-table type generic data (?\u0080 "hi-there")) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2353 (let ((aragh (make-char-table 'generic))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2354 (put-char-table ?\u0080 "HI-THERE" aragh) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2355 aragh) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2356 "checking #'equalp succeeds correctly, char-tables") |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2357 (Assert (not (equalp #s(char-table type generic data (?\u0080 "hi-there")) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2358 (let ((aragh (make-char-table 'generic))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2359 (put-char-table ?\u0080 "hi there" aragh) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2360 aragh))) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5188
diff
changeset
|
2361 "checking #'equalp fails correctly, char-tables"))) |
|
4792
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2362 |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2363 ;; There are more tests available for equalp here: |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2364 ;; |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2365 ;; http://www.parhasard.net/xemacs/equalp-tests.el |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2366 ;; |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2367 ;; They are taken from Paul Dietz' GCL ANSI test suite, licensed under the |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2368 ;; LGPL and part of GNU Common Lisp; the GCL people didn't respond to |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2369 ;; several requests for information on who owned the copyright for the |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2370 ;; files, so I haven't included the tests with XEmacs. Anyone doing XEmacs |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2371 ;; development on equalp should still run them, though. Aidan Kehoe, Thu Dec |
|
95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4742
diff
changeset
|
2372 ;; 31 14:53:52 GMT 2009. |
|
4732
2491a837112c
Fix typo in test of equalp and add more tests.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4728
diff
changeset
|
2373 |
|
4795
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2374 (loop |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2375 for special-form in '(multiple-value-call setq-default quote throw |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2376 save-current-buffer and or) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2377 with not-special-form = nil |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2378 do |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2379 (Assert (special-form-p special-form) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2380 (format "checking %S is a special operator" special-form)) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2381 (setq not-special-form |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2382 (intern (format "%s-gMAu" (symbol-name special-form)))) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2383 (Assert (not (special-form-p not-special-form)) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2384 (format "checking %S is a special operator" special-form)) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2385 (Assert (not (functionp special-form)) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2386 (format "checking %S is not a function" special-form))) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2387 |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2388 (loop |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2389 for real-function in '(find-file quote-maybe + - find-file-read-only) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2390 do (Assert (functionp real-function) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2391 (format "checking %S is a function" real-function))) |
|
084056f46755
#'functionp gives nil for special forms, as in CL and GNU Emacs 23.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4792
diff
changeset
|
2392 |
|
4885
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2393 ;; #'member, #'assoc tests. |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2394 |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2395 (when (featurep 'bignum) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2396 (let* ((member*-list `(0 9 342 [hi there] ,(1+ most-positive-fixnum) 0 |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2397 0.0 ,(1- most-negative-fixnum) nil)) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2398 (assoc*-list (loop |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2399 for elt in member*-list |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2400 collect (cons elt (random)))) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2401 (hashing (make-hash-table :test 'eql)) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2402 hashed-bignum) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2403 (macrolet |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2404 ((1+most-positive-fixnum () |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2405 (1+ most-positive-fixnum)) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2406 (1-most-negative-fixnum () |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2407 (1- most-negative-fixnum)) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2408 (*-2-most-positive-fixnum () |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2409 (* 2 most-positive-fixnum))) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2410 (Assert (eq |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2411 (member* (1+ most-positive-fixnum) member*-list) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2412 (member* (1+ most-positive-fixnum) member*-list :test #'eql)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2413 "checking #'member* correct if #'eql not explicitly specified") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2414 (Assert (eq |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2415 (assoc* (1+ most-positive-fixnum) assoc*-list) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2416 (assoc* (1+ most-positive-fixnum) assoc*-list :test #'eql)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2417 "checking #'assoc* correct if #'eql not explicitly specified") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2418 (Assert (eq |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2419 (rassoc* (1- most-negative-fixnum) assoc*-list) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2420 (rassoc* (1- most-negative-fixnum) assoc*-list :test #'eql)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2421 "checking #'rassoc* correct if #'eql not explicitly specified") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2422 (Assert (eql (1+most-positive-fixnum) (1+ most-positive-fixnum)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2423 "checking #'eql handles a bignum literal properly.") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2424 (Assert (eq |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2425 (member* (1+most-positive-fixnum) member*-list) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2426 (member* (1+ most-positive-fixnum) member*-list :test #'equal)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2427 "checking #'member* compiler macro correct with literal bignum") |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2428 (Assert (eq |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2429 (assoc* (1+most-positive-fixnum) assoc*-list) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2430 (assoc* (1+ most-positive-fixnum) assoc*-list :test #'equal)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2431 "checking #'assoc* compiler macro correct with literal bignum") |
|
4885
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2432 (puthash (setq hashed-bignum (*-2-most-positive-fixnum)) |
|
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2433 (gensym) hashing) |
|
5136
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2434 (Assert (eq |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2435 (gethash (* 2 most-positive-fixnum) hashing) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2436 (gethash hashed-bignum hashing)) |
|
0f66906b6e37
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically
Ben Wing <ben@xemacs.org>
parents:
5036
diff
changeset
|
2437 "checking hashing works correctly with #'eql tests and bignums")))) |
|
4885
6772ce4d982b
Fix hash tables, #'member*, #'assoc*, #'eql compiler macros if bignums
Aidan Kehoe <kehoea@parhasard.net>
parents:
4855
diff
changeset
|
2438 |
|
5241
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2439 ;; |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2440 (when (decode-char 'ucs #x0192) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2441 (Check-Error |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2442 invalid-state |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2443 (let ((str "aaaaaaaaaaaaa") |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2444 (called 0) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2445 modified) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2446 (reduce #'+ str |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2447 :key #'(lambda (object) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2448 (prog1 |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2449 object |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2450 (incf called) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2451 (or modified |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2452 (and (> called 5) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2453 (setq modified |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2454 (fill str (read #r"?\u0192"))))))))))) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2455 |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2456 (Assert |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2457 (eql 55 |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2458 (let ((sequence '(1 2 3 4 5 6 7 8 9 10)) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2459 (called 0) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2460 modified) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2461 (reduce #'+ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2462 sequence |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2463 :key |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2464 #'(lambda (object) (prog1 |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2465 object |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2466 (incf called) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2467 (and (eql called 5) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2468 (setcdr (nthcdr 3 sequence) nil)) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2469 (garbage-collect)))))) |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2470 "checking we can amputate lists without crashing #'reduce") |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5191
diff
changeset
|
2471 |
|
5244
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2472 (Assert (not (eq t (canonicalize-inst-list |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2473 `(((mswindows) . [string :data ,(make-string 20 0)]) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2474 ((tty) . [string :data " "])) 'image t))) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2475 "checking mswindows is always available as a specifier tag") |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2476 |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2477 (Assert (not (eq t (canonicalize-inst-list |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2478 `(((mswindows) . [nothing]) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2479 ((tty) . [string :data " "])) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2480 'image t))) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2481 "checking the correct syntax for a nothing image specifier works") |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2482 |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2483 (Check-Error-Message invalid-argument "^Invalid specifier tag set" |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2484 (canonicalize-inst-list |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2485 `(((,(gensym)) . [nothing]) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2486 ((tty) . [string :data " "])) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2487 'image)) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2488 |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2489 (Check-Error-Message invalid-argument "^Unrecognized keyword" |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2490 (canonicalize-inst-list |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2491 `(((mswindows) . [nothing :data "hi there"]) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2492 ((tty) . [string :data " "])) 'image)) |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2493 |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2494 ;; If we combine both the specifier inst list problems, we get the |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2495 ;; unrecognized keyword error first, not the invalid specifier tag set |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2496 ;; error. This is a little unintuitive; the specifier tag set thing is |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2497 ;; processed first, and would seem to be more important. But anyone writing |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2498 ;; code needs to solve both problems, it's reasonable to ask them to do it |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2499 ;; in series rather than in parallel. |
|
04811a268716
Be clearer in our error messages, #'canonicalize-inst-pair, #'canonicalize-spec
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
2500 |
|
5243
808131ba4a57
Print symbols with ratio-like names and the associated ratios distinctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5241
diff
changeset
|
2501 (when (featurep 'ratio) |
|
808131ba4a57
Print symbols with ratio-like names and the associated ratios distinctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5241
diff
changeset
|
2502 (Assert (not (eql '1/2 (read (prin1-to-string (intern "1/2"))))) |
|
808131ba4a57
Print symbols with ratio-like names and the associated ratios distinctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5241
diff
changeset
|
2503 "checking symbols with ratio-like names are printed distinctly") |
|
808131ba4a57
Print symbols with ratio-like names and the associated ratios distinctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5241
diff
changeset
|
2504 (Assert (not (eql '1/5 (read (prin1-to-string (intern "2/10"))))) |
|
808131ba4a57
Print symbols with ratio-like names and the associated ratios distinctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5241
diff
changeset
|
2505 "checking symbol named \"2/10\" not eql to ratio 1/5 on read")) |
|
808131ba4a57
Print symbols with ratio-like names and the associated ratios distinctly.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5241
diff
changeset
|
2506 |
|
5283
be436ac36ba4
Don't share a counter when checking for circularity, list_merge().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5244
diff
changeset
|
2507 (let* ((count 0) |
|
be436ac36ba4
Don't share a counter when checking for circularity, list_merge().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5244
diff
changeset
|
2508 (list (map-into (make-list 2048 nil) #'(lambda () (decf count)))) |
|
be436ac36ba4
Don't share a counter when checking for circularity, list_merge().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5244
diff
changeset
|
2509 (expected (append list '(1)))) |
|
be436ac36ba4
Don't share a counter when checking for circularity, list_merge().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5244
diff
changeset
|
2510 (Assert (equal expected (merge 'list list '(1) #'<)) |
|
be436ac36ba4
Don't share a counter when checking for circularity, list_merge().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5244
diff
changeset
|
2511 "checking merge's circularity checks are sane")) |
|
be436ac36ba4
Don't share a counter when checking for circularity, list_merge().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5244
diff
changeset
|
2512 |
|
5300
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2513 (flet ((list-nreverse (list) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2514 (do ((list1 list (cdr list1)) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2515 (list2 nil (prog1 list1 (setcdr list1 list2)))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2516 ((atom list1) list2)))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2517 (let* ((integers (loop for i from 0 to 6000 collect i)) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2518 (characters (mapcan #'(lambda (integer) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2519 (if (char-int-p integer) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2520 (list (int-char integer)))) integers)) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2521 (fourth-bit #'(lambda (integer) (ash (logand #x10 integer) -4))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2522 (bits (mapcar fourth-bit integers)) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2523 (vector (vconcat integers)) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2524 (string (concat characters)) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2525 (bit-vector (bvconcat bits))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2526 (Assert (equal (reverse vector) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2527 (vconcat (list-nreverse (copy-list integers))))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2528 (Assert (eq vector (nreverse vector))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2529 (Assert (equal vector (vconcat (list-nreverse (copy-list integers))))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2530 (Assert (equal (reverse string) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2531 (concat (list-nreverse (copy-list characters))))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2532 (Assert (eq string (nreverse string))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2533 (Assert (equal string (concat (list-nreverse (copy-list characters))))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2534 (Assert (eq bit-vector (nreverse bit-vector))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2535 (Assert (equal (bvconcat (list-nreverse (copy-list bits))) bit-vector)) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2536 (Assert (not (equal bit-vector |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2537 (mapcar fourth-bit |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2538 (loop for i from 0 to 6000 collect i))))))) |
|
9f738305f80f
Accept sequences generally, not just lists, #'reverse, #'nreverse.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5299
diff
changeset
|
2539 |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2540 (Check-Error wrong-type-argument (self-insert-command 'self-insert-command)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2541 (Check-Error wrong-type-argument (make-list 'make-list 'make-list)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2542 (Check-Error wrong-type-argument (make-vector 'make-vector 'make-vector)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2543 (Check-Error wrong-type-argument (make-bit-vector 'make-bit-vector |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2544 'make-bit-vector)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2545 (Check-Error wrong-type-argument (make-byte-code '(&rest ignore) "\xc0\x87" [4] |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2546 'ignore)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2547 (Check-Error wrong-type-argument (make-string ?a ?a)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2548 (Check-Error wrong-type-argument (nth-value 'nth-value (truncate pi e))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2549 (Check-Error wrong-type-argument (make-hash-table :test #'eql :size :size)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2550 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2551 (accept-process-output nil 'accept-process-output)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2552 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2553 (accept-process-output nil 2000 'accept-process-output)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2554 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2555 (self-insert-command 'self-insert-command)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2556 (Check-Error wrong-type-argument (string-to-number "16" 'string-to-number)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2557 (Check-Error wrong-type-argument (move-to-column 'move-to-column)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2558 (stop-profiling) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2559 (Check-Error wrong-type-argument (start-profiling (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2560 (stop-profiling) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2561 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2562 (fill '(1 2 3 4 5) 1 :start (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2563 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2564 (fill [1 2 3 4 5] 1 :start (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2565 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2566 (fill "1 2 3 4 5" ?1 :start (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2567 (Check-Error wrong-type-argument |
|
5323
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2568 (fill #*10101010 1 :start (float most-positive-fixnum))) |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2569 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2570 (fill '(1 2 3 4 5) 1 :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2571 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2572 (fill [1 2 3 4 5] 1 :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2573 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2574 (fill "1 2 3 4 5" ?1 :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2575 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2576 (fill #*10101010 1 :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2577 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2578 (reduce #'cons '(1 2 3 4 5) :start (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2579 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2580 (reduce #'cons [1 2 3 4 5] :start (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2581 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2582 (reduce #'cons "1 2 3 4 5" :start (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2583 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2584 (reduce #'cons #*10101010 :start (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2585 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2586 (reduce #'cons '(1 2 3 4 5) :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2587 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2588 (reduce #'cons [1 2 3 4 5] :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2589 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2590 (reduce #'cons "1 2 3 4 5" :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2591 (Check-Error wrong-type-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2592 (reduce #'cons #*10101010 :end (float most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2593 |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2594 (when (featurep 'bignum) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2595 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2596 (self-insert-command (* 2 most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2597 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2598 (make-list (* 3 most-positive-fixnum) 'make-list)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2599 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2600 (make-vector (* 4 most-positive-fixnum) 'make-vector)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2601 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2602 (make-bit-vector (+ 2 most-positive-fixnum) 'make-bit-vector)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2603 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2604 (make-byte-code '(&rest ignore) "\xc0\x87" [4] |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2605 (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2606 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2607 (make-byte-code '(&rest ignore) "\xc0\x87" [4] |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2608 #x10000)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2609 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2610 (make-string (* 4 most-positive-fixnum) ?a)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2611 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2612 (nth-value most-positive-fixnum (truncate pi e))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2613 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2614 (make-hash-table :test #'equalp :size (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2615 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2616 (accept-process-output nil 4294967)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2617 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2618 (accept-process-output nil 10 (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2619 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2620 (self-insert-command (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2621 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2622 (string-to-number "16" (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2623 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2624 (recent-keys (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2625 (when (featurep 'xbm) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2626 (Check-Error-Message |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2627 invalid-argument |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2628 "^data is too short for width and height" |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2629 (set-face-background-pixmap |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2630 'left-margin |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2631 `[xbm :data (20 ,(* 2 most-positive-fixnum) "random-text")]))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2632 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2633 (move-to-column (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2634 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2635 (move-to-column (1- most-negative-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2636 (stop-profiling) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2637 (when (< most-positive-fixnum (lsh 1 32)) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2638 ;; We only support machines with integers of 32 bits or more. If |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2639 ;; most-positive-fixnum is less than 2^32, we're on a 32-bit machine, |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2640 ;; and it's appropriate to test start-profiling with a bignum. |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2641 (Assert (eq nil (start-profiling (* most-positive-fixnum 2))))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2642 (stop-profiling) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2643 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2644 (fill '(1 2 3 4 5) 1 :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2645 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2646 (fill [1 2 3 4 5] 1 :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2647 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2648 (fill "1 2 3 4 5" ?1 :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2649 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2650 (fill #*10101010 1 :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2651 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2652 (fill '(1 2 3 4 5) 1 :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2653 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2654 (fill [1 2 3 4 5] 1 :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2655 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2656 (fill "1 2 3 4 5" ?1 :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2657 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2658 (fill #*10101010 1 :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2659 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2660 (reduce #'cons '(1 2 3 4 5) :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2661 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2662 (reduce #'cons [1 2 3 4 5] :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2663 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2664 (reduce #'cons "1 2 3 4 5" :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2665 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2666 (reduce #'cons #*10101010 :start (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2667 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2668 (reduce #'cons '(1 2 3 4 5) :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2669 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2670 (reduce #'cons [1 2 3 4 5] :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2671 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2672 (reduce #'cons "1 2 3 4 5" :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2673 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2674 (reduce #'cons #*10101010 :end (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2675 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2676 (replace '(1 2 3 4 5) [5 4 3 2 1] |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2677 :start1 (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2678 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2679 (replace '(1 2 3 4 5) [5 4 3 2 1] |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2680 :start2 (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2681 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2682 (replace '(1 2 3 4 5) [5 4 3 2 1] |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2683 :end1 (1+ most-positive-fixnum))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2684 (Check-Error args-out-of-range |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2685 (replace '(1 2 3 4 5) [5 4 3 2 1] |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2686 :end2 (1+ most-positive-fixnum)))) |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5300
diff
changeset
|
2687 |
|
5323
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2688 (symbol-macrolet |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2689 ((list-length 2048) (vector-length 512) (string-length (* 8192 2))) |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2690 (let ((list |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2691 ;; CIRCULAR_LIST_SUSPICION_LENGTH is 1024, it's helpful if this list |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2692 ;; is longer than that. |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2693 (make-list list-length 'make-list)) |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2694 (vector (make-vector vector-length 'make-vector)) |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2695 (bit-vector (make-bit-vector vector-length 1)) |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2696 (string (make-string string-length |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2697 (or (decode-char 'ucs #x20ac) ?\xFF))) |
|
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2698 (item 'cons)) |
|
5347
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2699 (macrolet |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2700 ((construct-item-sequence-checks (&rest functions) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2701 (cons |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2702 'progn |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2703 (mapcan |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2704 #'(lambda (function) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2705 `((Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2706 (,function item list |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2707 :start (1+ list-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2708 :end (1+ list-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2709 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2710 (,function item list :start -1 |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2711 :end list-length)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2712 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2713 (,function item list :end (* 2 list-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2714 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2715 (,function item vector |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2716 :start (1+ vector-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2717 :end (1+ vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2718 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2719 (,function item vector :start -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2720 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2721 (,function item vector |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2722 :end (* 2 vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2723 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2724 (,function item bit-vector |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2725 :start (1+ vector-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2726 :end (1+ vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2727 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2728 (,function item bit-vector :start -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2729 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2730 (,function item bit-vector |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2731 :end (* 2 vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2732 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2733 (,function item string |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2734 :start (1+ string-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2735 :end (1+ string-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2736 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2737 (,function item string :start -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2738 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2739 (,function item string |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2740 :end (* 2 string-length))))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2741 functions))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2742 (construct-one-sequence-checks (&rest functions) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2743 (cons |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2744 'progn |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2745 (mapcan |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2746 #'(lambda (function) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2747 `((Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2748 (,function (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2749 :start (1+ list-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2750 :end (1+ list-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2751 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2752 (,function (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2753 :start -1 :end list-length)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2754 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2755 (,function (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2756 :end (* 2 list-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2757 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2758 (,function (copy-sequence vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2759 :start (1+ vector-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2760 :end (1+ vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2761 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2762 (,function (copy-sequence vector) :start -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2763 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2764 (,function (copy-sequence vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2765 :end (* 2 vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2766 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2767 (,function (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2768 :start (1+ vector-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2769 :end (1+ vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2770 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2771 (,function (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2772 :start -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2773 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2774 (,function (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2775 :end (* 2 vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2776 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2777 (,function (copy-sequence string) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2778 :start (1+ string-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2779 :end (1+ string-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2780 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2781 (,function (copy-sequence string) :start -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2782 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2783 (,function (copy-sequence string) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2784 :end (* 2 string-length))))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2785 functions))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2786 (construct-two-sequence-checks (&rest functions) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2787 (cons |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2788 'progn |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2789 (mapcan |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2790 #'(lambda (function) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2791 `((Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2792 (,function (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2793 (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2794 :start1 (1+ list-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2795 :end1 (1+ list-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2796 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2797 (,function (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2798 (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2799 :start1 -1 :end1 list-length)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2800 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2801 (,function (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2802 (copy-sequence list) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2803 :end1 (* 2 list-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2804 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2805 (,function (copy-sequence vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2806 (copy-sequence vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2807 :start1 (1+ vector-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2808 :end1 (1+ vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2809 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2810 (,function |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2811 (copy-sequence vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2812 (copy-sequence vector) :start1 -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2813 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2814 (,function (copy-sequence vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2815 (copy-sequence vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2816 :end1 (* 2 vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2817 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2818 (,function (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2819 (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2820 :start1 (1+ vector-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2821 :end1 (1+ vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2822 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2823 (,function (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2824 (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2825 :start1 -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2826 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2827 (,function (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2828 (copy-sequence bit-vector) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2829 :end1 (* 2 vector-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2830 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2831 (,function (copy-sequence string) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2832 (copy-sequence string) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2833 :start1 (1+ string-length) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2834 :end1 (1+ string-length))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2835 (Check-Error wrong-type-argument |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2836 (,function (copy-sequence string) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2837 (copy-sequence string) :start1 -1)) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2838 (Check-Error args-out-of-range |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2839 (,function (copy-sequence string) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2840 (copy-sequence string) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2841 :end1 (* 2 string-length))))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2842 functions)))) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2843 (construct-item-sequence-checks count position find delete* remove* |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2844 reduce) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2845 (construct-one-sequence-checks delete-duplicates remove-duplicates) |
|
fd441b85d760
Loop at macroexpansion time when sanity-checking :start, :end keyword args.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5346
diff
changeset
|
2846 (construct-two-sequence-checks replace mismatch search)))) |
|
5323
f87bb35a6b94
Test sanity-checking of :start, :end keyword arguments when appropriate.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
2847 |
|
5336
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2848 (let* ((list (list 1 2 3 4 5 6 7 120 'hi-there '#:everyone)) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2849 (vector (map 'vector #'identity list)) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2850 (bit-vector (map 'bit-vector |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2851 #'(lambda (object) (if (fixnump object) 1 0)) list)) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2852 (string (map 'string |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2853 #'(lambda (object) (or (and (fixnump object) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2854 (int-char object)) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2855 (decode-char 'ucs #x20ac))) list)) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2856 (gensym (gensym))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2857 (Assert (null (find 'not-in-it list))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2858 (Assert (null (find 'not-in-it vector))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2859 (Assert (null (find 'not-in-it bit-vector))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2860 (Assert (null (find 'not-in-it string))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2861 (loop |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2862 for elt being each element in vector using (index position) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2863 do |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2864 (Assert (eq elt (find elt list))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2865 (Assert (eq (elt list position) (find elt vector)))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2866 (Assert (eq gensym (find 'not-in-it list :default gensym))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2867 (Assert (eq gensym (find 'not-in-it vector :default gensym))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2868 (Assert (eq gensym (find 'not-in-it bit-vector :default gensym))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2869 (Assert (eq gensym (find 'not-in-it string :default gensym))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2870 (Assert (eq 'hi-there (find 'hi-there list))) |
|
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2871 ;; Different uninterned symbols with the same name. |
|
5339
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2872 (Assert (not (eq '#1=#:everyone (find '#1# list)))) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2873 |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2874 ;; Test concatenate. |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2875 (Assert (equal list (concatenate 'list vector))) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2876 (Assert (equal list (concatenate 'list (subseq vector 0 4) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2877 (subseq list 4)))) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2878 (Assert (equal vector (concatenate 'vector list))) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2879 (Assert (equal vector (concatenate `(vector * ,(length vector)) list))) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2880 (Assert (equal string (concatenate `(vector character ,(length string)) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2881 (append string nil)))) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2882 (Assert (equal bit-vector (concatenate 'bit-vector (subseq bit-vector 0 4) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2883 (append (subseq bit-vector 4) nil)))) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2884 (Assert (equal bit-vector (concatenate `(vector bit ,(length bit-vector)) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2885 (subseq bit-vector 0 4) |
|
ba62563ec7c7
Accept more complex TYPEs in #'concatenate, cl-extra.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5336
diff
changeset
|
2886 (append (subseq bit-vector 4) nil))))) |
|
5336
287499ff4c5f
Pass in the DEFAULT argument to position() as documented, #'find.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5329
diff
changeset
|
2887 |
|
5353
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2888 ;;----------------------------------------------------- |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2889 ;; Test `block', `return-from' |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2890 ;;----------------------------------------------------- |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2891 (Assert (eql 1 (block outer |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2892 (flet ((outtahere (n) (return-from outer n))) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2893 (block outer (outtahere 1))) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2894 2)) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2895 "checking `block' and `return-from' are lexically scoped correctly") |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2896 |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2897 ;; Other tests are available in Paul Dietz' test suite, and pass. The above, |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2898 ;; which we used to fail, is based on a test in the Hyperspec. We still |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2899 ;; behave incorrectly when compiled for the contorted-example function of |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2900 ;; CLTL2, whence the following test: |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2901 |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2902 (flet ((needs-lexical-context (first second third) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2903 (if (eql 0 first) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2904 (funcall second) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2905 (block awkward |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2906 (+ 5 (needs-lexical-context |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2907 (1- first) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2908 third |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2909 #'(lambda () (return-from awkward 0))) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2910 first))))) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2911 (if (compiled-function-p (symbol-function 'needs-lexical-context)) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2912 (Known-Bug-Expect-Failure |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2913 (Assert (eql 0 (needs-lexical-context 2 nil nil)) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2914 "the function special operator doesn't create a lexical context.")) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2915 (Assert (eql 0 (needs-lexical-context 2 nil nil))))) |
|
38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5347
diff
changeset
|
2916 |
|
4732
2491a837112c
Fix typo in test of equalp and add more tests.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4728
diff
changeset
|
2917 ;;; end of lisp-tests.el |