       (assert (= (get m fixed-hash-bar) 2))
       (assert (not (contains? m fixed-hash-foo)))
       (assert (= (count m) 1))))
+
   (let [m (into cljs.core.PersistentHashMap.EMPTY ; make sure we're testing
                 (zipmap (range 100) (range 100))) ; the correct map type
         m (assoc m fixed-hash-foo 1 fixed-hash-bar 2)]

    (is (= 1.5 1.5M))
    (is (= 4.9E-324 5E-324M))))

(defn test-stuff []
  (let [v1 (vec (range 15 48))
        v2 (vec (range 40 57))
        v1 (persistent! (assoc! (conj! (pop! (transient v1)) :foo) 0 :quux))
        v2 (persistent! (assoc! (conj! (transient v2) :bar) 0 :quux))
        v  (into v1 v2)]
    (assert (= v (vec (concat [:quux] (range 16 47) [:foo]
                              [:quux] (range 41 57) [:bar])))))
  (loop [v  (transient [])
         xs (range 100)]
    (if-let [x (first xs)]
      (recur
       (condp #(%1 (mod %2 3)) x
         #{0 2} (conj! v x)
         #{1}   (assoc! v (count v) x))
       (next xs))
      (assert (= (vec (range 100)) (persistent! v)))))

  ;; PersistentHashMap & TransientHashMap
  (loop [m1 cljs.core.PersistentHashMap.EMPTY
         m2 (transient cljs.core.PersistentHashMap.EMPTY)

        (assert (= (map vector (range 100) (range 100)) (sort-by first (seq m1))))
        (assert (= (map vector (range 100) (range 100)) (sort-by first (seq m2))))
        (assert (not (contains? (dissoc m1 3) 3))))))
  (let [tm (-> (->> (interleave (range 10) (range 10))
                    (apply assoc cljs.core.PersistentHashMap.EMPTY))
               (dissoc 3 5 7)
