         1000)
       (run-once
         (executor)
-        (fn [] (System/exit 0)) 120000))))
-
+        (fn [] (System/exit 0)) 120000)
+      (if (.endsWith scenario "-async-pipeline-go")
+        (do
+          (async/go
+            (loop []
+              (async/>! in-chan in-data)
+              (.inc in-cntr)
+              (recur)))
+          (sleep 130000))
+        (.start in-loop))
+      (if
+        (not (nil? async-out-count-loop))
+        (.start async-out-count-loop)))))
+

                                (async/>!! in-chan data)))))
                      (and
                        (not (nil? in-data))
                        (> batch-delay 0)
                        (> batch-size 0)) (create-batched-in-fn (get-in-fn pipeline))
                      (not (nil? in-data)) (create-flood-in-fn (get-in-fn pipeline))
                      :default (fn [] (.inc out-cntr))))
          async-out-count-loop (if
                                 (and
                                   (.endsWith scenario "-async-pipeline")

                                 (ProcessingLoop.
                                   "AsyncOutputCountLoop"
                                   (fn []
                                     (async/<!! out-chan)
                                     (.inc out-cntr))))
          async-count-channel (if
                                (and
                                  (.endsWith scenario "-async-pipeline-go")
                                  (not (nil? in-data)))
                                (async/go
                                  (loop []
                                    (async/<! out-chan)
                                    (.inc out-cntr)
                                    (recur))))
          async-pipeline (if
                           (and
                             (.contains scenario "-async-pipeline")
                             (not (nil? in-data)))
                           (async/pipeline
                             8
