(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)

#|
(use bsdrnd)

(make-random-source 'bsd)
|#

#|
(use composite-random-source)
(use mwc mrg32k3a moa)

(test-group "composite random"
  (let* (
      (crs-ctor
        (composite-random-source
          (make-random-source-mwc)
          (make-random-source-mrg32k3a)
          (make-random-source-moa)) )
      (crs (crs-ctor) )
      (rndint (random-source-make-integers crs) )
      (rnd (random-source-make-reals crs) ) )
    (test-assert (procedure? rndint))
    (test-assert (procedure? rnd))
    (test-assert (integer? (rndint 10)))
    (test-assert (<= 0 (rndint 10)))
    (test-assert (<= (rndint 10) 10))
    (test-assert (inexact? (rnd)))
    (test-assert (random-source-randomize! crs))
    (test-assert (random-source-pseudo-randomize! crs 1 2))
  )
)
|#

#|
(use composite-entropy-source)
(use entropy-clock entropy-unix)
(use srfi-4)

(test-group "composite entropy"
  (let* (
      (ces-ctor
        (composite-entropy-source
          (make-entropy-source-system-clock)
          (make-entropy-source-random-device)
          (make-entropy-source-urandom-device)) )
      (ces (ces-ctor) )
      (genu8 (entropy-source-u8 ces) )
      (genf64 (entropy-source-f64 ces) ) )
    (test-assert (integer? (genu8)))
    (test-assert (<= 0 (genu8)))
    (test-assert (<= (genu8) 255))
    (test-assert (flonum? (genf64)))
    (test-assert (u8vector? (entropy-source-u8vector ces 2)))
    (test-assert (= 2 (u8vector-length (entropy-source-u8vector ces 2))))
    (test-assert (f64vector? (entropy-source-f64vector ces 2)))
    (test-assert (= 2 (f64vector-length (entropy-source-f64vector ces 2))))
  )
)
|#

;;

(test-begin "SRFI 27")

;;

(use random-source entropy-source)

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

(test-group "basics random"
  (test-assert (random-source? default-random-source))
  (test-assert (random-source? (current-random-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)