anchor.diff:  
   (in-package :cl-user)
   (uiop:define-package class-star/tests
  -  (:use #:common-lisp)
  +  (:use #:common-lisp #:prove)
     (:import-from #:class-star))
   (in-package :class-star/tests)
   
  -(prove:plan nil)
  +(plan nil)
   
  -(prove:subtest "Simple class"
  -  (prove:is (progn
  +(subtest "Simple class"
  +  (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"
  +(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))
  +  (ok (fboundp 'name))
  +  (ok (fboundp 'this-age))
  +  (is (fboundp 'address) nil))
   
  -(prove:subtest "Simple class default value"
  -  (prove:is (progn
  +(subtest "Simple class default value"
  +  (is (progn
                 (class-star:define-class foo-default ()
                   ((name :type string)
                    (age :type number)))
  
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: 
  ;; TODO: Fix following test and try to make it portable.
  #+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))
  
  (subtest "No accessor"
    (is (progn
                (class-star:define-class foo-no-accessors ()
                  ((name-no-acc :type string))
                  (:automatic-accessors-p nil))
  