;    Copyright (C) 2006  Will M. Farr <farr@mit.edu>
;
;    This program is free software; you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation; either version 2 of the License, or
;    (at your option) any later version.
;
;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.
;
;    You should have received a copy of the GNU General Public License along
;    with this program; if not, write to the Free Software Foundation, Inc.,
;    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.


(module streams-test mzscheme
  (require "streams.ss")
  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
  
  (provide streams-test-suite)
  
  (define ones (stream-cons 1 ones))
  
  (define (close? x y) (< (abs (- x y)) 1e-8))
  
  (define streams-test-suite 
    (test-suite
     "Streams test"
     (test-case
      "basic operations"
      (check = (stream-car ones) 1)
      (check = (stream-car (stream-cdr ones)) 1)
      (check = (stream-ref ones 10) 1))
     
     (test-case 
      "stream-map"
      (let ((twos (stream-map + ones ones)))
        (check = (stream-car twos) 2)
        (check = (stream-ref twos 10) 2)))
     
     (test-case
      "stream-filter"
      (letrec ((ints (stream-cons 1 (stream-map + ints ones))))
        (let ((evens (stream-filter even? ints))
              (odds (stream-filter odd? ints)))
          (check = (stream-car evens) 2)
          (check = (stream-car odds) 1)
          (check = (stream-ref ints 10) 11)
          (check = (stream-ref evens 1) 4)
          (check = (stream-ref odds 1) 3))))
     
     (test-case 
      "stream-take"
      (check equal? (stream-take 5 ones) '(1 1 1 1 1)))
     
     (test-case 
      "stream"
      (letrec ((alt-ones (stream 1 1 1 1 alt-ones)))
        (check equal? (stream-take 10 alt-ones) (stream-take 10 ones))))
     
     (test-case 
      "primes"
      (check equal? 
             (stream-take 
              9
              (letrec ((integers-from (lambda (n) (stream-cons n (integers-from (+ n 1)))))
                       (primes (stream-cons 2 (stream-filter prime? (integers-from 3))))
                       (prime? (lambda (x)
                                 (let iter ((ps primes))
                                   (let ((p (stream-car ps)))
                                     (cond 
                                       ((= (remainder x p) 0) #f)
                                       ((> (* p p) x) #t)
                                       (else (iter (stream-cdr ps)))))))))
                primes))
             '(2 3 5 7 11 13 17 19 23)))
     
     (test-case
      "convergence"
      (letrec ((sqrt3 (stream-cons 1.5 (stream-map (lambda (y) (* 0.5 (+ y (/ 3 y)))) sqrt3))))
        (check close? 
               (* (stream-take-converged sqrt3)
                         (stream-take-converged sqrt3))
               3))))))