       (is (= [1 2 3]
              (<! (async/into [] out)))))))
 
-(deftest-async test-lift
+(deftest-async test-map
   (go
     (let [number (event-constructor :numbers)
           in (z/input 0 :numbers)

      (async/onto-chan graph [(a 1) (b 2) (c 3) (a 10)])
      (is (= [1 3 6 15]
             (<! (async/into [] out)))))
    (let [zero-arity-+-lift (z/map +)
          zero-arity-vector-lift (z/map vector)]
      (is (= 0 (:init zero-arity-+-lift)))
      (is (= [] (:init zero-arity-vector-lift))))))

(deftest-async test-foldp
  (go

(deftest test-signal-sources
  (let [input (z/input 0)
        foldp (z/foldp + 0 input)
        mapped (z/map vector input foldp)
        async (z/async mapped)]
    (are [sig sources] (= (z/signal-deps sig) sources)
         input #{}
         foldp #{input}
         mapped #{input foldp}
         async #{mapped})))

(deftest test-output-node->dependency-map
  (let [input (z/input 0)
        foldp (z/foldp + 0 input)
        mapped (z/map vector input foldp)
        async (z/async mapped)]
    (are [out deps] (= (z/output-node->dependency-map out) deps)
         input {input #{}}
         foldp {input #{}
                foldp #{input}}
         mapped {input #{}
                 foldp #{input}
                 mapped #{input foldp}}
         async {input #{}
                foldp #{input}
                mapped #{input foldp}
                async #{mapped}})))

(deftest test-topsort
  (let [input (z/input 0)
        foldp (z/foldp + 0 input)
        mapped (z/map vector input foldp)
        async (z/async mapped)]
    (are [out sorted-sigs] (= (z/topsort out) sorted-sigs)
         input [input]
         foldp [input foldp]
         mapped [input foldp mapped]
         async [input foldp mapped async])))

(deftest-async test-wiring-things-up
  (go
