            [v1 v2] @(p/all [rs1 rs2])]
        (t/is (= v1 v2)))))
 
-(t/deftest promisify
-  #?(:cljs
-     (t/async done
-       (let [func1 (fn [x cb] (cb (inc x)))
-             func2 (p/promisify func1)
-             p1 (func2 2)]
-         (p/then p1 (fn [x]
-                      (t/is (= x 3))
-                      (done)))))
-     :clj
-     (let [func1 (fn [x cb] (cb (inc x)))
-           func2 (p/promisify func1)
-           p1 (func2 2)]
-       @(p/then p1 (fn [x]
-                     (t/is (= x 3)))))))
-
-(t/deftest then-with-ifn
-  (let [p (-> {:x ::value} p/promise (p/then :x))]
-    #?(:cljs
-       (t/async done
-         (p/then p (fn [x]
-                     (t/is (= x ::value))
-                     (done))))
-       :clj
-       (t/is (= @p ::value)))))
-
-(defmulti unwrap-caught identity)
-(defmethod unwrap-caught :default [x]
-  (-> x ex-data :x))
-
-(t/deftest catch-with-ifn
-  (let [p (-> (p/promise
-               (fn [_ reject] (reject (ex-info "foobar" {:x ::value}))))
-              (p/catch unwrap-caught))]
-    #?(:cljs
-       (t/async done
-         (p/then p (fn [x]
-                     (t/is (= x ::value))
-                     (done))))
-       :clj
-       (t/is (= @p ::value)))))
-
-(t/deftest bind-with-ifn
-  (let [p (-> (p/promise {:x ::value})
-              (m/>>= :x))]
-    #?(:cljs
-       (t/async done
-         (p/then p (fn [x]
-                     (t/is (= x ::value))
-                     (done))))
-       :clj
-       (t/is (= @p ::value)))))
-
-;; (t/deftest extract-from-rejected-promise
-;;   (let [p1 (p/rejected 42)]
-;;     (t/is (p/rejected? p1))
-;;     (t/is (= (m/extract p1) 42))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Entry Point
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 
 #?(:cljs (enable-console-print!))
 #?(:cljs (set! *main-cli-fn* #(t/run-tests)))

           p2 (p/branch p1 (constantly nil) (constantly 1))]
       (t/is (= @p2 1)))))

(t/deftest chaining-using-bind
  #?(:cljs
     (t/async done

        p1 (p/rejected e1)
        p2 (p/catch p1 (constantly nil))]
    (t/is (p/rejected? p1))
    (t/is (= e1 (p/extract p1)))))

(t/deftest promise-from-promise
  (let [p1 (p/promise 1)
