       (drain! s #(t/is (= % [1])))
       (s/on-end s done))))
 
-(t/deftest observable-never
-  (t/async done
-    (let [n (s/never)]
-      (s/on-end n done))))
-
-;; (t/deftest observable-interval
+;; (t/deftest observable-never
 ;;   (t/async done
-;;     (let [i (s/interval 10)
-;;           sample (s/take 4 i)]
-;;       (drain! sample #(t/is (apply = %)))
-;;       (s/on-end sample done))))
-
-;; (t/deftest observable-later
+;;     (let [n (s/never)]
+;;       (s/on-end n done))))
+
+;; (t/deftest observable-on-value
 ;;   (t/async done
-;;     (let [s (s/later 10 42)]
-;;       (drain! s #(t/is (= % [42])))
-;;       (s/on-end s done))))
-
-;; (t/deftest observable-sequentially
-;;   (t/async done
-;;     (let [s (s/sequentially 10 [1 2 3])
-;;           sample (s/take 6 s)]
-;;       (drain! sample #(t/is (= % [1 2 3])))
-;;       (s/on-end sample done))))
-
-;; (t/deftest observable-repeatedly
-;;   (t/async done
-;;     (let [s (s/repeatedly 10 [1 2 3])
-;;           sample (s/take 6 s)]
-;;       (drain! sample #(t/is (= % [1 2 3 1 2 3])))
-;;       (s/on-end sample done))))
-
-(t/deftest observable-on-value
-  (t/async done
-    (let [s (s/from-coll [1 2 3])
-          vacc (volatile! [])]
-      (s/on-value s #(vswap! vacc conj %))
-      (s/on-end s #(do (t/is (= @vacc [1 2 3]))
-                       (done))))))
+;;     (let [s (s/from-coll [1 2 3])
+;;           vacc (volatile! [])]
+;;       (s/on-value s #(vswap! vacc conj %))
+;;       (s/on-end s #(do (t/is (= @vacc [1 2 3]))
+;;                        (done))))))
 
 (t/deftest observable-concat
   (t/async done

                                  [3 :3]])))
      (s/on-end sample done))))

;; ;; interop

(t/deftest pipe-to-atom
  (t/async done
    (let [st (s/from-coll [1 2 3])

      (t/is (s/observable? s))
      (drain! s #(t/is (= % coll)))
      (s/on-end s done))))

(t/deftest observable-from-vector-with-take
  (t/async done
    (let [coll [1 2 3 4 5 6]
          s (->> (s/from-coll coll)
                 (s/take 2))]
      (t/is (s/observable? s))
      (drain! s #(t/is (= % [1 2])))
      (s/on-end s done))))

(t/deftest observable-from-atom
  (t/async done
    (let [a (atom 0)
          s (->> (s/from-atom a)
                 (s/take 4))]
      (t/is (s/observable? s))
      (drain! s #(do
                   (t/is (= % [1 2 3 4]))
                   (done)))
      (swap! a inc)
      (swap! a inc)
      (swap! a inc)
      (swap! a inc))))

(t/deftest observable-from-set
  (t/async done
