     (println "Server should be started now")
     (try
       (println "Sending bogus HELLO")
-      (let [msg "Howdy!"
-            client (get-in started [::state/client-write-chan ::state/chan])
-            recvd (strm/try-take! client ::drained 500 ::timed-out)
-            success (deref (strm/try-put! client msg 1000 ::timed-out))]
+      (let [msg (build-hello)
+            ->srvr (get-in started [::state/client-read-chan ::state/chan])
+            success (deref (strm/try-put! ->srvr msg 1000 ::timed-out))]
         (println "put! success:" success)
         (is (not= ::timed-out success))
-        (is (= @recvd msg)))
+        (when (not= ::timed-out success)
+          (let [srvr-> (get-in started [::state/client-write-chan ::state/chan])
+                cookie @(strm/try-take! srvr-> ::drained 1000 ::timeout)]
+            (is (not= ::drained cookie))
+            (is (not= ::timeout cookie))
+            (when (and (not= ::drained cookie)
+                       (not= ::timeout cookie))
+              ;; A: Decrypt the cookie and send an Initiate to get the server
+              ;; to fork a child to handle messages with this client
+              (throw (RuntimeException. "Q: What next?"))))))
       (finally
         (println "Triggering event loop exit")
         (stop started)))))

            [frereth-cp.server.state :as state]
            [frereth-cp.shared :as shared]
            [frereth-cp.shared.constants :as K]
            [manifold.stream :as strm]))

(defn system-options
  []

   ::state/client-read-chan {::state/chan nil}
   ::state/client-write-chan {::state/chan nil}})

(defn build-hello
  [srvr-xtn
   {:keys [::specs/public-short]
    :as my-short-keys}]
  ;; frereth-cp.client.hello is really my model for setting
  ;; this up.
  ;; I'm not overly fond of the current implementation.
  ;; Still, it's silly not to use whatever the client does.
  ;; TODO: Make what the client does less objectionable
  (let [empty-crypto-box "Q: What is this?"  ; A: a B] of (- K/hello-crypto-box-length K/box-zero-bytes) zeros
        crypto-box "FIXME: How do I encrypt this?"
        hello-dscr {::K/hello-prefix K/hello-header
                    ::K/srvr-xtn srvr-xtn
                    ::K/clnt-xtn (byte-array (take K/extension-length (drop 256 (range))))
                    ::K/clnt-short-pk public-short
                    ::K/zeros (K/zero-bytes K/zero-box-length)
                    ::K/client-nonce-suffix (byte-array [0 0 0 0 0 0 0 1])
                    ::K/crypto-box crypto-box}]
     (serial/compose K/hello-packet-dscr hello-dscr)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Tests

(deftest start-stop
  (testing "That we can start and stop successfully"
    (let [inited (build)
