contrib/sb-aclrepl/aclrepl-tests.lisp

   1 ;; Tests for sb-aclrepl
   2
   3 (defpackage #:aclrepl-tests (:use #:sb-aclrepl #:cl))
   4 (in-package #:aclrepl-tests)
   5
   6 (import '(sb-aclrepl::inspected-parts sb-aclrepl::inspected-description
   7           sb-aclrepl::inspected-elements sb-aclrepl::parts-count
   8           sb-aclrepl::parts-seq-type sb-aclrepl::find-part-id
   9           sb-aclrepl::element-at sb-aclrepl::label-at
  10           sb-aclrepl::display-inspected-parts
  11           sb-aclrepl::display-labeled-element
  12           sb-aclrepl::*inspect-unbound-object-marker*))
  13
  14 (eval-when (:compile-toplevel :load-toplevel :execute)
  15   (unless (find-package 'regression-test)
  16     (load (sb-aclrepl::compile-file-as-needed "rt.lisp"))))
  17 (use-package :regression-test)
  18 (setf regression-test::*catch-errors* nil)
  19
  20 (rem-all-tests)
  21
  22 (deftest hook.1 (boundp 'sb-impl::*inspect-fun*) t)
  23 (deftest hook.2 (boundp 'sb-int:*repl-prompt-fun*) t)
  24 (deftest hook.3 (boundp 'sb-int:*repl-read-form-fun*) t)
  25 ;(deftest (boundp 'sb-debug::*invoke-debugger-fun*) t)
  26
  27 ;;; Inspector tests
  28
  29 (defclass empty-class ()
  30   ())
  31 (defparameter *empty-class* (make-instance 'empty-class))
  32
  33 (defclass empty-class ()
  34   ())
  35
  36 (defclass simple-class ()
  37   ((a)
  38    (second :initform 0)
  39    (really-long-slot-name :initform "abc")))
  40
  41 (defstruct empty-struct
  42   )
  43
  44 (defstruct tiny-struct
  45   (first 10))
  46
  47 (defstruct simple-struct
  48   (first)
  49   (slot-2 'a-value)
  50   (really-long-struct-slot-name "defg"))
  51
  52 (defparameter *empty-class* (make-instance 'empty-class))
  53 (defparameter *simple-class* (make-instance 'simple-class))
  54 (defparameter *empty-struct* (make-empty-struct))
  55 (defparameter *tiny-struct* (make-tiny-struct))
  56 (defparameter *simple-struct* (make-simple-struct))
  57 (defparameter *normal-list* '(a b 3))
  58 (defparameter *dotted-list* '(a b . 3))
  59 (defparameter *cons-pair* '(#c(1 2) . a-symbol))
  60 (defparameter *complex* #c(1 2))
  61 (defparameter *ratio* 22/7)
  62 (defparameter *double* 5.5d0)
  63 (defparameter *array* (make-array '(3 3 2) :initial-element nil))
  64 (defparameter *vector* (make-array '(20):initial-contents
  65                              '(0 1 2 3 4 5 6 7 8 9
  66                                10 11 12 13 14 15 16 17 18 19)))
  67
  68 (defun find-position (object id)
  69     (nth-value 0 (find-part-id object id)))
  70 (defun parts (object)
  71     (inspected-parts object))
  72 (defun description (object)
  73   (inspected-description object))
  74 (defun elements (object &optional print (skip 0))
  75   (nth-value 0 (inspected-elements object print skip )))
  76 (defun elements-labels (object &optional print (skip 0))
  77   (nth-value 1 (inspected-elements object print skip)))
  78 (defun elements-count (object &optional print (skip 0))
  79   (nth-value 2 (inspected-elements object print skip)))
  80
  81 (defun labeled-element (object pos &optional print (skip 0))
  82   (with-output-to-string (strm)
  83     (display-labeled-element
  84      (aref (the simple-vector (elements object print skip)) pos)
  85      (aref (the simple-vector (elements-labels object print skip)) pos)
  86      strm)))
  87
  88 (deftest find.list.0 (find-position *normal-list* 0) 0)
  89 (deftest find.list.1 (find-position *normal-list* 0) 0)
  90 (deftest find.list.2 (find-position *normal-list* 1) 1)
  91 (deftest find.list.3 (find-position *normal-list* 2) 2)
  92 (deftest parts.list.1 (parts-count (parts *normal-list*)) 3)
  93 (deftest parts.list.2 (element-at (parts *normal-list*) 0) a)
  94 (deftest parts.list.3 (element-at (parts *normal-list*) 1) b)
  95 (deftest parts.list.4 (element-at (parts *normal-list*) 2) 3)
  96 (deftest parts.list.5 (label-at (parts *normal-list*) 0) 0)
  97 (deftest parts.list.6 (label-at (parts *normal-list*) 1) 1)
  98 (deftest parts.list.7 (label-at (parts *normal-list*) 2) 2)
  99 (deftest parts.list.8 (parts-seq-type (parts *normal-list*)) :list)
 100
 101 (deftest elem.list.0 (elements-count *normal-list*) 3)
 102 (deftest elem.list.1 (elements *normal-list*) #(a b 3))
 103 (deftest elem.list.2 (elements-labels *normal-list*) #(0 1 2))
 104
 105 (deftest elem.dotted.0 (elements-count *dotted-list*) 3)
 106 (deftest elem.dotted.1 (elements *dotted-list*) #(a b 3))
 107 (deftest elem.dotted.2 (elements-labels *dotted-list*) #(0 1 :tail))
 108
 109 (deftest elem.consp.0 (elements-count *cons-pair*) 2)
 110 (deftest elem.consp.1 (elements *cons-pair*) #(#c(1 2) a-symbol))
 111 (deftest elem.consp.2 (elements-labels *cons-pair*)
 112   #((0 . "car") (1 . "cdr")))
 113
 114 (deftest elem.complex.0 (elements-count *complex*) 2)
 115 (deftest elem.complex.1 (elements *complex*) #(1 2))
 116 (deftest elem.complex.2 (elements-labels *complex*)
 117   #((0 . "real") (1 . "imag")))
 118
 119 (deftest elem.ratio.0 (elements-count *ratio*) 2)
 120 (deftest elem.ratio.1 (elements *ratio*) #(22 7))
 121 (deftest elem.ratio.2 (elements-labels *ratio*)
 122   #((0 . "numerator") (1 . "denominator")))
 123
 124 (deftest elem.vector.0 (elements-count *vector*) 20)
 125 (deftest elem.vector.1 (elements *vector*)
 126   #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19))
 127 (deftest elem.vector.2 (elements-labels *vector*)
 128   #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19))
 129
 130 (deftest elem.vector.skip1.0 (elements-count *vector* nil 3) 18)
 131 (deftest elem.vector.skip1.1 (elements *vector* nil 3)
 132   #(nil 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19))
 133 (deftest elem.vector.skip1.2 (elements-labels *vector* nil 3)
 134   #(:ellipses 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19))
 135
 136 (deftest elem.vector.skip2.0 (elements-count *vector* 10 3) 13)
 137 (deftest elem.vector.skip2.1 (elements *vector* 10 3)
 138   #(nil 3 4 5 6 7 8 9 10 11 12 nil 19))
 139 (deftest elem.vector.skip2.2 (elements-labels *vector* 10 3)
 140   #(:ellipses 3 4 5 6 7 8 9 10 11 12 :ellipses 19))
 141
 142 (deftest elem.vector.skip3.0 (elements-count *vector* 5 16) 5)
 143 (deftest elem.vector.skip3.1 (elements *vector* 5 16)
 144   #(nil 16 17 18 19))
 145 (deftest elem.vector.skip3.2 (elements-labels *vector* 5 16)
 146   #(:ellipses 16 17 18 19))
 147
 148 (deftest elem.vector.skip4.0 (elements-count *vector* 2 16) 5)
 149 (deftest elem.vector.skip4.1 (elements *vector* 2 16)
 150   #(nil 16 17 18 19))
 151 (deftest elem.vector.skip4.2 (elements-labels *vector* 2 16)
 152   #(:ellipses 16 17 18 19))
 153
 154 (deftest elem.vector.skip5.0 (elements-count *vector* 2 15) 5)
 155 (deftest elem.vector.skip5.1 (elements *vector* 2 15)
 156   #(nil 15 16 nil 19))
 157 (deftest elem.vector.skip5.2 (elements-labels *vector* 2 15)
 158   #(:ellipses 15 16 :ellipses 19))
 159
 160 (deftest elem.array.0 (elements-count *array*) 18)
 161 (deftest elem.array.1 (elements *array*)
 162    #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL
 163                 NIL NIL))
 164 (deftest elem.array.2 (elements-labels *array*)
 165   #((0 . "[0,0,0]") (1 . "[0,0,1]") (2 . "[0,1,0]") (3 . "[0,1,1]")
 166     (4 . "[0,2,0]") (5 . "[0,2,1]") (6 . "[1,0,0]") (7 . "[1,0,1]")
 167     (8 . "[1,1,0]") (9 . "[1,1,1]") (10 . "[1,2,0]")
 168     (11 . "[1,2,1]") (12 . "[2,0,0]") (13 . "[2,0,1]")
 169     (14 . "[2,1,0]") (15 . "[2,1,1]") (16 . "[2,2,0]")
 170     (17 . "[2,2,1]")))
 171
 172 (deftest empty.class.0 (elements-count *empty-class*) 0)
 173 (deftest empty.class.1 (elements *empty-class*) nil)
 174 (deftest empty.class.2 (elements-labels *empty-class*) nil)
 175
 176 (deftest simple.class.0 (elements-count *simple-class*) 3)
 177 (deftest simple.class.1 (elements *simple-class*)
 178   #(#.*inspect-unbound-object-marker* 0 "abc"))
 179 (deftest simple.class.2 (elements-labels *simple-class*)
 180   #((0 . "A") (1 . "SECOND") (2 . "REALLY-LONG-SLOT-NAME")))
 181
 182 (deftest empty.struct.0 (elements-count *empty-struct*) 0)
 183 (deftest empty.struct.1 (elements *empty-struct*) nil)
 184 (deftest empty.struct.2 (elements-labels *empty-struct*) nil)
 185
 186 (deftest simple.struct.0 (elements-count *simple-struct*) 3)
 187 (deftest simple.struct.1 (elements *simple-struct*)
 188   #(nil a-value "defg"))
 189 (deftest simple.struct.2 (elements-labels *simple-struct*)
 190   #((0 . "FIRST") (1 . "SLOT-2")
 191     (2 . "REALLY-LONG-STRUCT-SLOT-NAME")))
 192
 193 (deftest display.simple-struct.0 (labeled-element *simple-struct* 0)
 194   "   0 FIRST ----------> the symbol NIL")
 195 (deftest display.simple-struct.1 (labeled-element *simple-struct* 1)
 196   "   1 SLOT-2 ---------> the symbol A-VALUE")
 197 (deftest display.simple-struct.2 (labeled-element *simple-struct* 2)
 198   "   2 REALLY-LONG-STRUCT-SLOT-NAME -> a simple-string (4) \"defg\"")
 199
 200 (deftest display.simple-class.0 (labeled-element *simple-class* 0)
 201   "   0 A --------------> ..unbound..")
 202 (deftest display.simple-class.1 (labeled-element *simple-class* 1)
 203   "   1 SECOND ---------> fixnum 0")
 204 (deftest display.simple-class.2 (labeled-element *simple-class* 2)
 205   "   2 REALLY-LONG-SLOT-NAME -> a simple-string (3) \"abc\"")
 206
 207 (deftest display.complex.0 (labeled-element *complex* 0)
 208   "   0 real -----------> fixnum 1")
 209 (deftest display.complex.1 (labeled-element *complex* 1)
 210   "   1 imag -----------> fixnum 2")
 211
 212 (deftest display.ratio.0 (labeled-element *ratio* 0)
 213   "   0 numerator ------> fixnum 22")
 214 (deftest display.ratio.1 (labeled-element *ratio* 1)
 215   "   1 denominator ----> fixnum 7")
 216
 217 (deftest display.dotted-list.0 (labeled-element *dotted-list* 0)
 218   "   0-> the symbol A")
 219 (deftest display.dotted-list.1 (labeled-element *dotted-list* 1)
 220   "   1-> the symbol B")
 221 (deftest display.dotted-list.2 (labeled-element *dotted-list* 2)
 222   "tail-> fixnum 3")
 223
 224 (deftest display.normal-list.0
 225     (labeled-element *normal-list* 0)
 226   "   0-> the symbol A")
 227 (deftest display.normal-list.1 (labeled-element *normal-list* 1)
 228   "   1-> the symbol B")
 229 (deftest display.normal-list.2 (labeled-element *normal-list* 2)
 230   "   2-> fixnum 3")
 231
 232
 233 (deftest display.vector.0 (labeled-element *vector* 0)
 234   "   0-> fixnum 0")
 235 (deftest display.vector.1 (labeled-element *vector* 1)
 236   "   1-> fixnum 1")
 237
 238 (deftest display.vector.skip1.0 (labeled-element *vector* 0 nil 2)
 239   "   ...")
 240 (deftest display.vector.skip1.1 (labeled-element *vector* 1 nil 2)
 241   "   2-> fixnum 2")
 242
 243 (deftest display.consp.0 (labeled-element *cons-pair* 0)
 244   "   0 car ------------> complex number #C(1 2)")
 245 (deftest display.consp.1 (labeled-element *cons-pair* 1)
 246   "   1 cdr ------------> the symbol A-SYMBOL")
 247
 248 (deftest nil.parts.0 (elements-count nil) 5)
 249
 250 (deftest tiny.struct.0 (elements-count *tiny-struct*) 1)
 251 (deftest tiny.struct.1 (elements *tiny-struct*) #(10))
 252 (deftest tiny.struct.1 (elements-labels *tiny-struct*) #((0 . "FIRST")))
 253
 254 (deftest tiny.struct.skip1.0 (elements-count *tiny-struct* nil 1) 1)
 255 (deftest tiny.struct.skip1.1 (elements *tiny-struct* nil 1)
 256   #(nil))
 257 (deftest tiny.struct.skip1.2 (elements-labels *tiny-struct* nil 1)
 258   #(:ellipses))
 259
 260 (deftest tiny.double.0 (elements-count *double*) 0)
 261
 262 (deftest tiny.double.skip1.0 (elements-count *double* nil 1) 0)
 263 (deftest tiny.double.skip1.1 (elements *double* nil 0)
 264   nil)
 265 (deftest tiny.doubel.skip1.2 (elements-labels *double* nil 1)
 266   nil)
 267
 268
 269
 270 (do-tests)
 271
 272 (when (pending-tests)
 273   (error "Some tests failed."))
 274