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: 
  (in-package :cl-user)
  (uiop:define-package class-star/tests
    (:use #:common-lisp)
    (:import-from #:class-star))
  (in-package :class-star/tests)
  
  (prove:plan nil)
  
  (prove:subtest "Simple class"
    (prove:is (progn
                (class-star:define-class foo ()
                  ((name "fooname")))
                (let ((foo (make-instance 'foo)))
                  (name-of foo)))
              "fooname"))
  
  (prove:subtest "Simple class with custom accessors"
    (class-star:define-class bar ()
      ((name "fooname")
       (age :accessor this-age)
       (address :accessor nil))
      (:accessor-name-transformer (lambda (name def) (declare (ignore def)) name)))
    (make-instance 'bar)
    (prove:ok (fboundp 'name))
    (prove:ok (fboundp 'this-age))
    (prove:is (fboundp 'address) nil))
  
  (prove:subtest "Simple class default value"
    (prove:is (progn
                (class-star:define-class foo-default ()
                  ((name :type string)
                   (age :type number)))
  
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)
  