maze-tests.ss

#lang scheme

(require rackunit)
(require rackunit/text-ui)

(define minimal-maze
  '(
    (w   w   w)
      (w   0   w)
    (w   w   w)
    )
  )

(define minimal-free-maze
  '(
    (w   w   w   w   w)
      (w   0   0   w   w)
    (w   0   0   0   w)
      (w   0   0   w   w)
    (w   w   w   w   w)
    )
  )

(define maze-tests
  (test-suite
   "maze"
   (test-suite
    "simulate"
    (test-case "empty program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '()
                          '()
                          0)
                `(() (,minimal-maze (1 1) west))
                )
               )
    (test-case "complicated empty program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(() ((())) (()))
                          '()
                          0)
                `(() (,minimal-maze (1 1) west))
                )
               )
    (test-case "turn left program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(turn-left)
                          '()
                          0)
                `((turn-left) (,minimal-maze (1 1) southwest))
                )
               )
    (test-case "turn left program (symbol)"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          'turn-left
                          '()
                          0)
                `((turn-left) (,minimal-maze (1 1) southwest))
                )
               )
    (test-case "list program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(turn-left turn-left turn-left)
                          '()
                          0)
                `((turn-left turn-left turn-left) (,minimal-maze (1 1) east))
                )
               )
    (test-case "put-mark program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(put-mark put-mark)
                          '()
                          0)
                `((put-mark put-mark) 
                  (,(applyat2d 1 1 (lambda (x) 2) minimal-maze) (1 1) west))
                )
               )
    (test-case "put-mark/get-mark program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(put-mark get-mark get-mark get-mark turn-left)
                          '()
                          0)
                `((put-mark get-mark) (,minimal-maze (1 1) west))
                )
               )
    (test-case "step program"
               (check-equal?
                (simulate (list minimal-free-maze '(2 2) 'west)
                          'step
                          '()
                          0)
                `((step) (,minimal-free-maze (1 2) west))
                )
               )
    (test-case "if west? program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(if west? turn-left put-mark)
                          '()
                          0)
                `((turn-left) (,minimal-maze (1 1) southwest))
                )
               )
    (test-case "if mark? program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(if mark? put-mark turn-left)
                          '()
                          0)
                `((turn-left) (,minimal-maze (1 1) southwest))
                )
               )
    (test-case "if wall? program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          '(if wall? turn-left put-mark)
                          '()
                          0)
                `((turn-left) (,minimal-maze (1 1) southwest))
                )
               )
    (test-case "simple proc program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          'start
                          '((procedure start
                                       turn-left turn-left turn-left))
                          1)
                `((turn-left turn-left turn-left) (,minimal-maze (1 1) east))
                )
               )
    (test-case "recursive proc program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          'start
                          '((procedure start
                                       (turn-left start)))
                          3)
                `((turn-left turn-left turn-left) (,minimal-maze (1 1) east))
                )
               )
    (test-case "recursive 2 proc program"
               (check-equal?
                (simulate (list minimal-maze '(1 1) 'west)
                          'foo
                          '((procedure foo
                                       (turn-left bar))
                            (procedure bar
                                       (turn-left foo)))
                          3)
                `((turn-left turn-left turn-left) (,minimal-maze (1 1) east))
                )
               )
    )
   )
  )

(run-tests maze-tests)