;;; skiplists/run.scm

(require 'skiplists)
(import skiplists)


;;; (run xpr0 xpr1 ...)
;;; -------------------
(define (run . xprs)
  (let loop ((xprs xprs))
    (if (null? xprs)
      (print "All tests passed!")
      (if (car xprs)
        (loop (cdr xprs))
        (error 'run "#### Some test failed! ####")))))

;;; build a list of length n of random numbers between 0 and n
(define (random-list n)
  (let loop ((acc '()) (k n))
    (if (zero? k)
      acc
      (loop (cons (random n) acc) (- k 1)))))

;;; build the list of cardinals less than n
(define (enum n)
  (let loop ((acc '()) (k (- n 1)))
    (if (negative? k)
      acc
      (loop (cons k acc) (- k 1)))))

(define lst (random-list 60))
(define dlst (map (lambda (x) (list x (car (random-list 5)))) lst))

(define ord (make-skiplist-with-gap-from-list (enum 60) 5 3 -))
(define skp (make-skiplist-from-list lst 5 -)) ; without dups
(define skp* (make-skiplist-from-list lst 5 - dups)) ; with dups
(define skp12 (make-skiplist-from-list dlst 5
                                      (lambda (x y) (- (car x) (car y)))
                                      (lambda (x y) (- (cadr x) (cadr y)))))
(define skp21 (apply skip-reorder skp12 (reverse (skip-orders skp12))))
(define flt (skip-filter skp* even?))

(run
  (= (skip-count skp*) (length lst))
  (apply <= (skip-list skp*))
  (<= (skip-count flt) (length lst))
  (not (memq #f (map even? (skip-list flt))))
  (<= (skip-count skp) (length lst))
  (apply < (skip-list skp))
  (= (skip-count skp12) (length lst) (length dlst))
  (= (skip-count skp21) (length lst) (length dlst))
  (apply <= (map car (skip-list skp12)))
  (apply <= (map cadr (skip-list skp21)))
  (equal? (skip-list skp*)
          (skip-list (skip-restructure skp* 7 3)))
  (equal? (skip-list skp12)
          (skip-list (skip-restructure skp12 7 3)))
  (equal? (skip-list ord) (enum 60))
  (begin (skip-insert! skp* -1 -1 -1)
         ;(skip-insert! skp* -1)
         ;(skip-insert! skp* -1)
    (= (skip-count skp*) (+ 3 (length lst))))
  (memv -1 (skip-list skp*))
  (begin (skip-remove-all! skp* -1)
         (= (skip-count skp*) (length lst)))
  (not (memv -1 (skip-list skp*)))
  (let ((len (skip-count skp)))
    (skip-insert! skp -1)
    (skip-insert! skp -1)
    (skip-insert! skp -1)
    (skip-remove! skp -1)
    (= len (skip-count skp)))
  (begin
    (apply skip-insert! skp (enum 60))
    (equal? (skip-list skp) (enum 60)))
  )