(import (scheme base)
        (only (csc hash-map)
          hash-bytevector)
        (only (csc sort)
          sort)
        (only (csc testing)
          assert-equal)
        (csc set))


(define transform-set
  (cons set? (lambda (s)
               (sort (lambda (x y)
                       (string<? (symbol->string x) (symbol->string y)))
                 (set->list s)))))


(define k
  (make-comparer
    (lambda (s)
      (hash-bytevector (string->utf8 (symbol->string s))))
    (lambda (x y)
      (cond
        ((symbol=? x y) 0)
        ((string<? (symbol->string x) (symbol->string y)) -1)
        (else 1)))))


(test difference
  (assert-equal
    '(a c e)
    (difference
      (set k 'a 'b 'c 'd 'e)
      (set k 'b 'd))
    transform-set))


(test difference-empty
  (assert-equal
    '(a b c d e)
    (difference
      (set k 'a 'b 'c 'd 'e)
      *empty-set*)
    transform-set))


(test difference-empty2
  (assert-equal
    '()
    (difference
      *empty-set*
      (set k 'a 'b 'c 'd 'e))
    transform-set))


(test empty-yes
  (assert-equal
    #t
    (empty? *empty-set*)))


(test empty-map
  (assert-equal
    #t
    (empty? (set k))))


(test empty-no
  (assert-equal
    #f
    (empty? (set k 'a))))


(test intersection
  (assert-equal
    '(d e)
    (intersection
      (set k 'a 'b 'c 'd 'e)
      (set k 'd 'e 'f 'g 'h))
    transform-set))

(test intersection-empty
  (assert-equal
    '()
    (intersection
      (set k 'a 'b 'c 'd 'e)
      *empty-set*)
    transform-set))


(test member-yes
  (assert-equal
    #t
    (member? 'b (set k 'a 'b 'c))))


(test member-no
  (assert-equal
    #f
    (member? 'd (set k 'a 'b 'c))))


(test member-empty
  (assert-equal
    #f
    (member? 'a *empty-set*)))


(test set=?-yes
  (assert-equal
    #t
    (set=? (set k 'a 'b 'c) (set k 'a 'b 'c))))


(test set=?-no
  (assert-equal
    #f
    (set=? (set k 'a 'b 'c) (set k 'a 'b))))


(test set=?-empty
  (assert-equal
    #t
    (set=? *empty-set* (set k))))


(test subset-yes
  (assert-equal
    #t
    (subset?
      (set k 'b 'c)
      (set k 'a 'b 'c 'd))))


(test subset-no
  (assert-equal
    #f
    (subset?
      (set k 'd 'e)
      (set k 'a 'b 'c 'd))))


(test subset-empty
  (assert-equal
    #t
    (subset? *empty-set* *empty-set*)))


(test subset-of-empty
  (assert-equal
    #f
    (subset? (set k 'a) *empty-set*)))


(test subset-another-empty
  (assert-equal
    #t
    (subset? *empty-set* (set k))))


(test union
  (assert-equal
    '(a b c d e f g h i)
    (union
      (set k 'a 'b 'c)
      (set k 'd 'e 'f)
      (set k 'g 'h 'i))
    transform-set))


(test union-empty
  (assert-equal
    '(a b c)
    (union
      (set k 'a 'b 'c)
      *empty-set*)))