anchor.diff:          (with alphabet-length = (length alphabet))
           (for i below length)
           (setf (cl:aref id i)
  -	      (cl:aref alphabet (random alphabet-length)))
  +              (cl:aref alphabet (random alphabet-length)))
           (finally (return id))))
   
   (defun info (message &rest arguments)
  
positive.code: 
  (defun make-test-data-instance (test-data &rest other-keywords)
    (let ((args (append (list 'grouped-list)
  		      test-data
  		      other-keywords)))
      (apply #'make-instance args)))
  
  (defparameter +test-timeclock-data+
  
negative.code:   (list
     :list
     (let ((alphabet (if (< num-rows (length +lower-case-ascii-alphabet+))
                         (subseq +lower-case-ascii-alphabet+
                                 0 (floor (+ 1 (/ num-rows 3))))
                         +lower-case-ascii-alphabet+)))
       (iter (for i from 1 to num-rows)
             (collect (apply #'vector
                             (iter (for i from 1 to depth)
                                   (collect
                                       (case (mod i 2)
                                         (0 (random-string
                                             (truncate (+ 1 (/ num-rows (length alphabet) 3)))
                                             alphabet))
                                         (1 (random (max (/ num-rows 10) 3))))))))))
     :keys (iter (for i from 0 below depth)
                 (collect (alexandria:rcurry #'elt i)))
     :tests (iter (for i from 1 to depth)
                  (collect
                      (case (mod i 2)
                        (0 #'string=)
                        (1 #'=))))))
  
  (defmethod print-object ((o grouped-list) s)
    ;; This is way slow so dont have this in live code and you might wish to undefine it
  