anchor.diff:              until (eq item done)
               sum (if (a-test item titem) 1 0) into passed
               sum 1 into total
  -            finally (format t "~D of ~D tests passed~&" passed total))))))
  +            finally (progn
  +                      (format t "~D of ~D tests passed~&" passed total)
  +                      (return (values passed total))))))))
   
   (defun test-tnet-encode-decode ()
     (let ((tests
  
positive.code: (ql:quickload :tnetstring)
  (ql:quickload :cl-json)
  (defun compare-alists (a b)
    (and (equal (length a) (length b))
         (every (lambda (item) 
               (equalp item (assoc (car item) b))) a)))
  
  (defun my-compare (a b)
    (or (equalp a b)
            (and (consp a) (consp b)
                 (consp (car a)) (consp (car b))
                 (keywordp (caar a))
                 (keywordp (caar b))
                 (compare-alists a b))))
  
  (defun a-test (a b)
    (if (my-compare a b)
  
negative.code:       (time (dotimes (_ iters)
                (loop for item in tests do (json:decode-json-from-string item)))))))
  
  (defmacro run-tests (form)
    `(multiple-value-bind (a b) ,form
      (setq passed (+ passed a))
      (setq total (+ total b))))
  
  (let ((passed 0)
        (total 0)
        (a) (b))
    (run-tests (test-tnet-decode))
    (run-tests (test-tnet-encode-decode))
  
    (let ((tnetstring:*dict-decode-type* :hash-table))
      (run-tests (test-tnet-decode))
      (run-tests (test-tnet-encode-decode)))
    (format t "~&~A of ~A tests passed~&" passed total))
   
  (benchmark-encode 1000)
  (benchmark-decode 1000)
  (let ((tnetstring:*dict-decode-type* :hash-table))
  (benchmark-encode 1000)
  (benchmark-decode 1000))
  (benchmark-json-decode 1000)
  