(import (scheme base)
        (only (csc testing) define-test errorf subtest)
        (csc match))


(define-test (test-match t)
  (define-record-type <test-case>
    (test-case name expr want)
    test-case?
    (name name)
    (expr expr)
    (want want))
  (let ((tests (list
                 (test-case
                   "cond"
                   (match 3
                     (0 0)
                     (1 1)
                     (2 2)
                     (3 3)
                     (_ 4))
                   3)
                 (test-case
                   "match-list"
                   (match '(1 2 3)
                     ('() 0)
                     ((1 2) 1)
                     ((1 2 3) 2)
                     ((1 2 3 4) 3)
                     (_ 4))
                   2)
                 (test-case
                   "binding"
                   (match '(1 2 3)
                     ((1 x 3) x))
                   2)
                 #;(test-case
                   "destructuring"
                   (match '(1 2 3)
                     ('() 0)
                     ((head . _) head))
                   1)
                 #;(test-case
                   "ignore"
                   (match '(1 2 3)
                     ((_ _ _ _) 0)
                     ((2 _ _) 1)
                     ((1 _ _) 2)
                     (_ 3))
                   2)
                 #;(test-case
                   "improper list"
                   (match '(1 2 3)
                     ((2 . _) 1)
                     ((1 . x) (car x))
                     (_ 3))
                   2))))
    (for-each
      (lambda (tc)
        (subtest t (name tc)
          (unless (equal? (expr tc) (want tc))
            (errorf t "match = {}, want {}." (expr tc) (want tc)))))
      tests)))