;; 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 U0-test) (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 "U0.rkt") (require "scanner.rkt") (require rackunit) ;;;;;;;;;;;;;;;;;;; TEST CASES: U0 ;;;;;;;;;;;;;;;; ; 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 add 4]") (make-binop 3 "add" 4)) (check-equal? (string->expr "[(34) add [3 mlt 4]]") (make-binop (make-paren 34) "add" (make-binop 3 "mlt" 4))) (check-equal? (string->expr "iph 3 ? 7 : 9 hpi") (make-ifZero 3 7 9)) (check-equal? (string->expr "iph (34) ? [(34) add [3 mlt 4]] : iph 3 ? 7 : 9 hpi hpi") (make-ifZero (make-paren 34) (make-binop (make-paren 34) "add" (make-binop 3 "mlt" 4)) (make-ifZero 3 7 9))) (check-equal? (eval 34) 34) (check-equal? (eval (string->expr "(34)")) 34) (check-equal? (eval (string->expr "[3 add 4]")) 7) (check-equal? (eval (string->expr "[3 sbt 4]")) -1) (check-equal? (eval (string->expr "[3 mlt 4]")) 12) (check-equal? (eval (string->expr "iph 3 ? 4 : 5 hpi")) 5) (check-equal? (eval (string->expr "iph 0 ? 4 : 5 hpi")) 4) (check-equal? (eval (string->expr "iph [2 sbt 4] ? [1 add 2] : [3 add 4] hpi")) 7) (check-equal? (eval (string->expr "iph 7 ? [3 add 4] : 5 hpi")) 5) (check-equal? (expr->string (string->expr "34")) "34") (check-equal? (expr->string (string->expr "(34)")) "(34)") (check-equal? (expr->string (string->expr "[3 add 4]")) "[3 add 4]") (check-equal? (expr->string (string->expr "[3 sbt 4]")) "[3 sbt 4]") (check-equal? (expr->string (string->expr " [ 3 mlt 4 ] ")) "[3 mlt 4]") (check-equal? (expr->string (string->expr "iph 3 ? 4 : 5 hpi")) "iph 3 ? 4 : 5 hpi") (check-equal? (expr->string (string->expr "iph 0 ? [3 add 4] : 5 hpi")) "iph 0 ? [3 add 4] : 5 hpi") ;; 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 add 3]") (define e3 "(([4 add (3)]))") (define e4 "[(43) add [42 mlt 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)) (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 add 3]") (make-binop 4 "add" 3)) (check-equal? (eval (string->expr "[4 add 3]")) 7) (check-equal? (expr->string (string->expr "[4 add 3]")) "[4 add 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 add 4]" 7 ,(make-binop 3 "add" 4)) ("[3 mlt 4]" 12 ,(make-binop 3 "mlt" 4 )) ("[[3 add 4] add [3 mlt 4]]" 19) ("[(3) mlt ([2 add 3])]" 15) ("iph 0 ? 1 : 2 hpi" 1 ,(make-ifZero 0 1 2)) ("iph 1 ? 1 : 2 hpi" 2 ,(make-ifZero 1 1 2)) ("iph [3 add -3] ? 1 : 2 hpi" 1 ,(make-ifZero (make-binop 3 "add" -3) 1 2)) ("iph [iph iph 0 ? 1 : 2 hpi ? 3 : 4 hpi add -3] ? 1 : 2 hpi" 2 ,(make-ifZero (make-binop (make-ifZero (make-ifZero 0 1 2) 3 4) "add" -3) 1 2)) #| ;>>>U1 tests ; Uncomment these tests, once `mod` is implemented: ["[3 rmd 4]" 3] ["[[5 add 6] rmd 3]" 2] ["[8.1 rmd 3]" 2.1] ["[8 rmd 3.1]" 1.8] ["[-8.1 rmd 3]" 0.9] ["[-8 rmd 3.1]" 1.3] ["[8.1 rmd -3]" -0.9] ["[8 rmd -3.1]" -1.3] ["[-8.1 rmd -3]" -2.1] ["[-8 rmd -3.1]" -1.8] ["[8 rmd 2]" 0] ["[-8 rmd 2]" 0] ["[8 rmd -2]" 0] ["[-8 rmd -2]" 0] ["[8 rmd 3]" 2] ["[-8 rmd 3]" 1] ["[8 rmd -3]" -1] ["[-8 rmd -3]" -2] YOU-MUST-CREATE-SOME-TESTS-FOR-IfEven |# }) ; ; 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 'Ui-test-harness.rkt' would become mildly problematic: ;; since it calls 'eval', 'string->expr' as provided in U0, it needs to require U0.rkt. ;; As we update our implementation U0.rkt to U2.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 Ui-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 : S-example -> void? ; Test that t parses to the correct internal tree-representation (if provided) ; (define (test-internal-representation t) (when (>= (length t) 3) (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 : S-example -> void? ; Test that the S-example `eval`s to what it should. ; (define (test-eval t) (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 : S-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 (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) (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 : S-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 S-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-all t) (begin (test-internal-representation t) (test-parse-inverse-of-to-string t) ; N.B. counts as two tests (test-eval t))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; run the tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (printf "Running U-test-harness:\n") (for-each test-all all-tests) ; This line actually invokes the checker (printf "\nU-test-harness complete; ~v expressions each tested two-or-four ways.\n" (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))