           (let [really-succeeded? (deref succeeded? 10000 ::timed-out)]
             (log/info "Bottom of message-test")
             (let [client-state (message/get-state client-io 500 ::timed-out)]
-              (is (not (or (= client-state ::timed-out)
-                           (instance? Throwable client-state)
-                           (nil? client-state))))
-              (when (= really-succeeded? ::timed-out)
+              (when (or (= client-state ::timed-out)
+                        (instance? Throwable client-state)
+                        (nil? client-state))
+                (is not client-state))
+              (when (= really-succeeded ::timed-out)
                 (let [{:keys [::specs/flow-control]} client-state]
                   ;; I'm mostly interested in the next-action inside flow-control
                   ;; Down-side to switching to manifold for scheduling:

                          ;; thread).
                          ;; Actually, I'm a little surprised that this works at all.
                          ;; Q: But is it worth it for the test's sake?
                          (loop [n 5
                                 time-out 100]
                            (let [srvr-state (message/get-state server-io time-out ::timed-out)]
                              (if (or (= ::timed-out srvr-state)
                                      (instance? Throwable srvr-state)
                                      (nil? srvr-state))
                                (let [problem (if (instance? Throwable srvr-state)
                                                srvr-state
                                                (ex-info "Non-exception in client->server consumer"
                                                         {::problem srvr-state}))]
                                  (if (> 0 n)
                                    (do
                                      (log/error problem prelog "Server failed!")
                                      (dfrd/error! succeeded? problem))
                                    (recur (dec n) (* time-out 3))))
                                (do
                                  (message/parent->! server-io bs)
                                  (log/debug prelog
                                             "Server's parent-> triggered after"
                                             n "attempts")))))))
                      client->server)
        (strm/consume (fn [bs]
                        (let [prelog (utils/pre-log "server->client consumer")]
                          (log/info prelog "Message from server to client")
                          (loop [n 5
                                 time-out 100]
                            (let [client-state (message/get-state client-io time-out ::timed-out)]
                              (if (or (= ::timed-out client-state)
                                      (instance? Throwable client-state)
                                      (nil? client-state))
                                (if (> 0 n)
                                  (let [problem (if (instance? Throwable client-state)
                                                  client-state
                                                  (ex-info "Non-exception in server->client consumer"
                                                           {::problem client-state}))]
                                    (log/error problem prelog "Client failed!")
                                    (dfrd/error! succeeded? problem))
                                  (recur (dec n) (* time-out 3)))
                                (do
                                  (message/parent->! client-io bs)
                                  (log/debug prelog
                                             "Client's parent-> triggered after"
                                             n
                                             "attempts")))))))
                      server->client)

        (let [initial-message (Unpooled/buffer K/k-1)

                  (is (not flow-control) "Client flow-control"))))
            (let [{:keys [::specs/flow-control]
                   :as srvr-state} (message/get-state server-io 500 ::timed-out)]
              (when (or (= srvr-state ::timed-out)
                        (instance? Throwable srvr-state)
                        (nil? srvr-state))
                (is (not srvr-state)))
              (is (not flow-control) "Server flow-control"))
            (is (= ::kthxbai really-succeeded?))
            (is (= 5 @client-state))))
