#lang racket/base
(require data/bit-vector
         racket/dict
         rackunit
         racket/set)

(define (bit-vector->vector bv)
  (for/vector ([b (in-bit-vector bv)])
    b))

(test-equal? "bit-vector"
             (bit-vector->vector (bit-vector #t #f #t))
             '#(#t #f #t))

(test-equal? "make-bit-vector"
             (make-bit-vector 3)
             (bit-vector #f #f #f))

(test-equal? "make-bit-vector"
             (make-bit-vector 3 #t)
             (bit-vector #t #t #t))

(test-equal? "bit-vector-ref"
             (let ([bv (bit-vector #t #f #t)])
               ;; 3 valid refs + 1 not-found
               (for/list ([index '(0 1 2)])
                 (bit-vector-ref bv index)))
             '(#t #f #t))

(test-equal? "bit-vector-set!"
             (let ([bv (bit-vector #t #t #t)])
               (bit-vector-set! bv 1 #f)
               (bit-vector->vector bv))
             '#(#t #f #t))

(test-equal? "bit-vector-length"
             (bit-vector-length (bit-vector #t #f #t))
             3)

(test-equal? "in-bit-vector"
             (let ([bv (bit-vector #t #f #t)])
               (for/list ([x (in-bit-vector bv)]) x))
             '(#t #f #t))

(test-equal? "in-bit-vector expression form"
             (let* ([bv (bit-vector #t #f #t)]
                    [bv-sequence (in-bit-vector bv)])
               (for/list ([x bv-sequence]) x))
             '(#t #f #t))

(test-equal? "bit-vector as sequence"
             (let ([bv (bit-vector #t #f #t)])
               (for/list ([x bv]) x))
             '(#t #f #t))

(test-case "bitvector, lots of sets"
           (let ([bv (make-bit-vector 1000)])
             (for ([i (in-range 0 1000)])
               (bit-vector-set! bv i (odd? i)))
             (for ([i (in-range 0 1000)])
               (check-equal? (bit-vector-ref bv i) (odd? i)))))

(test-equal? "bit-vector, dict-map"
             (dict-map (bit-vector #t #f #t) list)
             '((0 #t) (1 #f) (2 #t)))

(test-equal? "bit-vector, dict-ref"
             (dict-ref (bit-vector #t #f #t) 0)
             #t)

(test-equal? "bit-vector, dict-ref out of range"
             (dict-ref (bit-vector #t #f #t) 5 'not-found)
             'not-found)

(test-case "bit-vector-copy"
           (let ([bv (bit-vector #t #f #t #f #t)])
             (check-equal? (bit-vector-copy bv) bv)))

(test-case "bit-vector, hash-equal"
           (check-equal? 
            (equal-hash-code (bit-vector #t #f #t #f #t))
            (equal-hash-code (bit-vector #t #f #t #f #t))))

(test-case "bit-vector, hash-eq"
           (check-equal? 
            (= (eq-hash-code (bit-vector #t #f #t #f #t))
               (eq-hash-code (bit-vector #t #f #t #f #t)))
            #f))

(test-case "for/bit-vector"
           (check-equal? (for/bit-vector ([i 5]) (odd? i))
                         (bit-vector #f #t #f #t #f))
           (check-equal? (for/bit-vector #:length 4 ([i 2]) (odd? i))
                         (bit-vector #f #t #f #f))
           (check-equal? (for/bit-vector #:length 4 #:fill #t ([i 2]) (odd? i))
                         (bit-vector #f #t #t #t))
           (let ([bv (make-bit-vector 1000)])
             (bit-vector-set! bv 400 #t)
             (check-equal? bv (for/bit-vector ([i 1000]) (= i 400)))))

(test-case "bit-vector-popcount"
           (let ()
             (define (test)
               (define fill (odd? (random 2)))
               (define bv (make-bit-vector 1000 fill))
               (define ns (list->set (build-list 100 (λ (_) (random 1000)))))
               (for ([n (in-set ns)]) (bit-vector-set! bv n (not fill)))
               (define count 
                 (if fill (- 1000 (set-count ns)) (set-count ns)))
               (check-equal? (bit-vector-popcount bv) count))
             (for ([i (in-range 100)])
               (test))))