(define-library (csc hash-map-test)
  (import (scheme base)
          (only (csc format)
            sprintf)
          (only (csc loop)
            loop
            return)
          (only (csc sort) sort)
          (only (csc testing)
                assert-equal
                assert-raises
                test)
          (csc hash-map))
  (begin


    (define transform-map
      (list
        (cons map? map->alist)
        (cons list? (lambda (l) (sort (lambda (x y) (string<? (symbol->string (car x)) (symbol->string (car y)))) l)))))


    (test alist->map-singleton
      (assert-equal
        '((a . 1))
        (alist->map compare-symbols '((a . 1)))
        transform-map))


    (test alist->map-two
      (assert-equal
        '((a . 1) (b . 2))
        (alist->map compare-symbols '((a . 1) (b . 2)))
        transform-map))


    (test alist->map-longer
      (assert-equal
        '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))
        (alist->map compare-symbols '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6)))
        transform-map))


    (test alist->map-larger
      (assert-equal
        '((f . 5) (m . 1) (n . 7) (q . 3) (x . 8))
        (alist->map compare-symbols '((m . 1) (n . 2) (q . 3) (f . 5) (n . 7) (x . 8)))
        transform-map))


    (test alist->map-in-order
      (assert-equal
        '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()))
        (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
        transform-map))


    (test alist->map-reversed
      (assert-equal
        '((h . ()) (g . ()) (f . ()) (e . ()) (d . ()) (c . ()) (b . ()) (a . ()))
        (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
        transform-map))


    (test alist->map-overwrite
      (assert-equal
        '((a . 2))
        (alist->map compare-symbols '((a . 1) (a . 2)))
        transform-map))


    (test alist->map-alternating
      (assert-equal
        '((h . ()) (g . ()) (i . ()) (f . ()) (j . ()) (e . ()) (k . ()) (d . ()) (l . ()) (c . ()))
        (alist->map compare-symbols '((c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()) (i . ()) (j . ()) (k . ()) (l . ())))
        transform-map))


    (define (test-map . bindings)
      (alist->map compare-symbols bindings))


    (test lookup
      (assert-equal
        2
        (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'b)))


    (test lookup-notfound
      (assert-raises key-not-found-error?
        (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'd)))


    (test lookup-default
      (assert-equal
        #f
        (lookup (test-map '(a . #t) '(b . #t)) 'c #f)))


    (test merge
      (assert-equal
        '((a . 1) (b . 2) (c . 3) (d . 4))
        (merge
          (test-map '(a . 1) '(b . 2))
          (test-map '(c . 3) '(d . 4)))
        transform-map))


    (test delete
      (assert-equal
        '((a . 1) (b . 2) (d . 4))
        (delete
          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
          'c)
        transform-map))


    (test delete-only
      (assert-equal
        '()
        (delete
          (test-map '(a . 1))
          'a)
        transform-map))


    (test delete-first
      (assert-equal
        '((b . 2) (c . 3) (d . 4))
        (delete
          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
          'a)
        transform-map))


    (test delete-last
      (assert-equal
        '((a . 1) (b . 2) (c . 3))
        (delete
          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
          'd)
        transform-map))


    (test delete-many
      (assert-equal
        '()
        (loop with m = (loop with m = (test-map)
                             for i from 1 to 100
                             do (set! m (insert m (string->symbol (sprintf "key{}" i)) i))
                             finally (return m))
              for i from 1 to 100
              do (set! m (delete m (string->symbol (sprintf "key{}" i))))
              finally (return m))
        transform-map))))