;; The first three lines of this file were inserted by DrRacket. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-advanced-reader.ss" "lang")((modname W0-tests) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #t #t none #f () #f)))
; Note: this file is written in *advanced*-student
; (because the test-functions do sequences of I/O, rather than return values).
; Your program should be written in "intermediate student with lambda".


(require "W0.rkt")
(require "scanner.rkt")
(require rackunit)
(require "student-extras.rkt") ; solely for `for-each`

;;;;;;;;;;;;;;;;;;; TEST CASES: W0 ;;;;;;;;;;;;;;;;

; Some expressions to test in a non-automated way:
(check-equal? (parse! (create-scanner "34")) 34)
(check-equal? (parse! (create-scanner "-34")) -34)
(check-equal? (string->expr "34") 34)
(check-equal? (string->expr "|34|") (make-paren 34))
(check-equal? (string->expr "#3 order-up 4}") (make-binop 3 "order-up" 4))
(check-equal? (string->expr "#|34| order-up #3 barnacles! 4}}")
              (make-binop (make-paren 34) "order-up" (make-binop 3 "barnacles!" 4)))
(check-equal? (string->expr "sponge 3 bob 7 square 9 pants")
              (make-if-neg 3 7 9))
(check-equal? (string->expr "sponge |34| bob #3 barnacles! 4} square 7 pants")
              (make-if-neg (make-paren 34) (make-binop 3 "barnacles!" 4) 7))
              
(check-equal? (string->expr "sponge |34| bob #|34| order-up #3 barnacles! 4}} square sponge 3 bob 7 square 9 pants pants")
              (make-if-neg (make-paren 34)
                           (make-binop (make-paren 34) "order-up" (make-binop 3 "barnacles!" 4))
                           (make-if-neg 3 7 9)))




(check-equal? (eval 34) 34)
(check-equal? (eval (string->expr "|34|")) 34)
(check-equal? (eval (string->expr "#3 order-up 4}"))  7)
(check-equal? (eval (string->expr "# 3 ah-shrimp 4 }")) -1)
(check-equal? (eval (string->expr "#3 barnacles!   4}")) 12)
(check-equal? (eval (string->expr "sponge 3 bob 4 square 5 pants")) 5)
(check-equal? (eval (string->expr "sponge -999 bob 4 square 5 pants")) 4)
(check-equal? (eval (string->expr "sponge #4 ah-shrimp 2} bob #1 order-up 2} square #3 order-up 4} pants")) 7)
(check-equal? (eval (string->expr "sponge 7 bob #3 order-up 4} square 5 pants")) 5)

(check-equal? (expr->string (string->expr "34")) "34")
(check-equal? (expr->string (string->expr "|34|")) "|34|")
(check-equal? (expr->string (string->expr "#3 order-up 4}")) "#3 order-up 4}")
(check-equal? (expr->string (string->expr "#3 ah-shrimp 4}")) "#3 ah-shrimp 4}")
(check-equal? (expr->string (string->expr "  # 3 barnacles!     4   } ")) "#3 barnacles! 4}")
(check-equal? (expr->string (string->expr "sponge 3 bob 4 square 5 pants")) "sponge 3 bob 4 square 5 pants")
(check-equal? (expr->string (string->expr "sponge 0 bob #3 order-up 4} square 5 pants")) "sponge 0 bob #3 order-up 4} square 5 pants")

;; Add more specific tests here,
;; if you want things more specific that provided via adding to `all-tests` below.





(define e0 "43")
(define e1 "|43|")
(define e2 "#4 order-up 3}")
(define e3 "||#4 order-up |3|}||")
(define e4 "#|43| order-up #42 barnacles! 3}}")


;;; we can automate checking that string->expr is the (right)inverses of expr->string:
(for-each (λ(e) (check-equal? (expr->string (string->expr e))
                              e))
          (list e0 e1 e2 e3 e4))
; `for-each` is like map except that it discards the result from each function-call;
; it is suitable for functions which are called solely for a side-effect.
; (`test-all` is such a function.)


;;; Though we also want to check that e0..e4 eval to 43,43,7,7,169 respectively.
(for-each (λ(e v) (check-equal? (eval (string->expr e)) v)) ; is the source-Expression; v for Value
          (list e0 e1 e2 e3  e4)
          (list 43 43  7  7 169))


;;; The above is a promising start, to automating tests.
;;; Okay, we'll generalize the above to a more complete test-harness.
;;; One thing, is that we don't want to have two parallel-lists;
;;; instead keep a list of pairs.

;;; Three sorts of tests we want to make, for many different exprs:
(check-equal? (string->expr "#4 order-up 3}") (make-binop 4 "order-up" 3))
(check-equal? (eval (string->expr "#4 order-up 3}")) 7)
(check-equal? (expr->string (string->expr "#4 order-up 3}"))
              "#4 order-up 3}")




; Data Def'n:  a `S-example` is a list of length two or length three:
; '[str val]      (where val is the expected result `(eval (string->expr str))`, or
; '[str val expr] (as above, but `expr` is the internal (struct) representation of `(string->expr str)`).

; A list of S-examples;
; The last line of this file runs two-to-three tests on each S-example.
;
; BE AWARE of the comma preceding the constructors; it's necessary to actually call it.
; See explanation at http://www.radford.edu/~itec380/2017fall-ibarland/Lectures/backquote.html
;
(define all-tests
  `{("7" 7 7)
    ("|3|" 3 ,(make-paren 3))
    ("#3 order-up 4}" 7 ,(make-binop 3 "order-up" 4))
    ("#3 barnacles! 4}" 12 ,(make-binop 3 "barnacles!" 4 ))
    ("##3 order-up 4} order-up #3 barnacles! 4}}" 19)
    ("#|3| barnacles! |#2 order-up 3}|}" 15)
    ("sponge -2 bob 1 square 2 pants" 1 ,(make-if-neg -2 1 2))
    ("sponge 1 bob 1 square 2 pants" 2 ,(make-if-neg 1 1 2))
    ("sponge #3 order-up -3.5} bob 1 square 2 pants" 1 ,(make-if-neg (make-binop 3 "order-up" -3.5) 1 2))
    ("sponge #sponge sponge 0 bob 1 square 2 pants bob 3 square 4 pants order-up -3} bob 1 square 2 pants"
     2
     ,(make-if-neg (make-binop (make-if-neg (make-if-neg 0 1 2) 3 4) "order-up" -3) 1 2))

    
    #|
    ;>>>W1  tests
    ; Uncomment these tests, once `mod` is implemented:
    ("#3 fish-paste 4}" 3)
    ("##5 order-up 6} fish-paste 3}" 2)
    ("#8.1 fish-paste 3}" 2.1)
    ("#8 fish-paste 3.1}" 1.8)
    ("#-8.1 fish-paste 3}" 0.9)
    ("#-8 fish-paste 3.1}" 1.3)
    ("#8.1 fish-paste -3}" -0.9)
    ("#8 fish-paste -3.1}" -1.3)
    ("#-8.1 fish-paste -3}" -2.1)
    ("#-8 fish-paste -3.1}" -1.8)
    ("#8 fish-paste 2}" 0)
    ("#-8 fish-paste 2}" 0)
    ("#8 fish-paste -2}" 0)
    ("#-8 fish-paste -2}" 0)
    ("#8 fish-paste 3}" 2)
    ("#-8 fish-paste 3}" 1)
    ("#8 fish-paste -3}" -1)
    ("#-8 fish-paste -3}" -2)

    YOU-MUST-CREATE-SOME-TESTS-FOR-IfOdd
    |#
    })
;
; For info on backquote, see documentation and/or:
;   http://www.radford.edu/itec380/2017fall-ibarland/Lectures/backquote.html



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; helper functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; The following functions should really be in a separate file, and exported from there.
;; However, putting this in to a file 'Wi-test-harness.rkt' would become mildly problematic:
;; since it calls 'eval', 'string->expr' as provided in W0, it needs to require W0.rkt.
;; As we update our implementation W0.rkt to W2.rkt,U4.rkt etc,
;; we'd then need to updated *this* file each time, changing *nothing* but the 'require'.  Yuck.
;; An actual solution would be using "units":
;; http://docs.racket-lang.org/reference/creatingunits.html?q=unit#%28form._%28%28lib._racket%2Funit..rkt%29._unit%29%29
;;
;; But rather than add that level of indirection for a student-assignment, we'll just repeat
;; this code inside each Wi-test.rkt.


; my-check-equal? : any, any, string -> boolean
; If the two values aren't equal, print an error message.
; If they are equal (and `print-on-success`), a "." gets printed, just to show progress.
;
(define my-check-equal?
  (local {(define test# 0)
          (define print-on-success #true)}
      (λ (actual expected err-msg)
        (begin (set! test# (add1 test#))
               (if (equal? actual expected)
                   (when print-on-success (printf ".~a" "" #;(if (zero? (modulo test# 5)) " " "")))
                   (printf "\ntest #~a failed:\n~a\n" test# err-msg))
               ;(check-equal? actual expected) ; Use `check-equal?` to additionally-but-redundantly manage test cases.
               (equal? actual expected) ; return this boolean
               ))))


; test-internal-representation : Wi-example -> void?
; Test that t parses to the correct internal tree-representation (if provided)
;
(define (test-internal-representation t)
  (when (>= (length t) 3)
    (with-handlers {[exn:fail? print-exception]}
      (my-check-equal? (string->expr (first t))
                       (third t)
                       (format "Parsing     ~v\nresulted in ~v\ninstead of  ~v\nas expected."
                               (first t) (string->expr (first t)) (third t))))))

; test-eval : Wi-example -> void?
; Test that the Wi-example `eval`s to what it should.
;
(define (test-eval t)
  (with-handlers {[exn:fail? print-exception]}
    (my-check-equal? (eval (string->expr (first t)))
                     (second t)
                     (format "Program    ~v\neval'd to  ~v\ninstead of ~v\nas expected."
                             (first t) (eval (string->expr (first t))) (second t)))))
  

; test-parse-inverse-of-to-string : Wi-example -> void?
; Test that `parse` and `expr->string` are inverses of each other:
;    `parse` is a right-inverse: for a string `s`,  (expr->string (parse s)) = s, and
;    `parse` is a left- inverse: for a tree `expr`, (parse (expr->string expr)) = expr.
; Note that spaces between tokens in a string is ignored, so they're not *quite* exact inverses.
;
; Also, other tests are redundant with checking the left-inverse,
; but we still check it to be independent of other code.
;
(define (test-parse-inverse-of-to-string t)
  (begin (with-handlers {[exn:fail? print-exception]}
           (my-check-equal? (string->tokens (expr->string (string->expr (first t))))
                            (string->tokens (first t))
                            (format "Parsing ~v then converting back to string gave ~v."
                                    (first t) (expr->string (string->expr (first t))))))
         (when (>= (length t) 3)
           (with-handlers {[exn:fail? print-exception]}
             (my-check-equal? (string->expr (expr->string (third t)))
                              (third t)
                              (format "Converting ~v to string and re-parsing it gave ~v."
                                      (third t) (expr->string (third t))))))))


; test-all : Wi-example -> void?
; Make sure that t meets the following properties:
;   i. Parsing the string results in the expected internal representation (*)
;  ii. Check that parsing the string and then to-string'ing the result
;      gives back the initial string
; iii. Check that to-string'ing the internal representation and then parsing
;      that resulting string gives back the initial internal representation (*)
;  iv. check that eval'ing the (parsed) string gives the expected value.
;
; (*) steps i,iii can only be performed if the Wi-example contained all three values.
;     If it only contained a string and a value, then only *two* tests get performed.
;     This affects the test-number reported, should a later test fail.
;
(define test# 0)
(define (test-all t)
  (begin
    (set! test# (add1 test#))
    (printf ":")
    (test-internal-representation t)
    (test-parse-inverse-of-to-string t) ; N.B. counts as two tests
    (test-eval t)
    (when (zero? (remainder test# 5)) (printf " "))
    ))


(define (print-exception exn) (printf "~nEXCEPTION: ~a~n" (exn-message exn)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; run the tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(printf "Running V-test-harness (each item in `all-tests` preceded by a ':')\n")

(for-each test-all all-tests)  ; This line actually invokes the checker
(if (= (length all-tests) test#)
    (printf "\nV-test-harness complete; ~v expressions each tested two-or-four ways.\n" (length all-tests))
    (printf "\nV-test-harness ended during test# ~v of ~v tests." test# (length all-tests)))
; `for-each` is like `map` except that it discards the result from each function-call;
; it is suitable for functions which are called solely for a side-effect.
; (`test-all` is such a function.)


;; a line which just "re"prints out the tests,
;; except with the *actual* (not expected) results of eval, string->expr.
;;  [useful for ibarland, in converting one year's spec to another]
#;(pretty-print (map (λ(tst) (let* {[prog (string->expr (first tst))]} (list (expr->string prog) (eval prog))))
       all-tests))