(use test)

;;

(use srfi-27)

;(print "Current Random Source: " (random-source-kind (current-random-source)))
;(print "Current Entropy Source: " (entropy-source-kind (current-entropy-source)))
;(newline)

(test-begin "SRFI 27")

;;

(use random-source entropy-source)

(test-group "basics"
  (test-assert (random-source? default-random-source))
  (test-assert (random-source? (current-random-source)))
  (test-assert (entropy-source? (current-entropy-source)))

  (test-assert (procedure? random-integer))
  (test-assert (procedure? random-real))
)

;;

(use srfi-4)

(test-group "SRFI-4 vector"

  (test-group "u8vector"
    ;(test-assert (procedure? random-u8vector))
    (let ((v10 (random-u8vector 10)))
      (test #t (u8vector? v10))
      (test 10 (u8vector-length v10)) ) )

  (test-group "f64vector"
    ;(test-assert (procedure? random-f64vector))
    (let ((v10 (random-f64vector 10)))
      (test #t (f64vector? v10))
      (test 10 (f64vector-length v10)) ) )
)

;;

(use srfi-27-uniform-random)

(test-group "uniform-random"

  (test-group "integers"
    (let-values (
        ((gen init)
          (make-uniform-random-integers high: 27 low: 16 precision: 2)))
      (let-values (((high low precision source) (init)))
        (test-assert (= 27 high))
        (test-assert (= 16 low))
        (test-assert (= 2 precision))
        (do ((i 0 (add1 i))
             (rv (gen) (gen)) )
            ((= 100 i))
          (unless (<= 16 rv) (test-assert (<= 16 rv)))
          (unless (<= rv 27) (test-assert (<= rv 27)))
          (unless (zero? (modulo rv 2)) (test-assert (zero? (modulo rv 2)))) ) ) ) )

  ;FIXME needs real test
  (test-group "reals"
    (let-values (
        ((gen init)
          (make-uniform-random-reals precision: 0.000000000003)))
      (let-values (((precision source) (init)))
        (test-assert (= 0.000000000003 precision))
        ;(flonum-print-precision 53)
        (do ((i 0 (add1 i))
             (rv (gen) (gen)) )
            ((= 100 i))
            ) ) ) )
)

;;

(use srfi-27-vector)

(test-group "vector"

  (test-group "random-permutations"
    (let ((gen (make-random-permutations)))
      (test-assert (procedure? gen))
      (let ((vec (gen 10)))
        (test-assert (vector? vec))
        (test 10 (vector-length vec)) ) ) )

  (test-group "random-vector"
    (let ((gen (make-random-vector)))
      (test-assert (procedure? gen))
      (let ((vec (gen 10)))
        (test-assert (vector? vec))
        (test 10 (vector-length vec)) ) ) )

  (test-group "random-hollow-sphere"
    (let ((gen (make-random-hollow-sphere)))
      (test-assert (procedure? gen))
      (let ((vec (gen 10)))
        (test-assert (vector? vec))
        (test 10 (vector-length vec)) ) ) )

  (test-group "random-solid-sphere"
    (let ((gen (make-random-solid-sphere)))
      (test-assert (procedure? gen))
      (let ((vec (gen 10)))
        (test-assert (vector? vec))
        (test 10 (vector-length vec)) ) ) )
)

(test-end "SRFI 27")

;;

(use utils)

(system* "csi -n -s test-mrg32k3a.scm")
(system* "csi -n -s test-confidence")
;(system* "csi -n -s test-diehard") ;errors

(newline)

(test-exit)