2.42.test.scm

(use-modules (srfi  srfi-64))
(load "2.42.scm")

(test-begin "adjoin-position")
(test-equal '(1) (adjoin-position 1 1 '()))
(test-equal '(1 2) (adjoin-position 2 2 '(1)))
(test-equal '(1 2 3) (adjoin-position 3 3 '(1 2)))
(test-end "adjoin-position")

(test-begin "index")
(define test-list (enumerate-interval 1 10))
(define (test-at i) (test-equal i (index i test-list)))
(map test-at test-list)
(test-end "index")

;(test-begin "safe?")
(let* ((safe-board '(2 4 6 8 3 1 7 5))
       (all-indexes (enumerate-interval 1 8))
       (horizontally-unsafe-board '(1 1 1 1 1 1 1 1))
       (descending-diagonally-unsafe-board all-indexes)
       (ascending-diagonally-unsafe-board (reverse all-indexes))
       (test-safe-board (lambda (index)
                          (test-assert (safe? index safe-board))
                        )
       )
       (test-hor-board (lambda (index)
                         (test-expect-fail 1)
                         (test-assert (safe? index horizontally-unsafe-board))
                       )
       )
       (test-diag-board (lambda (index)
                          (test-expect-fail 2)
                          (test-assert (safe? index
                                              descending-diagonally-unsafe-board
                                       )
                          )
                          (test-assert (safe? index
                                              ascending-diagonally-unsafe-board
                                       )
                          )
                        )
       )
      )
  (map test-safe-board all-indexes)
  (map test-hor-board all-indexes)
  (map test-diag-board all-indexes)
)
;(test-end "safe?")

(test-begin "queens")
(test-equal '((2 4 1 3) (3 1 4 2)) (queens 4))
(test-equal '((1 3 5 2 4) (4 2 5 3 1) (3 5 2 4 1) (5 2 4 1 3)
              (2 5 3 1 4)
             )
             (queens 5)
)
(test-end "queens")