test.ss
(module test mzscheme

  (require "combinators.ss"
           (lib "list.ss")
           (planet "test.ss" ("schematics" "schemeunit.plt" 1 (= 2))))

  (provide test)

  (define test
    (make-test-suite "combinators.plt"
      (make-test-suite "curry"
        (make-test-case "1 2 / 3 4"
          (assert-equal? ((curry list 1 2) 3 4) (list 1 2 3 4))))
      (make-test-suite "yrruc"
        (make-test-case "1 2 / 3 4"
          (assert-equal? ((yrruc list 1 2) 3 4) (list 3 4 1 2))))
      (make-test-suite "constant"
        (make-test-case "symbol"
          (assert-eq? ((constant 'symbol) 3 'other "values") 'symbol)))
      (make-test-suite "compose/apply"
        (make-test-case "reverse-evens"
          (assert-equal?
           ((compose/apply (lambda args (reverse args))
                           (lambda args args)
                           (lambda args (filter even? args)))
            0 1 2 3 4 5 6 7 8 9)
           (list 8 6 4 2 0))))
      (make-test-suite "map2"
        (make-test-case "complex"
          (let*-values ([(reals imags)
                         (map2 (lambda (complex)
                                 (values (real-part complex)
                                         (imag-part complex)))
                               (list 0+5i 1+4i 2+3i))])
            (assert-equal? reals (list 0 1 2))
            (assert-equal? imags (list 5 4 3)))))
      (make-test-suite "negate"
        (make-test-case "not even"
          (assert-false ((negate even?) 4)))
        (make-test-case "not odd"
          (assert-true ((negate odd?) 4))))
      (make-test-suite "conjoin"
        (make-test-case "all"
          (assert-true ((conjoin exact? positive? integer?) 4)))
        (make-test-case "some"
          (assert-false ((conjoin exact? positive? integer?) -1)))
        (make-test-case "none"
          (assert-false ((conjoin exact? positive? integer?) -3.3))))
      (make-test-suite "disjoin"
        (make-test-case "all"
          (assert-true ((disjoin exact? positive? integer?) 4)))
        (make-test-case "some"
          (assert-true ((disjoin exact? positive? integer?) -1)))
        (make-test-case "none"
          (assert-false ((disjoin exact? positive? integer?) -3.3))))))

  (define (test/gui)
    ((dynamic-require
      '(planet "graphical-ui.ss" ("schematics" "schemeunit.plt" 1 (= 2)))
      'test/graphical-ui)
     test))

  (define (test/text)
    ((dynamic-require
      '(planet "text-ui.ss" ("schematics" "schemeunit.plt" 1 (= 2)))
      'test/text-ui)
     test))

  )