(require-library arrays simple-tests)
(import arrays array-sets simple-tests) 

(define-test (arrays?)
  (check
    (define arr (make-array number?))
    (array? arr)
    (array-null? arr)
    (not (array? (array-handler arr)))
    (zero? (array-length arr))
    (do ((k 0 (fx+ k 1)))
      ((fx= k 15))
      (array-add! k arr))
    (not (array-null? arr))
    (= (array-length arr) 15)
    (= (array-length (array-range 2 10 arr)) 8)
    (array-equ? = arr (array-iterate number? 15 add1 0))
    (= (array-item 0 arr) 0)
    (= (array-item 10 arr) 10)
    (= (array-item 14 arr) 14)
    (equal? (array->list (array-range 5 10 arr))
            '(5 6 7 8 9))
    (equal? (array->vector (array-take 5 arr))
            '#(0 1 2 3 4))
    (array-eqv? (array-copy (array-drop 10 arr))
                (array number? 10 11 12 13 14))
    (array-eq? (array-repeat 5 #f) (array #f #f #f #f #f))
    (array-eqv? (array-iterate-while (cut < <> 5) add1 0)
                (array-iterate 5 add1 0))
    (array-eqv? (array-iterate-until (cut = <> 5) add1 0)
                (list->array '(0 1 2 3 4)))
    (array-eqv? (array-copy (array-range 5 10 arr))
                (array number? 5 6 7 8 9))
    (equal? (array->vector (array-map add1 (array-range 3 6 arr)))
            '#(4 5 6))
    (array-eqv?  (array-map number? + (array number? 1 2) (array number?  10 20 30))
                 (array number? 11 22))
    (array-eqv? (array-append (array-range 2 5 arr)
                              (array-range 10 12 arr)
                              (array-range 13 14 arr))
                (array number? 2 3 4 10 11 13))
    (define copied (array-copy arr))
    (array-reverse! copied)
    (array-eqv? copied (array number? 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
    (array-eqv? copied (array-reverse arr))
    (array-cursor-start! arr)
    (array-cursor-goto! (cut = <> 5) arr)
    (= (array-cursor-item arr) 5)
    (array-cursor-goto! (cut = <> 5) arr)
    (array-cursor-finished? arr)
    (array-reverse! copied)
    (= (let ((arr-5-10 (array-range 5 10 copied)))
         (array-cursor-start! arr-5-10)
         (array-cursor-next! arr-5-10)
         (array-cursor-item arr-5-10))
       5)
    (array-prune! arr)
    (array-eqv? arr (array-take 14 copied))
    (array-add! 14 arr)
    (array-eqv? arr copied)
    (define arr0 (array 0))
    (array-prune! arr0)
    (array-null? arr0)
    (define arr1 (make-array number?))
    (do ((k 15 (fx+ k 1)))
      ((fx= k 20))
      (array-add! k arr1))
    (array-append! arr1
                   (array number? 20 21)
                   (array number? 22))
    (array-eqv? arr1 (array-iterate number? 8 add1 15))
    (equal?
      (receive (ar0 ar1) (array-filter odd? arr)
        (list (array->vector ar0) (array->vector ar1)))
      '(#(1 3 5 7 9 11 13) #(0 2 4 6 8 10 12 14)))
    (array-eqv? (array-range 3 8 arr)
                (array-iterate number? 5 add1 3))
    (equal?
      (receive (ar0 ar1) (array-split-with (cut <= <> 5) arr)
        (list (array->list ar0) (array->list ar1)))
      '((0 1 2 3 4 5) (6 7 8 9 10 11 12 13 14)))
    (array-eqv? (array-take-while (cut <= <> 5) arr)
                (array number? 0 1 2 3 4 5))
    (array-eqv? (array-drop-while (cut <= <> 5) arr)
                (array number? 6 7 8 9 10 11 12 13 14))
    (= (array-fold-left * 1 arr1) (* 15 16 17 18 19 20 21 22))
    (equal? (array-fold-left cons '() (array-take 5 arr1))
            '(((((() . 15) . 16) . 17) . 18) . 19))
    (equal? (array-fold-right cons '() arr1)
            '(15 16 17 18 19 20 21 22))
    (= (array-fold-left + 0 (array 1 2 3) (array 10 20 30)) 66)
    (array-eqv? (array-reverse arr) (array-iterate number? 15 sub1 14))
    (array-eqv? (array-reverse (array-range 5 10 arr))
                (array-iterate number? 5 sub1 9))
    (array-sorted? < arr)
    (not (array-sorted? < (array 1 3 2 4 5 7)))
    (define rar (make-array number?))
    (do ((n 0 (fx+ n 1)))
      ((fx= n 100))
      (array-add! (random 1000) rar))
    (array-sort! < rar)
    (array-sorted? <= rar)
    "note that (array-sorted? < rar) is probably wrong because of dups"
    (= (array-apply + 1 2 (array number? 3 4 5)) 15)
    (equal?  (array-bind (a b . xs) arr (list a b (array->vector xs)))
             (list 0 1 (vector 2 3 4 5 6 7 8 9 10 11 12 13 14)))
    (array-eqv? (array-mappend (lambda x (apply array number? x))
                               (array number? 1 2)
                               (array number? 10 20 30))
                (array number? 1 10 2 20))
    (array-eqv? (array-mappend (lambda x (apply array x))
                               (array 0 2 4)
                               (array 1 3 5 7 9))
                (array 0 1 2 3 4 5))
    (array-eqv? (array-zip (array 0 2 4) (array 1 3 5 7 9))
                (array 0 1 2 3 4 5 7 9))
    (equal?
      (receive (ar0 ar1) (array-unzip arr)
        (list (array->list ar0) (array->list ar1)))
      '((0 2 4 6 8 10 12 14) (1 3 5 7 9 11 13)))
    (array-eqv? (array 1 2 3) (array 1 2 3) (array 1 2 3))
    (not (array-eqv? (array 1 2 3) (array 1 2 3 4)))
    "different item types:"
    (not (array-eqv? (array number? 1 2 3) (array 1 2 3)))
    (array-eqv? (array-interpose 100 (array-range 5 10 arr))
                (array number? 5 100 6 100 7 100 8 100 9))
    (array-every? odd? (array 1 5 7))
    (not (array-every? odd? (array 1 4 7)))
    (array-some? odd? (array 2 3 5))
    (not (array-some? odd? (array 2 4 6)))
    (array-cursor-start! arr)
    (array-cursor-goto! (cut = <> 5) arr)
    (= (array-cursor-item arr) 5)
    (array-eqv? (array-memv 10 arr) (array number? 10 11 12 13 14))
    (not (array-memv 20 arr))
    (array-in? = (array 2 3) (array 1 2 3))
    (not (array-in? = (array 1 2 3) (array 2 3)))
    (not (array-in? = (array 1 2 3) (array 2 1 3)))
    (array-equ? = (array-range 5 10 arr) (array number? 5 6 7 8 9))
    (array-eqv? (array-remv 5 arr)
                (array number? 0 1 2 3 4 6 7 8 9 10 11 12 13 14))
    (array-eqv? (array-take-while even? arr) (array number? 0))
    (array-eqv? (array-drop-while even? arr)
                (array number? 1 2 3 4 5 6 7 8 9 10 11 12 13 14))
    (array-eqv? (array-filter even? arr)
                (array number? 0 2 4 6 8 10 12 14))
    (array-eqv? (array-remove-dups = (array 1 2 1 3 2 4 3 5))
                (array 1 2 3 4 5))
    ))

(define-test (sets?)
  (check
    (define st (make-set =))
    (set? st)
    (set-null? st)
    (not (set-in 5 st))
    (set-add! 5 st)
    (set-in 5 st)
    (set-add! 2 st)
    (= (set-count st) 2)
    (set-in 2 st)
    (set-add! 2 st)
    (= (set-count st) 2)
    (equal? (set->vector st) '#(5 2))
    (equal? (set->list st) '(5 2))
    (do ((k 0 (+ k 1)))
      ((= k 5) st)
      (set-add! k st))
    (set-in 3 st)
    (set-remove! 5 st)
    (set= st (set = 0 1 2 3 4))
    (set-remove! 10 st)
    (set= st (set = 0 1 2 3 4))
    (set= (set-iterate = 10 add1 0)
          (set = 0 1 2 3 4 5 6 7 8 9))
    (set= (set-iterate-while = (cut < <> 10) add1 0)
          (set = 0 1 2 3 4 5 6 7 8 9))
    (set= (set-iterate-until = (cut = <> 10) add1 0)
          (set = 0 1 2 3 4 5 6 7 8 9))
    (list->set = '(0 1 2 3 4))
    (vector->set '#(0 1 2 3 4))
    (set<= (set 1 3 2) (set 0 1 2 3 4))
    (not (set<= (set = 1 3 2) (set 0 1 2 3 4)))
    (not (set<= (set 1 3 2 5) (set 0 1 2 3 4)))
    (set= (set 1 3 2 1 2) (set 1 2 3))
    (set= (set-filter odd? (set 0 1 2 3 4 5 6))
          (set 1 3 5))
    (set= (set-map + (set 1 2 3 4) (set 10 20 30))
          (set 11 22 33))
    (set= (set-copy (set 1 2 3 2 1 2)) (set 1 2 3))
    (set= (set-difference (set 1 2 3 2 1 2) (set 1 5 6 2))
          (set 3))
    (set= (set-union (set 1 3 2 1) (set 10 20 10) (set 200 100 200 300))
          (set 1 2 3 10 20 100 200 300))
    (set= (set-intersection (set 0 1 2 3 4 5) (set 7 9 1 3 5))
          (set 1 3 5))
    (set= (set-intersection (set 0 1 2 3 4 5) (set 7 9 1 3 5) (set 1 3))
          (set 1 3))
    (set-every? odd? (set 1 3 5 7))
    (set-every? odd? (make-set))
    (not (set-every? odd? (set 1 3 5 4 7)))
    (not (set-some? odd? (make-set)))
    (not (set-some? odd? (set 2 4 6 8 10)))
    (set-some? odd? (set 2 4 6 8 7 10))
    (= (set-apply + 1 2 3 (set 4 5)) 15)
    ))

(compound-test (ARRAYS-AND-SETS)
  (arrays?)
  (sets?)
  )