--- a/src/sock_test.c	Thu Mar 12 21:23:33 2009 +0200
+++ b/src/sock_test.c	Thu Mar 12 21:44:34 2009 +0200
@@ -225,6 +225,15 @@
     }
 }
 
+void sock_test_add_recv_str (struct sock_test *sock, const char *str)
+{
+    struct io_vec vec = {
+        (char*) str, strlen(str)
+    };
+
+    sock_test_add_recv_vec(sock, vec);
+}
+
 void sock_test_get_send_data (struct sock_test *sock, char **buf_ptr, size_t *len_ptr)
 {
     struct io_buf *buf = &sock->send_buf;
@@ -241,12 +250,21 @@
 
     // copy
     for (i = 0; i < buf->count; i++) {
-        memcpy(out + off, buf->vecs[i].buf, buf->vecs[i].len);
-        off += buf->vecs[i].len;
+        struct io_vec *vec = buf->vecs + i;
+
+        memcpy(out + off, vec->buf, vec->len);
+        off += vec->len;
+        
+        // zero
+        free(vec->buf); vec->buf = NULL;
+        vec->len = 0;
     }
     
     // update return
     *buf_ptr = out;
     *len_ptr = len;
+
+    // update write_vec
+    buf->write_vec = buf->vecs;
 }
 

--- a/src/sock_test.h	Thu Mar 12 21:23:33 2009 +0200
+++ b/src/sock_test.h	Thu Mar 12 21:44:34 2009 +0200
@@ -94,7 +94,14 @@
 void sock_test_add_recv_vec (struct sock_test *sock, struct io_vec vec);
 
 /**
- * Get the send buffer contents as a single string, free() after use if you care about that
+ * Add a string to the recieve buffer using sock_test_add_recv_vec()
+ */
+void sock_test_add_recv_str (struct sock_test *sock, const char *str);
+
+/**
+ * Get the send buffer contents as a single string, free() after use if you care about that.
+ *
+ * Clears the send buffer, so this doesn't return the same data twice.
  */
 void sock_test_get_send_data (struct sock_test *sock, char **buf, size_t *len);
 

--- a/src/test.c	Thu Mar 12 21:23:33 2009 +0200
+++ b/src/test.c	Thu Mar 12 21:44:34 2009 +0200
@@ -84,6 +84,24 @@
     assert_err(-sock_stream_read(sock, &buf, 1), ERR_READ_EOF);
 }
 
+void assert_sock_send_data (struct sock_test *sock, const char *data)
+{
+    // get the data out
+    char *buf;
+    size_t len;
+    
+    sock_test_get_send_data(sock, &buf, &len);
+    
+    log_debug("get_send_data: '%*s'", (int) len, buf);
+    
+    // should be the same
+    assert_strncmp(buf, data, len);
+    assert_strlen(data, len);
+
+    // cleanup
+    free(buf);
+}
+
 void test_sock_test (void)
 {
     struct sock_test *sock = sock_test_create();
@@ -110,21 +128,14 @@
 
     assert_sock_write(SOCK_TEST_BASE(sock), "test ");
     assert_sock_write(SOCK_TEST_BASE(sock), "data");
-
-    // get the data out
-    char *data;
-    size_t len;
+    
+    // check output
+    assert_sock_send_data(sock, _write_data);
 
-    log_info("test get_send_data");
-    
-    sock_test_get_send_data(sock, &data, &len);
-    
-    // should be the same
-    assert_strlen(_write_data, len);
-    assert_strncmp(data, _write_data, len);
+    // check output
+    assert_sock_send_data(sock, "");
 
     // cleanup
-    free(data);
     sock_test_destroy(sock);
 }
 
@@ -216,12 +227,54 @@
     sock_test_add_recv_vec(sock, _trailing_data);
     assert_strnull(ctx.line);
 
+    // test writing
+    log_info("test line_proto_send");
+    assert_success(-line_proto_send(lp, "foobar\r\n"));
+    assert_success(-line_proto_send(lp, "quux\r\n"));
+    assert_sock_send_data(sock, "foobar\r\nquux\r\n");
+
+    // XXX: test partial writes
+
     // cleanup
     line_proto_release(lp);
 }
 
+struct _test_irc_conn_ctx {
+    bool on_registered, on_TEST;
+};
+
+static void _conn_on_registered (struct irc_conn *conn, void *arg)
+{
+    struct _test_irc_conn_ctx *ctx = arg;
+
+    (void) conn;
+
+    ctx->on_registered = true;
+
+    log_debug("registered");
+}
+
+static void _conn_on_TEST (const struct irc_line *line, void *arg)
+{
+    struct _test_irc_conn_ctx *ctx = arg;
+
+    assert_strcmp(line->prefix, "foobar-prefix");
+    assert_strcmp(line->command, "TEST");
+    assert_strcmp(line->args[0], "arg0");
+    assert_strnull(line->args[1]);
+
+    ctx->on_TEST = true;
+
+    log_debug("on_TEST");
+}
+
 static struct irc_conn_callbacks _conn_callbacks = {
-    .on_registered      = NULL,
+    .on_registered      = &_conn_on_registered,
+};
+
+static struct irc_cmd_handler _conn_handlers[] = {
+    {   "TEST",         &_conn_on_TEST  },
+    {   NULL,           NULL            }
 };
 
 void test_irc_conn (void)
@@ -229,12 +282,33 @@
     struct sock_test *sock;
     struct irc_conn *conn;
     struct error_info err;
+    struct irc_conn_register_info register_info = {
+        "nick", "user", "realname"
+    };
+    struct _test_irc_conn_ctx ctx = { false, false };
 
     // create the test socket
     assert((sock = sock_test_create()));
     
     // create the irc_conn
-    assert_success(irc_conn_create(&conn, SOCK_TEST_BASE(sock), &_conn_callbacks, NULL, &err));
+    assert_success(irc_conn_create(&conn, SOCK_TEST_BASE(sock), &_conn_callbacks, &ctx, &err));
+    assert_success(irc_conn_add_cmd_handlers(conn, _conn_handlers, &ctx));
+
+    // test register
+    log_info("test irc_conn_register");
+    assert_success(irc_conn_register(conn, &register_info));
+    assert_sock_send_data(sock, "NICK nick\r\nUSER user 0 * realname\r\n");
+    
+    // test on_register callback    
+    log_info("test irc_conn_callbacks.on_register");
+    sock_test_add_recv_str(sock, "001 mynick :Blaa blaa blaa\r\n");
+    assert(ctx.on_registered);
+    assert_strcmp(conn->nickname, "mynick");
+
+    // test on_TEST handler
+    log_info("test irc_conn.handlers");
+    sock_test_add_recv_str(sock, ":foobar-prefix TEST arg0\r\n");
+    assert(ctx.on_TEST);
 
     // destroy it
     irc_conn_destroy(conn);