anchor.diff:       (sym 'sims)
        (fun #'list)
        (composite (error "Should not eval, type should not be infered"))))
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'name) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'name) :type)
               'string)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'nickname) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'nickname) :type)
               'string)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'age) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'age) :type)
               'integer)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'height) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'height) :type)
               'number)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'width) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'width) :type)
               'number)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'lisper) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'lisper) :type)
               'boolean)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'empty-list) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'empty-list) :type)
               'list)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'nonempty-list) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'nonempty-list) :type)
               'list)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'sym) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'sym) :type)
               'symbol)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'fun) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'fun) :type)
               'function)
  -  (prove:is (getf (mopu:slot-properties 'foo-type-infer 'composite) :type)
  +  (is (getf (mopu:slot-properties 'foo-type-infer 'composite) :type)
               nil))
   
  -(prove:finalize)
  +(finalize)
  
positive.code: 
  ;; TODO: Fix following test and try to make it portable.
  #+nil
  (prove:subtest "No initarg"
    (prove:is-error (let ((hu.dwim.defclass-star:*automatic-initargs-p* nil))
                      (class-star:define-class foo-no-initarg ()
                        ((name :type string)))
                      (make-instance 'foo-no-initarg :name "bar"))
                    'sb-pcl::initarg-error))
  
  (prove:subtest "No accessor"
    (prove:is (progn
                (class-star:define-class foo-no-accessors ()
                  ((name-no-acc :type string))
                  (:automatic-accessors-p nil))
  
negative.code:               (fboundp 'name-no-acc-of))
              nil))
  
  (subtest "Initform inference"
    (class-star:define-class foo-initform-infer ()
      ((name :type string)))
    (is (name-of (make-instance 'foo-initform-infer))
              "")
    (class-star:define-class foo-initform-infer-no-unbound ()
      ((name :type function))
      (:initform-inference 'class-star:no-unbound-initform-inference))
    (is-error (make-instance 'foo-initform-infer-no-unbound)
                    'simple-error)
    (class-star:define-class foo-initform-infer-nil-fallback ()
      ((name :type (or function null)))
      (:initform-inference 'class-star:nil-fallback-initform-inference))
    (is (name-of (make-instance 'foo-initform-infer-nil-fallback))
              nil))
  
  (defvar street-name "bar")
  (subtest "Type inference"
    (class-star:define-class foo-type-infer ()
      ((name "foo")
       (nickname street-name)
  