(import scheme callable-sequences simple-tests (chicken condition))


(define-checks (callables? verbose?
                           pair
                           (make-callable '(0 1 2 3 4 5 . 6))
                           lst
                           (make-callable '(0 1 2 3 4 5))
                           vec
                           (make-callable #(0 1 2 3 4 5))
                           str
                           (make-callable "012345"))

  (callable-length pair)
  6
  (callable-length lst)
  6
  (callable-length str)
  6
  (callable-length vec)
  6
  (lst 0)
  0
  (lst 3)
  3
  (vec 3)
  3
  (str 3)
  #\3
  (lst 5)
  5
  (condition-case (lst (callable-length lst))
    ((exn) #f))
  #f
  (condition-case (vec (callable-length vec))
    ((exn) #f))
  #f
  (condition-case (str (callable-length str))
    ((exn) #f))
  #f
  (callable-data (lst 2 4))
  '(2 3)
  (callable-data (lst 0 3))
  '(0 1 2)
  (callable-length (lst 0 3))
  3
  (callable-data (pair 0 3))
  '(0 1 2 . 6)
  (callable-data (pair 0 0))
  6
  (callable-null? (pair 3 3))
  #t
  (callable-null? (vec 1 2))
  #f
  (callable-data (pair 3 0))
  '(3 2 1 . 6)
  (callable-data (vec 0 3))
  #(0 1 2)
  (callable-data (str 0 3))
  "012"
  (callable-data (lst 3 0))
  '(3 2 1)
  (callable-data (vec 3 0))
  #(3 2 1)
  (callable-data (str 3 0))
  "321"
  (callable-data (pair 0 #f))
  '(0 1 2 3 4 5 . 6)
  (callable-data (pair 0 (callable-length pair)))
  '(0 1 2 3 4 5 . 6)
  (callable-data (lst 0 6))
  '(0 1 2 3 4 5)
  (callable-data (vec 0 #f))
  #(0 1 2 3 4 5)
  (callable-data (str 0 #f))
  "012345"
  (condition-case (lst 0 7)
    ((exn) #f))
  #f
  (condition-case (vec 0 7)
    ((exn) #f))
  #f
  (condition-case (str 0 7)
    ((exn) #f))
  #f
  (callable-data (lst 0 #f))
  '(0 1 2 3 4 5)
  (callable-data (vec 0 #f))
  #(0 1 2 3 4 5)
  (callable-data (str 0 #f))
  "012345"
  (callable-data (lst #f -1))
  '(5 4 3 2 1 0)
  (callable-data (lst (- (callable-length lst) 1) -1))
  '(5 4 3 2 1 0)
  (callable-data (callable-reverse lst))
  '(5 4 3 2 1 0)
  (callable-data (vec #f -1))
  #(5 4 3 2 1 0)
  (callable-data (vec (- (callable-length vec) 1) -1))
  #(5 4 3 2 1 0)
  (callable-data (vec #f -1))
  #(5 4 3 2 1 0)
  (callable-data (str #f -1))
  "543210"
  (callable-data (str (- (callable-length str) 1) -1))
  "543210"
  (callable-data (callable-reverse str))
  "543210"
  (callable-data (lst 3 1))
  '(3 2)
  (callable-data (vec 3 1))
  #(3 2)
  (callable-data (str 3 1))
  "32"
  (callable? str)
  #t
  (callable-sas? lst)
  #t
  (callable-ras? lst)
  #f
  (callable? lst)
  #t
  (callable? vec)
  #t
  (callable? (lst 1 4))
  #t
  (callable? (vec 1 4))
  #t
  (callable-ras? (str 1 4))
  #t
  (callable-sas? (str 1 4))
  #f
  (callable? (str 1 4))
  #t
  (callable? car)
  #f
  (callable? '(0 1 2 3))
  #f
  (callable? #(0 1 2 3))
  #f
  (callable? "0123")
  #f
  (callable? "0123")
  #f
)
;(callables?)

(define-checks (recursives? verbose?
                            pl*
                            (make-callable* '(a (b . c)))
                            ls*
                            (make-callable* '(a (b c)))
                            lv*
                            (make-callable* '(a #(b c)))
                            vp*
                            (make-callable* (vector 'a '(b . c)))
                            vs*
                            (make-callable* (vector 'a "bc"))
                            lv**
                            (make-callable* '(a (b #(c d) e) f)))
  (ls* 0)
  'a
  ((ls* 1) 1)
  'c
  (((ls* 1) 2 #f))
  '()
  ((pl* 1) 0)
  'b
  (((pl* 1) 1 #f))
  'c
  ((lv* 1) 1)
  'c
  ((vp* 1) 0)
  'b
  (((vp* 1) 1 #f))
  'c
  ((vs* 1) 0)
  #\b
  ((vs* 1) 1)
  #\c
  (((vs* 1) 2 #f))
  ""
  (lv** 0)
  'a
  ((lv** 1) 0)
  'b
  (((lv** 1) 1) 0)
  'c
  (((lv** 1) 1) 1)
  'd
  (lv** 2)
  'f
  ((lv** 1) 2)
  'e
  )
;(recursives?)

(check-all CALLABLES (callables?) (recursives?))