From 7e3732efca295e3085faeefd1b8e38e02f37764a Mon Sep 17 00:00:00 2001
From: Liam Healy <lnp@healy.washington.dc.us>
Date: Tue, 12 May 2009 16:45:01 -0400
Subject: [PATCH] Conditionalize some 64 bit tests

Some 64 bit vector and matrix tests were not conditionalized; add the
#+int64 conditionals.
---
 tests/matrix-set-all.lisp |   2 +
 tests/vector-add.lisp     | 244 +++++++++++++++++++-------------------
 tests/vector-set-all.lisp | 223 +++++++++++++++++-----------------
 3 files changed, 231 insertions(+), 238 deletions(-)

diff --git a/tests/matrix-set-all.lisp b/tests/matrix-set-all.lisp
index ce578211..8a00ca0c 100644
--- a/tests/matrix-set-all.lisp
+++ b/tests/matrix-set-all.lisp
@@ -88,6 +88,7 @@
                                 (MAKE-MARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
                                              '(3 3))))
                            (CL-ARRAY (SET-ALL M1 67)))))
+		       #+int64
                        (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
                         (MULTIPLE-VALUE-LIST
@@ -95,6 +96,7 @@
                                 (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS
                                              '(3 3))))
                            (CL-ARRAY (SET-ALL M1 -64)))))
+		       #+int64
                        (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-add.lisp b/tests/vector-add.lisp
index 171726ea..de759450 100644
--- a/tests/vector-add.lisp
+++ b/tests/vector-add.lisp
@@ -3,125 +3,127 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-ADD
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                      '(-43.43 42.36 -2.8600001)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
-                               (V2
-                                (MAKE-MARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                      '(-43.43d0 42.36d0
-                                        -2.8600000000000003d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0)))
-                               (V2
-                                (MAKE-MARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93d0 34.12d0 -6.15d0))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                      '(101 -16 61)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71)))
-                               (V2
-                                (MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-91 52 -10))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(UNSIGNED-BYTE 8) :INITIAL-CONTENTS
-                                      '(183 207 73)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(SIGNED-BYTE 16) :INITIAL-CONTENTS
-                                      '(-155 -16 61)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(-64 -68 71)))
-                               (V2
-                                (MAKE-MARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(-91 52 -10))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(UNSIGNED-BYTE 16) :INITIAL-CONTENTS
-                                      '(183 207 329)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(SIGNED-BYTE 32) :INITIAL-CONTENTS
-                                      '(-155 -16 61)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(-64 -68 71)))
-                               (V2
-                                (MAKE-MARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(-91 52 -10))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(UNSIGNED-BYTE 32) :INITIAL-CONTENTS
-                                      '(183 207 329)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(SIGNED-BYTE 64) :INITIAL-CONTENTS
-                                      '(-155 -16 61)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(-64 -68 71)))
-                               (V2
-                                (MAKE-MARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(-91 52 -10))))
-                           (ELT+ V1 V2))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (MAKE-MARRAY '(UNSIGNED-BYTE 64) :INITIAL-CONTENTS
-                                      '(183 207 329)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (MAKE-MARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (ELT+ V1 V2)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+		 '(-43.43 42.36 -2.8600001)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+			'(-34.5 8.24 3.29)))
+	  (V2
+	   (MAKE-MARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+			'(-8.93 34.12 -6.15))))
+      (ELT+ V1 V2))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+		 '(-43.43d0 42.36d0
+		   -2.8600000000000003d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+			'(-34.5d0 8.24d0 3.29d0)))
+	  (V2
+	   (MAKE-MARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+			'(-8.93d0 34.12d0 -6.15d0))))
+      (ELT+ V1 V2))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+		 '(101 -16 61)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+			'(-64 -68 71)))
+	  (V2
+	   (MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+			'(-91 52 -10))))
+      (ELT+ V1 V2))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(UNSIGNED-BYTE 8) :INITIAL-CONTENTS
+		 '(183 207 73)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 8)
+			:INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 8)
+			:INITIAL-CONTENTS '(116 163 140))))
+      (ELT+ V1 V2))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(SIGNED-BYTE 16) :INITIAL-CONTENTS
+		 '(-155 -16 61)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(SIGNED-BYTE 16)
+			:INITIAL-CONTENTS '(-64 -68 71)))
+	  (V2
+	   (MAKE-MARRAY '(SIGNED-BYTE 16)
+			:INITIAL-CONTENTS '(-91 52 -10))))
+      (ELT+ V1 V2))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(UNSIGNED-BYTE 16) :INITIAL-CONTENTS
+		 '(183 207 329)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 16)
+			:INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 16)
+			:INITIAL-CONTENTS '(116 163 140))))
+      (ELT+ V1 V2))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(SIGNED-BYTE 32) :INITIAL-CONTENTS
+		 '(-155 -16 61)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(SIGNED-BYTE 32)
+			:INITIAL-CONTENTS '(-64 -68 71)))
+	  (V2
+	   (MAKE-MARRAY '(SIGNED-BYTE 32)
+			:INITIAL-CONTENTS '(-91 52 -10))))
+      (ELT+ V1 V2))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(UNSIGNED-BYTE 32) :INITIAL-CONTENTS
+		 '(183 207 329)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 32)
+			:INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 32)
+			:INITIAL-CONTENTS '(116 163 140))))
+      (ELT+ V1 V2))))
+  #+int64
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(SIGNED-BYTE 64) :INITIAL-CONTENTS
+		 '(-155 -16 61)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(SIGNED-BYTE 64)
+			:INITIAL-CONTENTS '(-64 -68 71)))
+	  (V2
+	   (MAKE-MARRAY '(SIGNED-BYTE 64)
+			:INITIAL-CONTENTS '(-91 52 -10))))
+      (ELT+ V1 V2))))
+  #+int64
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (MAKE-MARRAY '(UNSIGNED-BYTE 64) :INITIAL-CONTENTS
+		 '(183 207 329)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 64)
+			:INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (MAKE-MARRAY '(UNSIGNED-BYTE 64)
+			:INITIAL-CONTENTS '(116 163 140))))
+      (ELT+ V1 V2)))))
 
diff --git a/tests/vector-set-all.lisp b/tests/vector-set-all.lisp
index 331e3dfe..4b3b6537 100644
--- a/tests/vector-set-all.lisp
+++ b/tests/vector-set-all.lisp
@@ -3,120 +3,109 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SET-ALL
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5 -34.5 -34.5))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1 (MAKE-MARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-                           (CL-ARRAY (SET-ALL V1 -34.5)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5d0 -34.5d0 -34.5d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1 (MAKE-MARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-                           (CL-ARRAY (SET-ALL V1 -34.5d0)))))
-		       #+fsbv
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #(#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (CL-ARRAY (SET-ALL V1 #C(-34.5 8.24))))))
-		       #+fsbv
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
-                           #C(-34.5d0 8.24d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (MAKE-MARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (CL-ARRAY (SET-ALL V1 #C(-34.5d0 8.24d0))))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(SIGNED-BYTE
-                                                                    8)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      -64)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(UNSIGNED-BYTE
-                                                                    8)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      67)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(SIGNED-BYTE
-                                                                    16)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      -64)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(UNSIGNED-BYTE
-                                                                    16)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      67)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(SIGNED-BYTE
-                                                                    32)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      -64)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(UNSIGNED-BYTE
-                                                                    32)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      67)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(SIGNED-BYTE
-                                                                    64)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      -64)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
-                                                         (MULTIPLE-VALUE-LIST
-                                                          (LET ((V1
-                                                                 (MAKE-MARRAY
-                                                                  '(UNSIGNED-BYTE
-                                                                    64)
-                                                                  :DIMENSIONS
-                                                                  '3)))
-                                                            (CL-ARRAY
-                                                             (SET-ALL V1
-                                                                      67))))))
-
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #(-34.5 -34.5 -34.5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (MAKE-MARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
+      (CL-ARRAY (SET-ALL V1 -34.5)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #(-34.5d0 -34.5d0 -34.5d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (MAKE-MARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
+      (CL-ARRAY (SET-ALL V1 -34.5d0)))))
+  #+fsbv
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #(#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(COMPLEX SINGLE-FLOAT)
+			:DIMENSIONS '3)))
+      (CL-ARRAY (SET-ALL V1 #C(-34.5 8.24))))))
+  #+fsbv
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
+      #C(-34.5d0 8.24d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (MAKE-MARRAY '(COMPLEX DOUBLE-FLOAT)
+			:DIMENSIONS '3)))
+      (CL-ARRAY (SET-ALL V1 #C(-34.5d0 8.24d0))))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
+				    (MULTIPLE-VALUE-LIST
+				     (LET ((V1
+					    (MAKE-MARRAY
+					     '(SIGNED-BYTE
+					       8)
+					     :DIMENSIONS
+					     '3)))
+				       (CL-ARRAY
+					(SET-ALL V1
+						 -64)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
+				    (MULTIPLE-VALUE-LIST
+				     (LET ((V1
+					    (MAKE-MARRAY
+					     '(UNSIGNED-BYTE
+					       8)
+					     :DIMENSIONS
+					     '3)))
+				       (CL-ARRAY
+					(SET-ALL V1
+						 67)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
+				    (MULTIPLE-VALUE-LIST
+				     (LET ((V1
+					    (MAKE-MARRAY
+					     '(SIGNED-BYTE
+					       16)
+					     :DIMENSIONS
+					     '3)))
+				       (CL-ARRAY
+					(SET-ALL V1
+						 -64)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
+				    (MULTIPLE-VALUE-LIST
+				     (LET ((V1
+					    (MAKE-MARRAY
+					     '(UNSIGNED-BYTE
+					       16)
+					     :DIMENSIONS
+					     '3)))
+				       (CL-ARRAY
+					(SET-ALL V1
+						 67)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
+				    (MULTIPLE-VALUE-LIST
+				     (LET ((V1
+					    (MAKE-MARRAY
+					     '(SIGNED-BYTE
+					       32)
+					     :DIMENSIONS
+					     '3)))
+				       (CL-ARRAY
+					(SET-ALL V1
+						 -64)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
+				    (MULTIPLE-VALUE-LIST
+				     (LET ((V1
+					    (MAKE-MARRAY
+					     '(UNSIGNED-BYTE
+					       32)
+					     :DIMENSIONS
+					     '3)))
+				       (CL-ARRAY
+					(SET-ALL V1
+						 67)))))
+  #+int64
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #(-64 -64 -64))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS '3)))
+      (CL-ARRAY (SET-ALL V1 -64)))))
+  #+int64
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #(67 67 67))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (MAKE-MARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS '3)))
+      (CL-ARRAY (SET-ALL V1 67))))))
-- 
GitLab