contrib/sb-introspect/test-driver.lisp

   1 (require :sb-introspect)
   2
   3 (defpackage :sb-introspect-test
   4   (:use "SB-INTROSPECT" "CL"))
   5 (in-package :sb-introspect-test)
   6
   7 (with-compilation-unit (:source-plist (list :test-outer "OUT"))
   8   (load (compile-file (merge-pathnames "test.lisp" *load-pathname*))))
   9
  10 (assert (equal (function-lambda-list 'cl-user::one)
  11                '(cl-user::a cl-user::b cl-user::c)))
  12 (assert (equal (function-lambda-list 'the)
  13                '(sb-c::value-type sb-c::form)))
  14
  15 (assert (equal (function-lambda-list #'(sb-pcl::slow-method cl-user::j (t)))
  16                '(sb-pcl::method-args sb-pcl::next-methods)))
  17
  18 (let ((source (find-definition-source #'cl-user::one)))
  19   (assert (= (definition-source-file-write-date source)
  20              (file-write-date (merge-pathnames "test.lisp" *load-pathname*))))
  21   (assert (equal (getf (definition-source-plist source) :test-outer)
  22                  "OUT")))
  23
  24 (let ((plist (definition-source-plist
  25                  (find-definition-source #'cl-user::four))))
  26   (assert (equal (getf plist :test-outer) "OUT"))
  27   (assert (equal (getf plist :test-inner) "IN")))
  28
  29 (defun matchp (object form-number)
  30   (let ((ds (sb-introspect:find-definition-source object)))
  31     (and (pathnamep (sb-introspect:definition-source-pathname ds))
  32          (= form-number
  33             (first (sb-introspect:definition-source-form-path ds))))))
  34
  35 (defun matchp-name (type object form-number)
  36   (let ((ds (car (sb-introspect:find-definition-sources-by-name object type))))
  37     (and (pathnamep (sb-introspect:definition-source-pathname ds))
  38          (= form-number
  39             (first (sb-introspect:definition-source-form-path ds))))))
  40
  41 (defun matchp-length (type object form-numbers)
  42   (let ((ds (sb-introspect:find-definition-sources-by-name object type)))
  43     (= (length ds) form-numbers)))
  44
  45 (assert (matchp-name :function 'cl-user::one 2))
  46 (assert (matchp #'cl-user::one 2))
  47 (assert (matchp-name :generic-function 'cl-user::two 3))
  48 (assert (matchp (car (sb-pcl:generic-function-methods #'cl-user::two)) 4))
  49
  50 (assert (matchp-name :variable 'cl-user::*a* 8))
  51 (assert (matchp-name :variable 'cl-user::*b* 9))
  52 (assert (matchp-name :class 'cl-user::a 10))
  53 (assert (matchp-name :condition 'cl-user::b 11))
  54 (assert (matchp-name :structure 'cl-user::c 12))
  55 (assert (matchp-name :function 'cl-user::make-c 12))
  56 (assert (matchp-name :function 'cl-user::c-e 12))
  57 (assert (matchp-name :structure 'cl-user::d 13))
  58 (assert (matchp-name :function 'cl-user::make-d 13))
  59 (assert (matchp-name :function 'cl-user::d-e 13))
  60 (assert (matchp-name :package 'cl-user::e 14))
  61 (assert (matchp-name :symbol-macro 'cl-user::f 15))
  62 (assert (matchp-name :type 'cl-user::g 16))
  63 (assert (matchp-name :constant 'cl-user::+h+ 17))
  64 (assert (matchp-length :method 'cl-user::j 2))
  65 (assert (matchp-name :macro 'cl-user::l 20))
  66 (assert (matchp-name :compiler-macro 'cl-user::m 21))
  67 (assert (matchp-name :setf-expander 'cl-user::n 22))
  68 (assert (matchp-name :function  '(setf cl-user::o) 23))
  69 (assert (matchp-name :method  '(setf cl-user::p) 24))
  70 (assert (matchp-name :macro  'cl-user::q 25))
  71 (assert (matchp-name :method-combination 'cl-user::r 26))
  72 (assert (matchp-name :setf-expander 'cl-user::s 27))
  73
  74 (let ((fin (make-instance 'sb-mop:funcallable-standard-object)))
  75   (sb-mop:set-funcallable-instance-function fin #'cl-user::one)
  76   (assert (matchp fin 2)))
  77
  78 (sb-profile:profile cl-user::one)
  79 (assert (matchp-name :function 'cl-user::one 2))
  80 (sb-profile:unprofile cl-user::one)
  81
  82
  83 ;;;; Check correctness of FUNCTION-LAMBDA-LIST.
  84
  85 (assert (equal (function-lambda-list 'cl-user::one)
  86                '(cl-user::a cl-user::b cl-user::c)))
  87 (assert (equal (function-lambda-list 'the)
  88                '(sb-c::value-type sb-c::form)))
  89
  90 ;;; Check wrt. interplay of generic functions and their methods.
  91
  92 (defgeneric xuuq (gf.a gf.b          &rest gf.rest &key gf.k-X))
  93 (defmethod  xuuq ((m1.a number) m1.b &rest m1.rest &key gf.k-X m1.k-Y m1.k-Z)
  94   (declare (ignore m1.a m1.b m1.rest gf.k-X m1.k-Y m1.k-Z))
  95   'm1)
  96 (defmethod  xuuq ((m2.a string) m2.b &rest m2.rest &key gf.k-X m1.k-Y m2.k-Q)
  97   (declare (ignore m2.a m2.b m2.rest gf.k-X m1.k-Y m2.k-Q))
  98   'm2)
  99
 100 ;; XUUQ's lambda list should look similiar to
 101 ;;
 102 ;;    (GF.A GF.B &REST GF.REST &KEY GF.K-X M1.K-Z M1.K-Y M2.K-Q)
 103 ;;
 104 (multiple-value-bind (required optional restp rest keyp keys allowp
 105                       auxp aux morep more-context more-count)
 106     (sb-int:parse-lambda-list (function-lambda-list #'xuuq))
 107   (assert (equal required '(gf.a gf.b)))
 108   (assert (null optional))
 109   (assert (and restp (eql rest 'gf.rest)))
 110   (assert (and keyp
 111                (member 'gf.k-X keys)
 112                (member 'm1.k-Y keys)
 113                (member 'm1.k-Z keys)
 114                (member 'm2.k-Q keys)))
 115   (assert (not allowp))
 116   (assert (and (not auxp) (null aux)))
 117   (assert (and (not morep) (null more-context) (not more-count))))
 118
 119 ;;; Check what happens when there's no explicit DEFGENERIC.
 120
 121 (defmethod kroolz (r1 r2 &optional opt &aux aux)
 122   (declare (ignore r1 r2 opt aux))
 123   'kroolz)
 124 (assert (equal (function-lambda-list #'kroolz) '(r1 r2 &optional opt)))
 125
 126 ;;;; Test finding a type that isn't one
 127 (assert (not (find-definition-sources-by-name 'fboundp :type)))
 128
 129 ;;;; Check correctness of DEFTYPE-LAMBDA-LIST.
 130 (deftype foobar-type
 131     (&whole w &environment e r1 r2 &optional o &rest rest &key k1 k2 k3)
 132   (declare (ignore w e r1 r2 o rest k1 k2 k3))
 133   nil)
 134
 135 (assert (multiple-value-bind (arglist found?) (deftype-lambda-list 'foobar-type)
 136           (and found?
 137                (equal arglist '(&whole w &environment e
 138                                 r1 r2 &optional o &rest rest &key k1 k2 k3)))))
 139
 140 (assert (equal (multiple-value-list (deftype-lambda-list (gensym)))
 141                '(nil nil)))
 142
 143
 144 ;;;; Test the xref facility
 145
 146 (load (merge-pathnames "xref-test.lisp" *load-pathname*))
 147
 148 ;;; Test allocation-information
 149
 150 (defun tai (x kind info)
 151   (multiple-value-bind (kind2 info2) (sb-introspect:allocation-information x)
 152     (unless (eq kind kind2)
 153       (error "wanted ~S, got ~S" kind kind2))
 154     (assert (equal info info2))))
 155
 156 (tai nil :heap '(:space :static))
 157 (tai t :heap '(:space :static))
 158 (tai 42 :immediate nil)
 159 (tai #'cons :heap
 160      #+(and (not ppc) gencgc)
 161      ;; FIXME: This is the canonical GENCGC result, the one below for PPC is
 162      ;; what we get there, but :LARGE T doesn't seem right. Figure out what's
 163      ;; going on.
 164      '(:space :dynamic :generation 6 :write-protected t :pinned nil :large nil)
 165      #+(and ppc gencgc)
 166      '(:space :dynamic :generation 6 :write-protected t :pinned nil :large t)
 167      ;; FIXME: Figure out what's the right cheney-result, and which platforms
 168      ;; return something else. The SPARC version here is what we get there,
 169      ;; but quite possibly that is the result on all non-GENCGC platforms.
 170      #+(and sparc (not gencgc))
 171      '(:space :read-only)
 172      #+(and (not sparc) (not gencgc))
 173      '(:space :dynamic))
 174 #+sb-thread
 175 (let ((x (list 1 2 3)))
 176   (declare (dynamic-extent x))
 177   (tai x :stack sb-thread:*current-thread*))
 178 #+sb-thread
 179 (progn
 180   (defun thread-tai ()
 181     (let ((x (list 1 2 3)))
 182       (declare (dynamic-extent x))
 183       (let ((child (sb-thread:make-thread
 184                     (lambda ()
 185                       (sb-introspect:allocation-information x)))))
 186         (assert (equal (list :stack sb-thread:*current-thread*)
 187                        (multiple-value-list (sb-thread:join-thread child)))))))
 188   (thread-tai)
 189   (defun thread-tai2 ()
 190     (let* ((sem (sb-thread:make-semaphore))
 191            (obj nil)
 192            (child (sb-thread:make-thread
 193                    (lambda ()
 194                      (let ((x (list 1 2 3)))
 195                        (declare (dynamic-extent x))
 196                        (setf obj x)
 197                        (sb-thread:wait-on-semaphore sem)))
 198                    :name "child")))
 199       (loop until obj)
 200       (assert (equal (list :stack child)
 201                      (multiple-value-list
 202                       (sb-introspect:allocation-information obj))))
 203       (sb-thread:signal-semaphore sem)
 204       (sb-thread:join-thread child)
 205       nil))
 206   (thread-tai2))
 207
 208 ;;;; Unix success convention for exit codes
 209 (sb-ext:quit :unix-status 0)
 210