Add test cases for nng_msg_reserve, etc. Convert message tests to NUTS.

4 files changed, 558 insertions, 269 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index ac3cdaec..459e5f23 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2020 Staysail Systems, Inc. <info@staystail.tech>
+# Copyright 2021 Staysail Systems, Inc. <info@staystail.tech>
 #
 # This software is supplied under the terms of the MIT License, a
 # copy of which should be located in the distribution where this
@@ -84,6 +84,7 @@ nng_test(buf_size_test)
 nng_test(errors_test)
 nng_test(id_test)
 nng_test(list_test)
+nng_test(message_test)
 nng_test(reconnect_test)
 nng_test(sock_test)
 nng_test(url_test)
diff --git a/src/core/message_test.c b/src/core/message_test.c
new file mode 100644
index 00000000..cbd217af
--- /dev/null
+++ b/src/core/message_test.c
@@ -0,0 +1,555 @@
+//
+// Copyright 2021 Staysail Systems, Inc. <info@staysail.tech>
+// Copyright 2018 Capitar IT Group BV <info@capitar.com>
+//
+// This software is supplied under the terms of the MIT License, a
+// copy of which should be located in the distribution where this
+// file was obtained (LICENSE.txt).  A copy of the license may also be
+// found online at https://opensource.org/licenses/MIT.
+//
+
+#include <string.h>
+
+#include <nng/nng.h>
+
+#include "nuts.h"
+
+static uint8_t dat123[] = { 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3 };
+
+void
+test_msg_option(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_FAIL(nng_msg_getopt(msg, 0, NULL, NULL), NNG_ENOTSUP);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_empty(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_ASSERT(nng_msg_len(msg) == 0);
+	NUTS_ASSERT(nng_msg_header_len(msg) == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_append_body(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "pad", 4));
+	NUTS_ASSERT(nng_msg_len(msg) == 4);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "pad") == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_append_header(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append(msg, "123", 4));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 4);
+	NUTS_ASSERT(strcmp(nng_msg_header(msg), "123") == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_insert_body(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "xyz", 4));
+	NUTS_PASS(nng_msg_insert(msg, "uvw", 3));
+	NUTS_ASSERT(nng_msg_len(msg) == 7);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "uvwxyz") == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_insert_header(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append(msg, "def", 4));
+	NUTS_PASS(nng_msg_header_insert(msg, "abc", 3));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 7);
+	NUTS_ASSERT(strcmp(nng_msg_header(msg), "abcdef") == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_trim_body(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "uvwxyz", 7));
+	NUTS_ASSERT(nng_msg_len(msg) == 7);
+	NUTS_PASS(nng_msg_trim(msg, 2));
+	NUTS_ASSERT(nng_msg_len(msg) == 5);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "wxyz") == 0);
+	NUTS_FAIL(nng_msg_trim(msg, 10), NNG_EINVAL);
+	nng_msg_free(msg);
+}
+void
+test_msg_trim_header(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append(msg, "abcdef", 7));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 7);
+	NUTS_PASS(nng_msg_header_trim(msg, 2));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 5);
+	NUTS_ASSERT(strcmp(nng_msg_header(msg), "cdef") == 0);
+	NUTS_FAIL(nng_msg_header_trim(msg, 10), NNG_EINVAL);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_chop_body(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_append(msg, "123456", 7));
+	NUTS_ASSERT(nng_msg_len(msg) == 7);
+	NUTS_PASS(nng_msg_chop(msg, 5));
+	NUTS_ASSERT(nng_msg_len(msg) == 2);
+	NUTS_ASSERT(memcmp(nng_msg_body(msg), "12", 2) == 0);
+	NUTS_FAIL(nng_msg_chop(msg, 10), NNG_EINVAL);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_chop_header(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append(msg, "abcdef", 7));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 7);
+	NUTS_PASS(nng_msg_header_chop(msg, 5));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 2);
+	NUTS_ASSERT(memcmp(nng_msg_header(msg), "ab", 2) == 0);
+	NUTS_FAIL(nng_msg_header_chop(msg, 10), NNG_EINVAL);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_clear_body(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append(msg, "header", 7));
+	NUTS_PASS(nng_msg_append(msg, "body", 5));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 7);
+	NUTS_ASSERT(nng_msg_len(msg) == 5);
+	nng_msg_clear(msg);
+	NUTS_ASSERT(nng_msg_len(msg) == 0);
+	NUTS_ASSERT(nng_msg_header_len(msg) == 7);
+	NUTS_ASSERT(strcmp(nng_msg_header(msg), "header") == 0);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_clear_header(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append(msg, "header", 7));
+	NUTS_PASS(nng_msg_append(msg, "body", 5));
+	NUTS_ASSERT(nng_msg_header_len(msg) == 7);
+	NUTS_ASSERT(nng_msg_len(msg) == 5);
+	nng_msg_header_clear(msg);
+	NUTS_ASSERT(nng_msg_len(msg) == 5);
+	NUTS_ASSERT(nng_msg_header_len(msg) == 0);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "body") == 0);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_pipe(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	nng_pipe p  = NNG_PIPE_INITIALIZER;
+	nng_pipe p0 = NNG_PIPE_INITIALIZER;
+
+	NUTS_ASSERT(nng_pipe_id(p0) < 0);
+	p = nng_msg_get_pipe(msg);
+	NUTS_ASSERT(nng_pipe_id(p) < 0);
+	memset(&p, 0x22, sizeof(p));
+	nng_msg_set_pipe(msg, p);
+	p = nng_msg_get_pipe(msg);
+	NUTS_ASSERT(nng_pipe_id(p) != nng_pipe_id(p0));
+	NUTS_ASSERT(nng_pipe_id(p) == 0x22222222);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_reallocate(void)
+{
+	nng_msg *msg;
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+
+	NUTS_PASS(nng_msg_append(msg, "abc", 4));
+	NUTS_PASS(nng_msg_realloc(msg, 1500));
+	NUTS_ASSERT(nng_msg_len(msg) == 1500);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "abc") == 0);
+	NUTS_ASSERT(nng_msg_realloc(msg, 2) == 0);
+	NUTS_ASSERT(nng_msg_len(msg) == 2);
+	NUTS_ASSERT(memcmp(nng_msg_body(msg), "abc", 3) == 0);
+	NUTS_PASS(nng_msg_append(msg, "CDEF", strlen("CDEF") + 1));
+	NUTS_ASSERT(nng_msg_len(msg) == strlen("abCDEF") + 1);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "abCDEF") == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_large(void)
+{
+	nng_msg *msg;
+	char     chunk[1024];
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	memset(chunk, '+', sizeof(chunk));
+	NUTS_PASS(nng_msg_append(msg, "abc", strlen("abc") + 1));
+	NUTS_ASSERT(nng_msg_len(msg) == strlen("abc") + 1);
+	NUTS_PASS(nng_msg_insert(msg, chunk, sizeof(chunk)));
+	NUTS_ASSERT(nng_msg_len(msg) == strlen("abc") + 1 + sizeof(chunk));
+	NUTS_ASSERT(memcmp(chunk, nng_msg_body(msg), sizeof(chunk)) == 0);
+	NUTS_ASSERT(
+	    strcmp((char *) nng_msg_body(msg) + sizeof(chunk), "abc") == 0);
+	NUTS_PASS(nng_msg_trim(msg, sizeof(chunk) - 2));
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "++abc") == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_dup(void)
+{
+	nng_msg *msg;
+	nng_msg *m2;
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_msg_header_append(msg, "front", strlen("front") + 1));
+	NUTS_PASS(nng_msg_append(msg, "back", strlen("back") + 1));
+
+	NUTS_PASS(nng_msg_dup(&m2, msg));
+
+	NUTS_ASSERT(msg != m2);
+	NUTS_ASSERT(nng_msg_len(msg) == strlen("front"));
+	NUTS_ASSERT(nng_msg_len(m2) == strlen("front"));
+	NUTS_ASSERT(nng_msg_header_len(msg) == nng_msg_header_len(m2));
+
+	NUTS_PASS(nng_msg_insert(msg, "way", 3));
+	NUTS_ASSERT(nng_msg_len(msg) == strlen("wayback") + 1);
+	NUTS_ASSERT(nng_msg_len(m2) == strlen("back") + 1);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "wayback") == 0);
+	NUTS_ASSERT(strcmp(nng_msg_body(m2), "back") == 0);
+	NUTS_PASS(nng_msg_chop(m2, 1));
+	NUTS_PASS(nng_msg_append(m2, "2basics", strlen("2basics") + 1));
+	NUTS_ASSERT(nng_msg_len(msg) == strlen("wayback") + 1);
+	NUTS_ASSERT(strcmp(nng_msg_body(msg), "wayback") == 0);
+	NUTS_ASSERT(nng_msg_len(m2) == strlen("back2basics") + 1);
+	NUTS_ASSERT(strcmp(nng_msg_body(m2), "back2basics") == 0);
+
+	nng_msg_free(m2);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_dup_pipe(void)
+{
+	nng_msg *msg;
+	nng_msg *m2;
+	nng_pipe p;
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	memset(&p, 0x22, sizeof(p));
+	nng_msg_set_pipe(msg, p);
+	NUTS_PASS(nng_msg_dup(&m2, msg));
+	p = nng_msg_get_pipe(m2);
+	NUTS_ASSERT(nng_pipe_id(p) == 0x22222222);
+	nng_msg_free(msg);
+	nng_msg_free(m2);
+}
+
+void
+test_msg_body_uint16(void)
+{
+	nng_msg *msg;
+	uint16_t v;
+	uint8_t  data[] = { 0, 1, 0, 2, 0, 3 };
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+
+	NUTS_PASS(nng_msg_append_u16(msg, 2));
+	NUTS_PASS(nng_msg_insert_u16(msg, 1));
+	NUTS_PASS(nng_msg_append_u16(msg, 3));
+	NUTS_PASS(nng_msg_insert_u16(msg, 0));
+	NUTS_PASS(nng_msg_trim_u16(msg, &v));
+	NUTS_ASSERT(v == 0);
+	NUTS_ASSERT(nng_msg_len(msg) == sizeof(data));
+	NUTS_ASSERT(memcmp(nng_msg_body(msg), data, sizeof(data)) == 0);
+	NUTS_PASS(nng_msg_trim_u16(msg, &v));
+	NUTS_ASSERT(v == 1);
+	NUTS_PASS(nng_msg_chop_u16(msg, &v));
+	NUTS_ASSERT(v == 3);
+	NUTS_PASS(nng_msg_trim_u16(msg, &v));
+	NUTS_ASSERT(v == 2);
+	NUTS_FAIL(nng_msg_trim_u16(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u16(msg, &v), NNG_EINVAL);
+
+	nng_msg_clear(msg);
+	NUTS_PASS(nng_msg_append(msg, &v, 1));
+	NUTS_FAIL(nng_msg_trim_u16(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u16(msg, &v), NNG_EINVAL);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_body_uint32(void)
+{
+	nng_msg *msg;
+	uint32_t v;
+	uint8_t  data[] = { 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3 };
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+
+	NUTS_PASS(nng_msg_append_u32(msg, 2));
+	NUTS_PASS(nng_msg_insert_u32(msg, 1));
+	NUTS_PASS(nng_msg_append_u32(msg, 3));
+	NUTS_PASS(nng_msg_insert_u32(msg, 0));
+	NUTS_PASS(nng_msg_trim_u32(msg, &v));
+	NUTS_ASSERT(v == 0);
+	NUTS_ASSERT(nng_msg_len(msg) == sizeof(data));
+	NUTS_ASSERT(memcmp(nng_msg_body(msg), data, sizeof(data)) == 0);
+	NUTS_PASS(nng_msg_trim_u32(msg, &v));
+	NUTS_ASSERT(v == 1);
+	NUTS_PASS(nng_msg_chop_u32(msg, &v));
+	NUTS_ASSERT(v == 3);
+	NUTS_PASS(nng_msg_trim_u32(msg, &v));
+	NUTS_ASSERT(v == 2);
+	NUTS_FAIL(nng_msg_trim_u32(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u32(msg, &v), NNG_EINVAL);
+
+	nng_msg_clear(msg);
+	NUTS_PASS(nng_msg_append(msg, &v, 1));
+	NUTS_FAIL(nng_msg_trim_u32(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u32(msg, &v), NNG_EINVAL);
+
+	nng_msg_free(msg);
+}
+void
+test_msg_body_uint64(void)
+{
+	nng_msg *msg;
+	uint64_t v;
+	uint8_t  data[] = { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0,
+                0, 0, 0, 0, 0, 0, 3 };
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+
+	NUTS_PASS(nng_msg_append_u64(msg, 2));
+	NUTS_PASS(nng_msg_insert_u64(msg, 1));
+	NUTS_PASS(nng_msg_append_u64(msg, 3));
+	NUTS_PASS(nng_msg_insert_u64(msg, 0));
+	NUTS_PASS(nng_msg_trim_u64(msg, &v));
+	NUTS_ASSERT(v == 0);
+	NUTS_ASSERT(nng_msg_len(msg) == sizeof(data));
+	NUTS_ASSERT(memcmp(nng_msg_body(msg), data, sizeof(data)) == 0);
+	NUTS_PASS(nng_msg_trim_u64(msg, &v));
+	NUTS_ASSERT(v == 1);
+	NUTS_PASS(nng_msg_chop_u64(msg, &v));
+	NUTS_ASSERT(v == 3);
+	NUTS_PASS(nng_msg_trim_u64(msg, &v));
+	NUTS_ASSERT(v == 2);
+	NUTS_FAIL(nng_msg_trim_u64(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u64(msg, &v), NNG_EINVAL);
+
+	nng_msg_clear(msg);
+	NUTS_PASS(nng_msg_append(msg, &v, 1));
+	NUTS_FAIL(nng_msg_trim_u64(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u64(msg, &v), NNG_EINVAL);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_header_uint16(void)
+{
+	nng_msg *msg;
+	uint16_t v;
+	uint8_t  data[] = { 0, 1, 0, 2, 0, 3 };
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+
+	NUTS_PASS(nng_msg_header_append_u16(msg, 2));
+	NUTS_PASS(nng_msg_header_insert_u16(msg, 1));
+	NUTS_PASS(nng_msg_header_append_u16(msg, 3));
+	NUTS_PASS(nng_msg_header_insert_u16(msg, 0));
+	NUTS_PASS(nng_msg_header_trim_u16(msg, &v));
+	NUTS_ASSERT(v == 0);
+	NUTS_ASSERT(nng_msg_header_len(msg) == sizeof(data));
+	NUTS_ASSERT(memcmp(nng_msg_header(msg), data, sizeof(data)) == 0);
+	NUTS_PASS(nng_msg_header_trim_u16(msg, &v));
+	NUTS_ASSERT(v == 1);
+	NUTS_PASS(nng_msg_header_chop_u16(msg, &v));
+	NUTS_ASSERT(v == 3);
+	NUTS_PASS(nng_msg_header_trim_u16(msg, &v));
+	NUTS_ASSERT(v == 2);
+	NUTS_FAIL(nng_msg_header_trim_u16(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_header_chop_u16(msg, &v), NNG_EINVAL);
+
+	nng_msg_clear(msg);
+	NUTS_PASS(nng_msg_append(msg, &v, 1));
+	NUTS_FAIL(nng_msg_trim_u16(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u16(msg, &v), NNG_EINVAL);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_header_uint32(void)
+{
+	nng_msg *msg;
+	uint32_t v;
+	uint8_t  data[] = { 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3 };
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+
+	NUTS_PASS(nng_msg_header_append_u32(msg, 2));
+	NUTS_PASS(nng_msg_header_insert_u32(msg, 1));
+	NUTS_PASS(nng_msg_header_append_u32(msg, 3));
+	NUTS_PASS(nng_msg_header_insert_u32(msg, 0));
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &v));
+	NUTS_ASSERT(v == 0);
+	NUTS_ASSERT(nng_msg_header_len(msg) == sizeof(data));
+	NUTS_ASSERT(memcmp(nng_msg_header(msg), data, sizeof(data)) == 0);
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &v));
+	NUTS_ASSERT(v == 1);
+	NUTS_PASS(nng_msg_header_chop_u32(msg, &v));
+	NUTS_ASSERT(v == 3);
+	NUTS_PASS(nng_msg_header_trim_u32(msg, &v));
+	NUTS_ASSERT(v == 2);
+	NUTS_FAIL(nng_msg_header_trim_u32(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_header_chop_u32(msg, &v), NNG_EINVAL);
+
+	nng_msg_clear(msg);
+	NUTS_PASS(nng_msg_append(msg, &v, 1));
+	NUTS_FAIL(nng_msg_trim_u32(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u32(msg, &v), NNG_EINVAL);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_header_uint64(void)
+{
+	nng_msg *msg;
+	uint64_t v;
+	uint8_t  data[] = { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0,
+                0, 0, 0, 0, 0, 0, 3 };
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+
+	NUTS_PASS(nng_msg_header_append_u64(msg, 2));
+	NUTS_PASS(nng_msg_header_insert_u64(msg, 1));
+	NUTS_PASS(nng_msg_header_append_u64(msg, 3));
+	NUTS_PASS(nng_msg_header_insert_u64(msg, 0));
+	NUTS_PASS(nng_msg_header_trim_u64(msg, &v));
+	NUTS_ASSERT(v == 0);
+	NUTS_ASSERT(nng_msg_header_len(msg) == sizeof(data));
+	NUTS_ASSERT(memcmp(nng_msg_header(msg), data, sizeof(data)) == 0);
+	NUTS_PASS(nng_msg_header_trim_u64(msg, &v));
+	NUTS_ASSERT(v == 1);
+	NUTS_PASS(nng_msg_header_chop_u64(msg, &v));
+	NUTS_ASSERT(v == 3);
+	NUTS_PASS(nng_msg_header_trim_u64(msg, &v));
+	NUTS_ASSERT(v == 2);
+	NUTS_FAIL(nng_msg_header_trim_u64(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_header_chop_u64(msg, &v), NNG_EINVAL);
+
+	nng_msg_clear(msg);
+	NUTS_PASS(nng_msg_append(msg, &v, 1));
+	NUTS_FAIL(nng_msg_trim_u64(msg, &v), NNG_EINVAL);
+	NUTS_FAIL(nng_msg_chop_u64(msg, &v), NNG_EINVAL);
+
+	nng_msg_free(msg);
+}
+
+void
+test_msg_capacity(void)
+{
+	nng_msg *msg;
+	char *   body;
+	char     junk[64];
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_ASSERT(nng_msg_capacity(msg) == 32); // initial empty
+	NUTS_PASS(nng_msg_append(msg, "abc", 4));
+	NUTS_ASSERT(nng_msg_capacity(msg) == 32); // initial empty
+	NUTS_ASSERT(nng_msg_len(msg) == 4);
+	body = nng_msg_body(msg);
+	NUTS_PASS(nng_msg_append(msg, junk, 64));
+	NUTS_ASSERT(nng_msg_len(msg) == 68);
+	NUTS_ASSERT(nng_msg_capacity(msg) >= 68);
+	NUTS_ASSERT(body != nng_msg_body(msg));
+	NUTS_ASSERT(memcmp(nng_msg_body(msg), "abc", 4) == 0);
+	nng_msg_free(msg);
+}
+
+void
+test_msg_reserve(void)
+{
+	nng_msg *msg;
+	char *   body;
+
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_ASSERT(nng_msg_capacity(msg) == 32); // initial empty
+	NUTS_PASS(nng_msg_append(msg, "abc", 4));
+	NUTS_ASSERT(nng_msg_capacity(msg) == 32); // initial empty
+	NUTS_ASSERT(nng_msg_len(msg) == 4);
+	body = nng_msg_body(msg);
+	NUTS_PASS(nng_msg_reserve(msg, 64));
+	NUTS_ASSERT(nng_msg_len(msg) == 4);
+	NUTS_ASSERT(nng_msg_capacity(msg) == 64);
+	NUTS_ASSERT(body != nng_msg_body(msg));
+	NUTS_ASSERT(memcmp(nng_msg_body(msg), "abc", 4) == 0);
+	nng_msg_free(msg);
+}
+
+TEST_LIST = {
+	{ "msg option", test_msg_option },
+	{ "msg empty", test_msg_empty },
+	{ "msg append body", test_msg_append_body },
+	{ "msg append header", test_msg_append_header },
+	{ "msg insert body", test_msg_insert_body },
+	{ "msg insert header", test_msg_insert_header },
+	{ "msg trim body", test_msg_trim_body },
+	{ "msg trim header", test_msg_trim_header },
+	{ "msg chop body", test_msg_chop_body },
+	{ "msg chop header", test_msg_chop_header },
+	{ "msg clear body", test_msg_clear_body },
+	{ "msg clear header", test_msg_clear_header },
+	{ "msg pipe", test_msg_pipe },
+	{ "msg reallocate", test_msg_reallocate },
+	{ "msg large", test_msg_large },
+	{ "msg dup", test_msg_dup },
+	{ "msg dup pipe", test_msg_dup_pipe },
+	{ "msg body u16", test_msg_body_uint16 },
+	{ "msg header u16", test_msg_body_uint16 },
+	{ "msg header u32", test_msg_header_uint16 },
+	{ "msg body u32", test_msg_body_uint32 },
+	{ "msg header u32", test_msg_header_uint32 },
+	{ "msg body u32", test_msg_body_uint64 },
+	{ "msg header u32", test_msg_header_uint64 },
+	{ "msg capacity", test_msg_capacity },
+	{ "msg reserve", test_msg_reserve },
+	{ NULL, NULL },
+};
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 5fcd4323..1b818832 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-#   Copyright 2020 Staysail Systems, Inc. <info@staysail.tech>
+#   Copyright 2021 Staysail Systems, Inc. <info@staysail.tech>
 #   Copyright 2018 Capitar IT Group BV <info@capitar.com>
 #   Copyright (c) 2012 Martin Sustrik  All rights reserved.
 #   Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
@@ -132,7 +132,6 @@ add_nng_test(inproc 5)
 add_nng_test(ipc 5)
 add_nng_test(ipcsupp 10)
 add_nng_test(ipcwinsec 5)
-add_nng_test(message 5)
 add_nng_test(multistress 60)
 add_nng_test(nonblock 60)
 add_nng_test(options 5)
diff --git a/tests/message.c b/tests/message.c
deleted file mode 100644
index 1eda09b1..00000000
--- a/tests/message.c
+++ /dev/null
@@ -1,266 +0,0 @@
-//
-// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech>
-// Copyright 2018 Capitar IT Group BV <info@capitar.com>
-//
-// This software is supplied under the terms of the MIT License, a
-// copy of which should be located in the distribution where this
-// file was obtained (LICENSE.txt).  A copy of the license may also be
-// found online at https://opensource.org/licenses/MIT.
-//
-
-#include <string.h>
-
-#include <nng/nng.h>
-
-#include "convey.h"
-
-static uint8_t dat123[] = { 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3 };
-
-TestMain("Message Tests", {
-	nng_msg *msg;
-
-	Convey("Given an empty message", {
-		So(nng_msg_alloc(&msg, 0) == 0);
-
-		Reset({ nng_msg_free(msg); });
-
-		Convey("Get opt returns ENOTSUP", {
-			So(nng_msg_getopt(msg, 0, NULL, NULL) == NNG_ENOTSUP);
-		});
-
-		Convey("Lengths are empty", {
-			So(nng_msg_len(msg) == 0);
-			So(nng_msg_header_len(msg) == 0);
-		});
-
-		Convey("We can append to the header", {
-			So(nng_msg_header_append(msg, "pad", 4) == 0);
-			So(nng_msg_header_len(msg) == 4);
-			So(strcmp(nng_msg_header(msg), "pad") == 0);
-		});
-
-		Convey("We can append to the body", {
-			So(nng_msg_append(msg, "123", 4) == 0);
-			So(nng_msg_len(msg) == 4);
-			So(strcmp(nng_msg_body(msg), "123") == 0);
-		});
-
-		Convey("We can insert to the header", {
-			So(nng_msg_header_append(msg, "def", 4) == 0);
-			So(nng_msg_header_insert(msg, "abc", 3) == 0);
-			So(nng_msg_header_len(msg) == 7);
-			So(strcmp(nng_msg_header(msg), "abcdef") == 0);
-
-			Convey("We can delete from the front", {
-				So(nng_msg_header_trim(msg, 2) == 0);
-				So(nng_msg_header_len(msg) == 5);
-				So(strcmp(nng_msg_header(msg), "cdef") == 0);
-			});
-
-			Convey("We can delete from the back", {
-				So(nng_msg_header_chop(msg, 5) == 0);
-				So(nng_msg_header_len(msg) == 2);
-				So(memcmp(nng_msg_header(msg), "ab", 2) == 0);
-			});
-		});
-
-		Convey("We can insert to the body", {
-			So(nng_msg_append(msg, "xyz", 4) == 0);
-			So(nng_msg_insert(msg, "uvw", 3) == 0);
-			So(nng_msg_len(msg) == 7);
-			So(strcmp(nng_msg_body(msg), "uvwxyz") == 0);
-
-			Convey("We can delete from the front", {
-				So(nng_msg_trim(msg, 2) == 0);
-				So(nng_msg_len(msg) == 5);
-				So(strcmp(nng_msg_body(msg), "wxyz") == 0);
-			});
-
-			Convey("We can delete from the back", {
-				So(nng_msg_chop(msg, 5) == 0);
-				So(nng_msg_len(msg) == 2);
-				So(memcmp(nng_msg_body(msg), "uv", 2) == 0);
-			});
-		});
-
-		Convey("Clearing the header works", {
-			So(nng_msg_header_append(msg, "bogus", 6) == 0);
-			So(nng_msg_header_len(msg) == 6);
-			nng_msg_header_clear(msg);
-			So(nng_msg_header_len(msg) == 0);
-		});
-
-		Convey("Clearing the body works", {
-			nng_msg_header_append(msg, "bogus", 6);
-			So(nng_msg_append(msg, "bogus", 6) == 0);
-			So(nng_msg_len(msg) == 6);
-			nng_msg_clear(msg);
-			So(nng_msg_len(msg) == 0);
-			// It shouldn't clear the header
-			So(nng_msg_header_len(msg) == 6);
-		});
-
-		Convey("We cannot delete more header than exists", {
-			So(nng_msg_header_append(
-			       msg, "short", strlen("short") + 1) == 0);
-			So(nng_msg_header_trim(msg, 16) == NNG_EINVAL);
-			So(nng_msg_header_len(msg) == strlen("short") + 1);
-			So(nng_msg_header_chop(msg, 16) == NNG_EINVAL);
-			So(nng_msg_header_len(msg) == strlen("short") + 1);
-			So(strcmp(nng_msg_header(msg), "short") == 0);
-		});
-
-		Convey("We cannot delete more body than exists", {
-			So(nng_msg_append(msg, "short", strlen("short") + 1) ==
-			    0);
-			So(nng_msg_trim(msg, 16) == NNG_EINVAL);
-			So(nng_msg_len(msg) == strlen("short") + 1);
-			So(nng_msg_chop(msg, 16) == NNG_EINVAL);
-			So(nng_msg_len(msg) == strlen("short") + 1);
-			So(strcmp(nng_msg_body(msg), "short") == 0);
-		});
-
-		Convey("Pipe retrievals work", {
-			nng_pipe p  = NNG_PIPE_INITIALIZER;
-			nng_pipe p0 = NNG_PIPE_INITIALIZER;
-
-			So(nng_pipe_id(p0) < 0);
-			p = nng_msg_get_pipe(msg);
-			So(nng_pipe_id(p) < 0);
-			memset(&p, 0x22, sizeof(p));
-			nng_msg_set_pipe(msg, p);
-			p = nng_msg_get_pipe(msg);
-			So(nng_pipe_id(p) != nng_pipe_id(p0));
-			So(nng_pipe_id(p) == 0x22222222);
-		});
-
-		Convey("Message realloc works", {
-			So(nng_msg_append(msg, "abc", 4) == 0);
-			So(nng_msg_realloc(msg, 1500) == 0);
-			So(nng_msg_len(msg) == 1500);
-			So(strcmp(nng_msg_body(msg), "abc") == 0);
-			So(nng_msg_realloc(msg, 2) == 0);
-			So(nng_msg_len(msg) == 2);
-			So(memcmp(nng_msg_body(msg), "abc", 3) == 0);
-			So(nng_msg_append(msg, "CDEF", strlen("CDEF") + 1) ==
-			    0);
-			So(nng_msg_len(msg) == strlen("abCDEF") + 1);
-			So(strcmp(nng_msg_body(msg), "abCDEF") == 0);
-		});
-
-		Convey("Inserting a lot of data works", {
-			char chunk[1024];
-			memset(chunk, '+', sizeof(chunk));
-			So(nng_msg_append(msg, "abc", strlen("abc") + 1) == 0);
-			So(nng_msg_len(msg) == strlen("abc") + 1);
-			So(nng_msg_insert(msg, chunk, sizeof(chunk)) == 0);
-			So(nng_msg_len(msg) ==
-			    strlen("abc") + 1 + sizeof(chunk));
-			So(memcmp(chunk, nng_msg_body(msg), sizeof(chunk)) ==
-			    0);
-			So(strcmp((char *) nng_msg_body(msg) + sizeof(chunk),
-			       "abc") == 0);
-			So(nng_msg_trim(msg, sizeof(chunk) - 2) == 0);
-			So(strcmp(nng_msg_body(msg), "++abc") == 0);
-		});
-
-		Convey("Message dup works", {
-			nng_msg *m2;
-
-			So(nng_msg_header_append(
-			       msg, "front", strlen("front") + 1) == 0);
-			So(nng_msg_append(msg, "back", strlen("back") + 1) ==
-			    0);
-
-			So(nng_msg_dup(&m2, msg) == 0);
-			Reset({ nng_msg_free(m2); });
-
-			So(nng_msg_len(msg) == strlen("front"));
-			So(nng_msg_len(m2) == strlen("front"));
-			So(nng_msg_header_len(msg) == nng_msg_header_len(m2));
-
-			So(nng_msg_insert(msg, "way", 3) == 0);
-			So(nng_msg_len(msg) == strlen("wayback") + 1);
-			So(nng_msg_len(m2) == strlen("back") + 1);
-			So(strcmp(nng_msg_body(msg), "wayback") == 0);
-			So(strcmp(nng_msg_body(m2), "back") == 0);
-			So(nng_msg_chop(m2, 1) == 0);
-			So(nng_msg_append(
-			       m2, "2basics", strlen("2basics") + 1) == 0);
-			So(nng_msg_len(msg) == strlen("wayback") + 1);
-			So(strcmp(nng_msg_body(msg), "wayback") == 0);
-			So(nng_msg_len(m2) == strlen("back2basics") + 1);
-			So(strcmp(nng_msg_body(m2), "back2basics") == 0);
-		});
-
-		Convey("Message dup copies pipe", {
-			nng_pipe p = NNG_PIPE_INITIALIZER;
-			nng_msg *m2;
-			memset(&p, 0x22, sizeof(p));
-			nng_msg_set_pipe(msg, p);
-			So(nng_msg_dup(&m2, msg) == 0);
-			Reset({ nng_msg_free(m2); });
-			p = nng_msg_get_pipe(m2);
-			So(nng_pipe_id(p) == 0x22222222);
-		});
-
-		Convey("Uint32 body operations work", {
-			uint32_t v;
-			So(nng_msg_append_u32(msg, 2) == 0);
-			So(nng_msg_insert_u32(msg, 1) == 0);
-			So(nng_msg_append_u32(msg, 3) == 0);
-			So(nng_msg_insert_u32(msg, 0) == 0);
-			So(nng_msg_trim_u32(msg, &v) == 0);
-			So(v == 0);
-			So(nng_msg_len(msg) == sizeof(dat123));
-			So(memcmp(nng_msg_body(msg), dat123, sizeof(dat123)) ==
-			    0);
-			So(nng_msg_trim_u32(msg, &v) == 0);
-			So(v == 1);
-			So(nng_msg_chop_u32(msg, &v) == 0);
-			So(v == 3);
-			So(nng_msg_trim_u32(msg, &v) == 0);
-			So(v == 2);
-			So(nng_msg_trim_u32(msg, &v) == NNG_EINVAL);
-			So(nng_msg_trim_u32(msg, &v) == NNG_EINVAL);
-
-			Convey("Single byte is inadequate", {
-				nng_msg_clear(msg);
-				So(nng_msg_append(msg, &v, 1) == 0);
-				So(nng_msg_trim_u32(msg, &v) == NNG_EINVAL);
-				So(nng_msg_trim_u32(msg, &v) == NNG_EINVAL);
-			});
-		});
-
-		Convey("Uint32 header operations work", {
-			uint32_t v;
-			So(nng_msg_header_append_u32(msg, 2) == 0);
-			So(nng_msg_header_insert_u32(msg, 1) == 0);
-			So(nng_msg_header_append_u32(msg, 3) == 0);
-			So(nng_msg_header_insert_u32(msg, 0) == 0);
-			So(nng_msg_header_trim_u32(msg, &v) == 0);
-			So(v == 0);
-			So(nng_msg_header_len(msg) == sizeof(dat123));
-			So(nng_msg_len(msg) == 0);
-			So(memcmp(nng_msg_header(msg), dat123,
-			       sizeof(dat123)) == 0);
-			So(nng_msg_header_trim_u32(msg, &v) == 0);
-			So(v == 1);
-			So(nng_msg_header_chop_u32(msg, &v) == 0);
-			So(v == 3);
-			So(nng_msg_header_trim_u32(msg, &v) == 0);
-			So(v == 2);
-			So(nng_msg_header_trim_u32(msg, &v) == NNG_EINVAL);
-			So(nng_msg_header_trim_u32(msg, &v) == NNG_EINVAL);
-
-			Convey("Single byte is inadequate", {
-				nng_msg_header_clear(msg);
-				So(nng_msg_header_append(msg, &v, 1) == 0);
-				So(nng_msg_header_trim_u32(msg, &v) ==
-				    NNG_EINVAL);
-				So(nng_msg_header_trim_u32(msg, &v) ==
-				    NNG_EINVAL);
-			});
-		});
-	});
-})