(setq T:number 1)
(setq T:failures 0)
(setq T:pass 1)
(setq T:name "test")

(defunq test (name)
  ;; (if (= T:number 0) (print T:name "has not been tested\n"))
  (setq T:name name)
  (setq T:number 0))

(defunq T (T:Expr T:Result)
  (? T:name "_" (setq T:number (+ T:number 1)))
  (if (= (setq T:expr (eval T:Expr)) (setq T:result (eval T:Result)))
    (? " Ok.\n")
    (progn
      (setq T:failures (+ T:failures 1))
      (? " \x07FAILED\x07!\nEvaluating: " T:Expr
	"\nExpecting: " T:result
	"\n Returned: " T:expr "\n"
))))

;; Predicate evaluated with the result of the tested func un T:result
;; and must return t (OK) or () (FAILED)
(defunq TP (T:Expr T:Predicate &aux T:result)
  (? T:name "_" (setq T:number (+ T:number 1)))
  (setq T:result (eval T:Expr))
  (if (eval T:Predicate)
    (? " Ok.\n")
    (progn
      (setq T:failures (+ T:failures 1))
      (? " \x07FAILED\x07!\nEvaluating: " T:Expr
	"\n Returned: " T:result "\n"
))))

(defun T:no-error (errorcode &rest args)
  (setq T:Errres errorcode)
  :true
)

(defunq E (expr err)
  (setq T:Errres ())
  (with (*error-handlers* T:no-error)
    (catch 'ERROR (eval expr))
  )
  (? T:name "_"(setq T:number (+ T:number 1)))
  (if (= T:Errres err)
    (? " Ok.\n")
    (progn
      (setq T:failures (+ T:failures 1))
      (? " \x07FAILED\x07!\nEvaluating: " expr
	"\nExpecting Error: " err
	"\nReturned: " T:Errres "\n"
))))


(defun P (value)
  (with (a "")
    (write value (open a :type :string))
    a))

(defun test-end ()
  (if (= 0 T:failures)
    (progn
      (print-format "*** Ok ***\nDone in %0 and %1 ms\n" T:t0 T:t1)
      (if (not (boundp 'do-no-exit-after-test))
	(exit)
      )
    )
    (progn
      (print-format "***** [%0] FAILURES!!!\x07 in %1 passes (%2 per pass) *****\n" 
	T:failures T:pass (/ T:failures T:pass))
)))

;; eqset-plist: checks if 2 plists are the same, even in different order

(defun eqset-plist (l1 l2 &aux
    (l (copy l2))
    (result t)
  )
  (dohash (k v l1)
    (if (= (get l k :nil) v) 	; k,v is there in l2
      (delete l k)
      (setq result ())       	; otherwise, they differ
  ))
  (if l (setq result ()))	; l2 has more elts than l1
  result
)

(defun eqset-list (l1 l2 &aux
    (l (copy l2))
    (result t)
  )
  (map ()
    (lambda (k &aux (pos (position k l)))
      (if pos 			; k is there in l2
        (delete l pos)
	(setq result ())       	; otherwise, they differ
      ))
    l1
  )
  (if l (setq result ()))	; l2 has more elts than l1
  result
)