                               ;; TODO: Check out the history, make sure this comment is
                               ;; in the correct vicinity, and then hopefully delete them both.
 
-                              (let [response-state @srvr-child-state]
+                              (let [packet-size (if (keyword? incoming)
+                                                  0
+                                                  (count incoming))
+                                    response-state @srvr-child-state]
                                 (if (keyword? incoming)
                                   (do
+                                    (log/warn prelog "Server child received EOF" incoming)
                                     (is (s/valid? ::specs/eof-flag incoming))
                                     (message/close! @client-io-atom))
-                                  (log/debug (str test-run
-                                                  "::server-child-cb ("
-                                                  (count incoming)
+                                  (log/debug prelog
+                                             (str "::server-child-cb ("
+                                                  packet-size
                                                   " bytes): "
                                                   (-> response-state
                                                       (dissoc :buffer)
                                                       (assoc :buffer-size (count (:buffer response-state)))))))
-                                ;; The first few blocks should max out the message size.
-                                ;; The way the test is set up, the last will be
-                                ;; (+ 512 64).
-                                ;; It doesn't seem worth the hoops it would take to validate that.
                                 (swap! srvr-child-state
                                        (fn [cur]
                                          (log/info prelog "Incrementing state count")
-                                         (-> cur
-                                             (update :count inc)
-                                             ;; Seems a little silly to include the ACKs.
-                                             ;; Should probably think this through more thoroughly
-                                             (update :buffer conj (vec incoming)))))
-                                ;; I would like to get 8 callbacks here:
-                                ;; 1 for each message packet the child tries to send.
-                                ;; I'm actually receiving 6:
-                                ;; 4 1K blocks, 256 bytes, and an EOF indicator.
-                                ;; It seems like this almost definitely involves
-                                ;; PipedStream buffering.
-                                ;; TODO: Need to double-check that and consider
-                                ;; very diligently what I think about it.
-                                ;; (At first glance, it seems totally incorrect).
-                                (when (= packet-count (:count @srvr-child-state))
+                                         (let [incoming (if (keyword? incoming)
+                                                          [incoming]
+                                                          incoming)]
+                                           (-> cur
+                                               (update :count inc)
+                                               ;; Seems a little silly to include the ACKs.
+                                               ;; Should probably think this through more thoroughly
+                                               ;; ACKs shouldn't get here.
+                                               ;; TODO: Verify that.
+                                               (update :buffer conj (vec incoming))
+                                               (update :address + packet-size)))))
+                                (when (= msg-len (:address @srvr-child-state))
                                   (log/info prelog
-                                            "::srvr-child-cb Received all expected packets")
-                                  (deliver response @srvr-child-state)))))
+                                            "::srvr-child-cb Received all expected bytes")
+                                  (deliver response @srvr-child-state)
+                                  (message/close! @srvr-io-atom)))))
           srvr-initialized (message/initial-state (str "(test " test-run ") Server w/ Big Inbound")
                                                   true
                                                   {})

          (when (not= outcome ::time-out)
            (is outgoing)
            (is (= msg-len (::specs/ackd-addr outgoing)))
            (let [n-m-id (::specs/next-message-id outgoing)]
              (is (= (inc packet-count) n-m-id)))
            (is (= 0 (from-child/buffer-size outcome)))
            ;; TODO: I do need a test that triggers EOF
            (is (= ::specs/false (::specs/send-eof outgoing)))
            ;; Keeping around as a reminder for when the implementation changes
            ;; and I need to see what's really going on again
            (comment (is (not outcome) "What should we have here?"))))

    (let [start-time (System/nanoTime)
          packet-count 9  ; trying to make life interesting
          ;; Add an extra quarter-K just for giggles
          msg-len (+ (* (dec packet-count) K/k-1) K/k-div4)
          response (promise)
          srvr-child-state (atom {:address 0
                                  :buffer []
                                  :count 0})
          srvr-io-atom (atom nil)
          ;; I have a circular dependency between
          ;; the client's child-cb, server-parent-cb,
          ;; and initialized.
          ;; The callbacks have access to the state
          ;; value, but not the io-loop handle.
          ;; They need that, because child->!
          ;; is going to trigger another send.
          ;; Wrapping it inside an atom is obnoxious, but
          ;; it works.
