+
+;;; class as :metaclass
+(assert (typep
+ (sb-mop:ensure-class-using-class
+ nil 'class-as-metaclass-test
+ :metaclass (find-class 'standard-class)
+ :name 'class-as-metaclass-test
+ :direct-superclasses (list (find-class 'standard-object)))
+ 'class))
+\f
+;;; COMPUTE-DEFAULT-INITARGS protocol mismatch reported by Bruno
+;;; Haible
+(defparameter *extra-initarg-value* 'extra)
+(defclass custom-default-initargs-class (standard-class)
+ ())
+(defmethod compute-default-initargs ((class custom-default-initargs-class))
+ (let ((original-default-initargs
+ (remove-duplicates
+ (reduce #'append
+ (mapcar #'class-direct-default-initargs
+ (class-precedence-list class)))
+ :key #'car
+ :from-end t)))
+ (cons (list ':extra '*extra-initarg-value* #'(lambda () *extra-initarg-value*))
+ (remove ':extra original-default-initargs :key #'car))))
+(defmethod validate-superclass ((c1 custom-default-initargs-class)
+ (c2 standard-class))
+ t)
+(defclass extra-initarg ()
+ ((slot :initarg :extra))
+ (:metaclass custom-default-initargs-class))
+(assert (eq (slot-value (make-instance 'extra-initarg) 'slot) 'extra))
+\f
+;;; STANDARD-CLASS valid as a superclass for FUNCALLABLE-STANDARD-CLASS
+(defclass standard-class-for-fsc ()
+ ((scforfsc-slot :initarg :scforfsc-slot :accessor scforfsc-slot)))
+(defvar *standard-class-for-fsc*
+ (make-instance 'standard-class-for-fsc :scforfsc-slot 1))
+(defclass fsc-with-standard-class-superclass
+ (standard-class-for-fsc funcallable-standard-object)
+ ((fsc-slot :initarg :fsc-slot :accessor fsc-slot))
+ (:metaclass funcallable-standard-class))
+(defvar *fsc/scs*
+ (make-instance 'fsc-with-standard-class-superclass
+ :scforfsc-slot 2
+ :fsc-slot 3))
+(assert (= (scforfsc-slot *standard-class-for-fsc*) 1))
+(assert (= (scforfsc-slot *fsc/scs*) 2))
+(assert (= (fsc-slot *fsc/scs*) 3))
+(assert (subtypep 'fsc-with-standard-class-superclass 'function))
+(assert (not (subtypep 'standard-class-for-fsc 'function)))
+
+;;; also check that our sanity check for functionness is good
+(assert (raises-error?
+ (progn
+ (defclass bad-standard-class (funcallable-standard-object)
+ ()
+ (:metaclass standard-class))
+ (make-instance 'bad-standard-class))))
+(assert (raises-error?
+ (progn
+ (defclass bad-funcallable-standard-class (standard-object)
+ ()
+ (:metaclass funcallable-standard-class))
+ (make-instance 'bad-funcallable-standard-class))))
+\f
+;;; we should be able to make classes with silly names
+(make-instance 'standard-class :name 3)
+(defclass foo () ())
+(reinitialize-instance (find-class 'foo) :name '(a b))
+\f
+;;; classes (including anonymous ones) and eql-specializers should be
+;;; allowed to be specializers.
+(defvar *anonymous-class*
+ (make-instance 'standard-class
+ :direct-superclasses (list (find-class 'standard-object))))
+(defvar *object-of-anonymous-class*
+ (make-instance *anonymous-class*))
+(eval `(defmethod method-on-anonymous-class ((obj ,*anonymous-class*)) 41))
+(assert (eql (method-on-anonymous-class *object-of-anonymous-class*) 41))
+(eval `(defmethod method-on-anonymous-class
+ ((obj ,(intern-eql-specializer *object-of-anonymous-class*)))
+ 42))
+(assert (eql (method-on-anonymous-class *object-of-anonymous-class*) 42))
+\f
+;;; accessors can cause early finalization, which caused confusion in
+;;; the system, leading to uncompileable TYPEP problems.
+(defclass funcallable-class-for-typep ()
+ ((some-slot-with-accessor :accessor some-slot-with-accessor))
+ (:metaclass funcallable-standard-class))
+(compile nil '(lambda (x) (typep x 'funcallable-class-for-typep)))
+\f
+;;; even anonymous classes should be valid types
+(let* ((class1 (make-instance 'standard-class :direct-superclasses (list (find-class 'standard-object))))
+ (class2 (make-instance 'standard-class :direct-superclasses (list class1))))
+ (assert (subtypep class2 class1))
+ (assert (typep (make-instance class2) class1)))
+\f
+;;; ensure-class got its treatment of :metaclass wrong.
+(ensure-class 'better-be-standard-class :direct-superclasses '(standard-object)
+ :metaclass 'standard-class
+ :metaclass 'funcallable-standard-class)
+(assert (eq (class-of (find-class 'better-be-standard-class))
+ (find-class 'standard-class)))
+
+;;; CLASS-SLOTS should signal an error for classes that are not yet
+;;; finalized. Reported by Levente Meszaros on sbcl-devel.
+(defclass has-slots-but-isnt-finalized () (a b c))
+(let ((class (find-class 'has-slots-but-isnt-finalized)))
+ (assert (not (sb-mop:class-finalized-p class)))
+ (assert (raises-error? (sb-mop:class-slots class) sb-kernel::reference-condition)))