;;;; File: tuples-run.scm
;;;; Author: Juergen Lorenz, ju (at) jugilo (dot) de
;;;; Date: Aug 07, 2010
;;;;       Aug 22, 2010
;;;;       Mar 17, 2011
;;;;       Mar 20, 2011


(require 'tuples)
(import tuples)

(define run
  (lambda ()
    (if
      (and
        (let ((tup (tuple 0 1 2 3)))
          (equal? (tuple->list tup) '(0 1 2 3))
          (eq? (tuple? tup) #t)
          (= (tuple-length tup) 4)
          (= (tuple-ref tup 2) 2)
          (eqv? (tuple-find tup 2 =) 2)
          (eqv? (tuple-find tup 4 =) #f)
          (equal? (tuple->list (tuple-map add1 tup)) '(1 2 3 4))
          (equal?
            (let ((result '()))
              (tuple-for-each (lambda (x) (set! result (cons x result)))
                              tup)
              result)
            '(3 2 1 0))
          (equal? (tuple->list (tuple-copy tup)) '(0 1 2 3))
          (equal? (tuple->list (tuple-copy tup 2 3)) '(2))
          (equal? (tuple->list (tuple-copy tup 2)) '(2 3)))
        (equal? (tuple->list (tuple)) '())
        (eq? ((tuple-of? even?) (tuple)) #t)
        (eq? ((tuple-of? even?) (tuple 1 2 3)) #f)
        (eq? ((tuple-of? even?) (tuple 2 4 6)) #t)
        (eq? (tuple? 3) #f)
        (= (tuple-length (tuple)) 0)
        (eqv? (tuple-find (tuple) 3 =) #f)
        (equal? (tuple->list (tuple)) '())
        (equal? (tuple->list (list->tuple '(0 1 2))) '(0 1 2))
        (equal? (tuple->list (list->tuple '())) '())
        (equal? (tuple->list (tuple-map add1 (tuple))) '())
        (equal? (tuple->list (tuple-append (tuple 0 1 2) (tuple 3) (tuple 4 5)))
                '(0 1 2 3 4 5))
        (equal? (tuple->list (tuple-append))
                '())
        (eq? (empty? (empty)) #t)
        (eq? (empty? (tuple 1 2)) #f)
        (eq? (empty? 3) #f)
        (eq? (single? (empty)) #f)
        (eq? (single? (single 1)) #t)
        (eq? (single? 3) #f)
        (let ((sg (single 1)))
          (= (single-state sg) 1)
          (begin (single-state! sg 2) (= (single-state sg) 2)))
        (let ((tup (couple 1 2)))
          (eq? (couple? tup) #t)
          (eq? (triple? tup) #f)
          (= (couple-left tup) 1)
          (= (couple-right tup) 2))
        (let ((tup (triple 1 2 3)))
          (eq? (couple? tup) #f)
          (eq? (triple? tup) #t)
          (= (triple-left tup) 1)
          (= (triple-middle tup) 2)
          (= (triple-right tup) 3))

      )
      (print "All tests passed")
      (print "##### Some tests failed #####"))))


(run)