                         "handshake-test run through. Need to see what happened\n"
                         "=====================================================")
               (let [client-message-state (message/get-state client-io time-out ::timed-out)]
+                ;; This seems inside-out.
+                ;; TODO: Check really-succeeded? first.
                 (when (or (= client-message-state ::timed-out)
                           (instance? Throwable client-state)
                           (nil? client-message-state))

                          "Giving up on forwarding to child"
                          {::response rsp
                           ::request incoming})
        (do
          ;; Houston, We have a problem.
          ;; This indicates that we received the EOF from the
          ;; Client.
          ;; So we're following it up with "OK, fine, we're
          ;; done too."
          ;; Marking the test complete here can't work.
          ;; The client told us that it's done.
          ;; We've probably sent back the appropriate ACK,
          ;; but it really isn't (and shouldn't!) be possible
          ;; to know at this level.
          ;; We still need to send back our ACK (which gets
          ;; triggered by closing the socket in the step below).
          (dfrd/success! succeeded? ::kthxbai)
          ;; The test really isn't done after this.
          ;; This message needs to
          ;; a) get to the server's parent
          ;; b) get to the client's parent
          ;; c) get the client-parent's ACK to the server
          ;; d) notify the client-child that it's all done
          ;; No matter what, we have a race condition between
          ;; c and d
          ;; In a real-world scenario, d will trigger first,
          ;; due to network latency.
          ;; And, really it won't matter.
          (message/child-close! @server-atom)))
      (when (= incoming ::icanhazchzbrgr?)
        ;; One of the main points is that this doesn't need to be a lock-step
        ;; request/response.


(defn client-child-processor
  "Process the messages queued by mock-client-child"
  [client-atom client-state-atom succeeded? chzbrgr-length incoming]
  (is incoming)
  (is (or (keyword? incoming)
          ;; Implementation detail:
