anchor.diff:  
   ;; 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))
  +(subtest "No initarg"
  +  (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
  +(subtest "No accessor"
  +  (is (progn
                 (class-star:define-class foo-no-accessors ()
                   ((name-no-acc :type string))
                   (:automatic-accessors-p nil))
  
positive.code:               (fboundp 'name-no-acc-of))
              nil))
  
  (prove:subtest "Initform inference"
    (class-star:define-class foo-initform-infer ()
      ((name :type string)))
    (prove: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))
    (prove: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))
    (prove:is (name-of (make-instance 'foo-initform-infer-nil-fallback))
              nil))
  
  (defvar street-name "bar")
  (prove:subtest "Type inference"
    (class-star:define-class foo-type-infer ()
      ((name "foo")
       (nickname street-name)
  
negative.code: 
  (in-package :cl-user)
  (uiop:define-package class-star/tests
    (:use #:common-lisp #:prove)
    (:import-from #:class-star))
  (in-package :class-star/tests)
  
  (plan nil)
  
  (subtest "Simple class"
    (is (progn
                (class-star:define-class foo ()
                  ((name "fooname")))
                (let ((foo (make-instance 'foo)))
                  (name-of foo)))
              "fooname"))
  
  (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)
    (ok (fboundp 'name))
    (ok (fboundp 'this-age))
    (is (fboundp 'address) nil))
  
  (subtest "Simple class default value"
    (is (progn
                (class-star:define-class foo-default ()
                  ((name :type string)
                   (age :type number)))
  