             (no-dispatch-value {:test :test})
             (catch js/Error e
               (not= -1 (.indexOf (.-message e) "cljs.core-test/no-dispatch-value")))))
-      (is (every? true?
-            (for [m [(obj-map) (array-map) (hash-map) (sorted-map)]]
-              (my-map? m))))
-      (is (every? true?
-            (for [not-m [[] 1 "asdf" :foo]]
-              (not (my-map? not-m)))))
+      (doseq [m [(obj-map) (array-map) (hash-map) (sorted-map)]]
+        (is (my-map? m)))
+      (doseq [not-m [[] 1 "asdf" :foo]]
+        (is (not (my-map? not-m))))
       ;; multimethod hashing
       (is (= foo2' (ffirst {foo2' 1})))
 )))


(deftest test-767
  (testing "Testing CLJS-767, invalid assoc"
    (is (every? true?
          (for [n [nil "-1" "" "0" "1" false true (js-obj)]]
            (and
              (= :fail (try (assoc [1 2] n 4)
                            (catch js/Error e :fail)))
              (= :fail (try (assoc (subvec [1 2 3] 2) n 4)
                            (catch js/Error e :fail)))
              (= :fail (try (assoc (range 1 3) n 4)
                            (catch js/Error e :fail)))))))))

(deftest test-768
  (testing "Testing CLJS-768, invalid assoc!"
    (is (every? true?
          (for [n [nil "-1" "" "0" "1" false true (js-obj)]]
            (= :fail (try (assoc! (transient [1 2]) n 4)
                          (catch js/Error e :fail))))))))

(defn cljs-739 [arr names]
  (let [name (first names)]


(deftest test-784
  (testing "Testing CLJS-784, conj on maps"
    (doseq [m [(array-map) (hash-map) (sorted-map)]]
      (is (= :ok
            (try
              (conj m "foo")
              (catch js/Error _
                :ok))))
      (is (= {:foo 1} (conj m [:foo 1])))
      (is (= {:foo 1} (conj m {:foo 1})))
      (is (= {:foo 1} (conj m (list [:foo 1])))))
    (doseq [mt [array-map hash-map sorted-map]]
      (is (= {:foo 1 :bar 2 :baz 3}
            (conj (mt :foo 1)
              ((fn make-seq [from-seq]
                 ;; this tests specifically for user defined seq's, that implement the bare minimum, i.e. no INext
                 (when (seq from-seq)
                   (reify
                     ISeqable
                     (-seq [this] this)
                     ISeq
                     (-first [this] (first from-seq))
                     (-rest [this] (make-seq (rest from-seq))))))
               [[:bar 2] [:baz 3]]))))))
  )

(deftest test-case-keyword
