New NUTS test framework (NNG Unit Test Support).

This is based on testutil/acutest, but is cleaner and fixes some
short-comings. We will be adding more support for additional
common paradigms to better facilitate transport tests.

While here we added some more test cases, and fixed a possible
symbol collision in the the stats framework (due to Linux use
of a macro definition of "si_value" in a standard OS header).

Test coverage may regress slightly as we are no longer using
some of the legacy APIs.

1 files changed, 247 insertions, 273 deletions

diff --git a/src/core/sock_test.c b/src/core/sock_test.c
index ab557632..9edfbf53 100644
--- a/src/core/sock_test.c
+++ b/src/core/sock_test.c
@@ -8,14 +8,7 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-#include <string.h>
-
-#include <nng/nng.h>
-#include <nng/protocol/pair1/pair.h>
-#include <nng/supplemental/util/platform.h>
-
-#include "acutest.h"
-#include "testutil.h"
+#include <nuts.h>
 
 void
 test_recv_timeout(void)
@@ -24,14 +17,14 @@ test_recv_timeout(void)
 	uint64_t   now;
 	nng_msg *  msg = NULL;
 
-	TEST_NNG_PASS(nng_pair_open(&s1));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 10));
-	now = testutil_clock();
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
-	TEST_CHECK(msg == NULL);
-	TEST_CHECK(testutil_clock() >= (now + 9));
-	TEST_CHECK(testutil_clock() < (now + 500));
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 10));
+	NUTS_CLOCK(now);
+	NUTS_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT);
+	NUTS_TRUE(msg == NULL);
+	NUTS_BEFORE(now + 500);
+	NUTS_AFTER(now + 9);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -41,13 +34,13 @@ test_recv_nonblock(void)
 	uint64_t   now;
 	nng_msg *  msg = NULL;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 10));
-	now = testutil_clock();
-	TEST_NNG_FAIL(nng_recvmsg(s1, &msg, NNG_FLAG_NONBLOCK), NNG_EAGAIN);
-	TEST_CHECK(msg == NULL);
-	TEST_CHECK(testutil_clock() < (now + 500));
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 10));
+	NUTS_CLOCK(now);
+	NUTS_FAIL(nng_recvmsg(s1, &msg, NNG_FLAG_NONBLOCK), NNG_EAGAIN);
+	NUTS_TRUE(msg == NULL);
+	NUTS_BEFORE(now + 500);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -57,15 +50,15 @@ test_send_timeout(void)
 	uint64_t   now;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_pair_open(&s1));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
-	now = testutil_clock();
-	TEST_NNG_FAIL(nng_sendmsg(s1, msg, 0), NNG_ETIMEDOUT);
-	TEST_CHECK(testutil_clock() >= (now + 9));
-	TEST_CHECK(testutil_clock() < (now + 500));
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100));
+	NUTS_CLOCK(now);
+	NUTS_FAIL(nng_sendmsg(s1, msg, 0), NNG_ETIMEDOUT);
+	NUTS_BEFORE(now + 500);
+	NUTS_AFTER(now + 9);
 	nng_msg_free(msg);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -75,26 +68,24 @@ test_send_nonblock(void)
 	uint64_t   now;
 	nng_msg *  msg;
 
-	TEST_NNG_PASS(nng_msg_alloc(&msg, 0));
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 500));
-	now = testutil_clock();
-	TEST_NNG_FAIL(nng_sendmsg(s1, msg, NNG_FLAG_NONBLOCK), NNG_EAGAIN);
-	TEST_CHECK(testutil_clock() < (now + 100));
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_msg_alloc(&msg, 0));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 500));
+	NUTS_CLOCK(now);
+	NUTS_FAIL(nng_sendmsg(s1, msg, NNG_FLAG_NONBLOCK), NNG_EAGAIN);
+	NUTS_BEFORE(now + 100);
 	nng_msg_free(msg);
+	NUTS_CLOSE(s1);
 }
 
 void
 test_readonly_options(void)
 {
 	nng_socket s1;
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_FAIL(
-	    nng_socket_set_int(s1, NNG_OPT_RECVFD, 0), NNG_EREADONLY);
-	TEST_NNG_FAIL(
-	    nng_socket_set_int(s1, NNG_OPT_SENDFD, 0), NNG_EREADONLY);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_OPEN(s1);
+	NUTS_FAIL(nng_socket_set_int(s1, NNG_OPT_RECVFD, 0), NNG_EREADONLY);
+	NUTS_FAIL(nng_socket_set_int(s1, NNG_OPT_SENDFD, 0), NNG_EREADONLY);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -102,14 +93,14 @@ test_socket_base(void)
 {
 	nng_socket s1 = NNG_SOCKET_INITIALIZER;
 
-	TEST_CHECK(nng_socket_id(s1) < 0);
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_CHECK(nng_socket_id(s1) > 0);
+	NUTS_TRUE(nng_socket_id(s1) < 0);
+	NUTS_PASS(nng_pair1_open(&s1));
+	NUTS_TRUE(nng_socket_id(s1) > 0);
 
 	// Cannot set bogus options
-	TEST_NNG_FAIL(nng_socket_set_bool(s1, "BAD_OPT", false), NNG_ENOTSUP);
+	NUTS_FAIL(nng_socket_set_bool(s1, "BAD_OPT", false), NNG_ENOTSUP);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -123,34 +114,33 @@ test_socket_name(void)
 	size_t     sz;
 
 	sz = sizeof(name);
-	TEST_NNG_PASS(nng_pair_open(&s1));
-	TEST_NNG_PASS(nng_socket_get(s1, NNG_OPT_SOCKNAME, name, &sz));
-	TEST_CHECK(sz > 0 && sz < 64);
-	TEST_CHECK(sz == strlen(name) + 1);
+	NUTS_OPEN(s1);
+	NUTS_PASS(nng_socket_get(s1, NNG_OPT_SOCKNAME, name, &sz));
+	NUTS_TRUE(sz > 0 && sz < 64);
+	NUTS_TRUE(sz == strlen(name) + 1);
 	id = strtol(name, &end, 10);
-	TEST_CHECK(id == (long) s1.id);
-	TEST_CHECK(end != NULL && *end == '\0');
+	NUTS_TRUE(id == (long) s1.id);
+	NUTS_TRUE(end != NULL && *end == '\0');
 
-	TEST_NNG_PASS(nng_socket_set(s1, NNG_OPT_SOCKNAME, "hello", 6));
+	NUTS_PASS(nng_socket_set(s1, NNG_OPT_SOCKNAME, "hello", 6));
 	sz = sizeof(name);
-	TEST_NNG_PASS(nng_socket_get(s1, NNG_OPT_SOCKNAME, name, &sz));
-	TEST_CHECK(sz == 6);
-	TEST_STREQUAL(name, "hello");
+	NUTS_PASS(nng_socket_get(s1, NNG_OPT_SOCKNAME, name, &sz));
+	NUTS_TRUE(sz == 6);
+	NUTS_MATCH(name, "hello");
 
 	memset(name, 'A', 64);
 	name[64] = '\0';
 
 	// strings must be NULL terminated
-	TEST_NNG_FAIL(
-	    nng_socket_set(s1, NNG_OPT_SOCKNAME, name, 5), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(s1, NNG_OPT_SOCKNAME, name, 5), NNG_EINVAL);
 
-	TEST_NNG_PASS(nng_socket_get_string(s1, NNG_OPT_SOCKNAME, &str));
-	TEST_ASSERT(str != NULL);
-	TEST_CHECK(strlen(str) == 5);
-	TEST_STREQUAL(str, "hello");
+	NUTS_PASS(nng_socket_get_string(s1, NNG_OPT_SOCKNAME, &str));
+	NUTS_ASSERT(str != NULL);
+	NUTS_TRUE(strlen(str) == 5);
+	NUTS_MATCH(str, "hello");
 	nng_strfree(str);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -161,22 +151,20 @@ test_socket_name_oversize(void)
 	size_t     sz = sizeof(name);
 
 	memset(name, 'A', sz);
-	TEST_NNG_PASS(nng_pair_open(&s1));
+	NUTS_OPEN(s1);
 
-	TEST_NNG_FAIL(
-	    nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz), NNG_EINVAL);
 	name[sz - 1] = '\0';
-	TEST_NNG_FAIL(
-	    nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz), NNG_EINVAL);
+	NUTS_FAIL(nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz), NNG_EINVAL);
 
 	strcpy(name, "hello");
-	TEST_NNG_PASS(nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz));
+	NUTS_PASS(nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz));
 	sz = sizeof(name);
 	memset(name, 'B', sz);
-	TEST_NNG_PASS(nng_getopt(s1, NNG_OPT_SOCKNAME, name, &sz));
-	TEST_CHECK(sz == 6);
-	TEST_STREQUAL(name, "hello");
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_PASS(nng_getopt(s1, NNG_OPT_SOCKNAME, name, &sz));
+	NUTS_TRUE(sz == 6);
+	NUTS_MATCH(name, "hello");
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -190,33 +178,33 @@ test_send_recv(void)
 	char *       buf;
 	char *       a = "inproc://t1";
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_socket_get_int(s1, NNG_OPT_RECVBUF, &len));
-	TEST_CHECK(len == 1);
+	NUTS_PASS(nng_socket_set_int(s1, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_socket_get_int(s1, NNG_OPT_RECVBUF, &len));
+	NUTS_TRUE(len == 1);
 
-	TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_socket_set_int(s2, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(s1, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(s2, NNG_OPT_SENDBUF, 1));
 
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, to));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, to));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, to));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, to));
 
-	TEST_NNG_PASS(nng_listen(s1, a, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, a, NULL, 0));
+	NUTS_PASS(nng_listen(s1, a, NULL, 0));
+	NUTS_PASS(nng_dial(s2, a, NULL, 0));
 
-	TEST_NNG_PASS(nng_send(s1, "abc", 4, 0));
-	TEST_NNG_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC));
-	TEST_CHECK(buf != NULL);
-	TEST_CHECK(sz == 4);
-	TEST_CHECK(memcmp(buf, "abc", 4) == 0);
+	NUTS_PASS(nng_send(s1, "abc", 4, 0));
+	NUTS_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC));
+	NUTS_TRUE(buf != NULL);
+	NUTS_TRUE(sz == 4);
+	NUTS_TRUE(memcmp(buf, "abc", 4) == 0);
 	nng_free(buf, sz);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
@@ -230,32 +218,32 @@ test_send_recv_zero_length(void)
 	char *       buf;
 	char *       a = "inproc://send-recv-zero-length";
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_RECVBUF, 1));
-	TEST_NNG_PASS(nng_getopt_int(s1, NNG_OPT_RECVBUF, &len));
-	TEST_CHECK(len == 1);
+	NUTS_PASS(nng_socket_set_int(s1, NNG_OPT_RECVBUF, 1));
+	NUTS_PASS(nng_getopt_int(s1, NNG_OPT_RECVBUF, &len));
+	NUTS_TRUE(len == 1);
 
-	TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_SENDBUF, 1));
-	TEST_NNG_PASS(nng_socket_set_int(s2, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(s1, NNG_OPT_SENDBUF, 1));
+	NUTS_PASS(nng_socket_set_int(s2, NNG_OPT_SENDBUF, 1));
 
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, to));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, to));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, to));
-	TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, to));
+	NUTS_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, to));
 
-	TEST_NNG_PASS(nng_listen(s1, a, NULL, 0));
-	TEST_NNG_PASS(nng_dial(s2, a, NULL, 0));
+	NUTS_PASS(nng_listen(s1, a, NULL, 0));
+	NUTS_PASS(nng_dial(s2, a, NULL, 0));
 
-	TEST_NNG_PASS(nng_send(s1, "", 0, 0));
-	TEST_NNG_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC));
-	TEST_CHECK(buf == NULL);
-	TEST_CHECK(sz == 0);
+	NUTS_PASS(nng_send(s1, "", 0, 0));
+	NUTS_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC));
+	NUTS_TRUE(buf == NULL);
+	NUTS_TRUE(sz == 0);
 	nng_free(buf, sz);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
@@ -263,9 +251,9 @@ test_connection_refused(void)
 {
 	nng_socket s1;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_FAIL(nng_dial(s1, "inproc://no", NULL, 0), NNG_ECONNREFUSED);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_OPEN(s1);
+	NUTS_FAIL(nng_dial(s1, "inproc://no", NULL, 0), NNG_ECONNREFUSED);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -277,23 +265,23 @@ test_late_connection(void)
 	nng_socket s2;
 	char *     a = "inproc://asy";
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMINT, 10));
-	TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMAXT, 10));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMINT, 10));
+	NUTS_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMAXT, 10));
 
-	TEST_NNG_PASS(nng_dial(s1, a, NULL, NNG_FLAG_NONBLOCK));
-	TEST_NNG_PASS(nng_listen(s2, a, NULL, 0));
+	NUTS_PASS(nng_dial(s1, a, NULL, NNG_FLAG_NONBLOCK));
+	NUTS_PASS(nng_listen(s2, a, NULL, 0));
 	nng_msleep(100);
-	TEST_NNG_PASS(nng_send(s1, "abc", 4, 0));
-	TEST_NNG_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC));
-	TEST_CHECK(sz == 4);
-	TEST_CHECK(memcmp(buf, "abc", 4) == 0);
+	NUTS_PASS(nng_send(s1, "abc", 4, 0));
+	NUTS_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC));
+	NUTS_TRUE(sz == 4);
+	NUTS_TRUE(memcmp(buf, "abc", 4) == 0);
 	nng_free(buf, sz);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
@@ -305,26 +293,26 @@ test_address_busy(void)
 	nng_socket   s1;
 	nng_socket   s2;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_PASS(nng_pair1_open(&s2));
+	NUTS_OPEN(s1);
+	NUTS_OPEN(s2);
 
-	TEST_CHECK(nng_listener_id(l) < 0);
-	TEST_NNG_PASS(nng_listen(s1, a, &l, 0));
-	TEST_CHECK(nng_listener_id(l) > 0);
+	NUTS_TRUE(nng_listener_id(l) < 0);
+	NUTS_PASS(nng_listen(s1, a, &l, 0));
+	NUTS_TRUE(nng_listener_id(l) > 0);
 
 	// Cannot start another one.
-	TEST_NNG_FAIL(nng_listen(s1, a, NULL, 0), NNG_EADDRINUSE);
+	NUTS_FAIL(nng_listen(s1, a, NULL, 0), NNG_EADDRINUSE);
 
 	// We can't restart it -- it's already running
-	TEST_NNG_FAIL(nng_listener_start(l, 0), NNG_ESTATE);
+	NUTS_FAIL(nng_listener_start(l, 0), NNG_ESTATE);
 
 	// We can connect to it.
-	TEST_CHECK(nng_dialer_id(d) < 0);
-	TEST_NNG_PASS(nng_dial(s2, a, &d, 0));
-	TEST_CHECK(nng_dialer_id(d) > 0);
+	NUTS_TRUE(nng_dialer_id(d) < 0);
+	NUTS_PASS(nng_dial(s2, a, &d, 0));
+	NUTS_TRUE(nng_dialer_id(d) > 0);
 
-	TEST_NNG_PASS(nng_close(s1));
-	TEST_NNG_PASS(nng_close(s2));
+	NUTS_CLOSE(s1);
+	NUTS_CLOSE(s2);
 }
 
 void
@@ -338,29 +326,29 @@ test_endpoint_types(void)
 	char *       a = "inproc://mumble...";
 	bool         b;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
+	NUTS_OPEN(s1);
 
-	TEST_CHECK(nng_dialer_id(d) < 0);
-	TEST_NNG_PASS(nng_dialer_create(&d, s1, a));
-	TEST_CHECK(nng_dialer_id(d) > 0);
+	NUTS_TRUE(nng_dialer_id(d) < 0);
+	NUTS_PASS(nng_dialer_create(&d, s1, a));
+	NUTS_TRUE(nng_dialer_id(d) > 0);
 
 	// Forge a listener
 	l2.id = nng_dialer_id(d);
-	TEST_NNG_FAIL(nng_listener_get_bool(l2, NNG_OPT_RAW, &b), NNG_ENOENT);
-	TEST_NNG_FAIL(nng_listener_close(l2), NNG_ENOENT);
-	TEST_NNG_PASS(nng_dialer_close(d));
+	NUTS_FAIL(nng_listener_get_bool(l2, NNG_OPT_RAW, &b), NNG_ENOENT);
+	NUTS_FAIL(nng_listener_close(l2), NNG_ENOENT);
+	NUTS_PASS(nng_dialer_close(d));
 
-	TEST_CHECK(nng_listener_id(l) < 0);
-	TEST_NNG_PASS(nng_listener_create(&l, s1, a));
-	TEST_CHECK(nng_listener_id(l) > 0);
+	NUTS_TRUE(nng_listener_id(l) < 0);
+	NUTS_PASS(nng_listener_create(&l, s1, a));
+	NUTS_TRUE(nng_listener_id(l) > 0);
 
 	// Forge a dialer
 	d2.id = nng_listener_id(l);
-	TEST_NNG_FAIL(nng_dialer_get_bool(d2, NNG_OPT_RAW, &b), NNG_ENOENT);
-	TEST_NNG_FAIL(nng_dialer_close(d2), NNG_ENOENT);
-	TEST_NNG_PASS(nng_listener_close(l));
+	NUTS_FAIL(nng_dialer_get_bool(d2, NNG_OPT_RAW, &b), NNG_ENOENT);
+	NUTS_FAIL(nng_dialer_close(d2), NNG_ENOENT);
+	NUTS_PASS(nng_listener_close(l));
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -368,10 +356,10 @@ test_bad_url(void)
 {
 	nng_socket s1;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
-	TEST_NNG_FAIL(nng_dial(s1, "bogus://1", NULL, 0), NNG_ENOTSUP);
-	TEST_NNG_FAIL(nng_listen(s1, "bogus://2", NULL, 0), NNG_ENOTSUP);
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_OPEN(s1);
+	NUTS_FAIL(nng_dial(s1, "bogus://1", NULL, 0), NNG_ENOTSUP);
+	NUTS_FAIL(nng_listen(s1, "bogus://2", NULL, 0), NNG_ENOTSUP);
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -383,25 +371,24 @@ test_url_option(void)
 	nng_dialer   d;
 	size_t       sz;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
+	NUTS_OPEN(s1);
 
 	// Listener
-	TEST_NNG_PASS(nng_listener_create(&l, s1, "inproc://url1"));
+	NUTS_PASS(nng_listener_create(&l, s1, "inproc://url1"));
 	memset(url, 0, sizeof(url));
 	sz = sizeof(url);
-	TEST_NNG_PASS(nng_listener_get(l, NNG_OPT_URL, url, &sz));
-	TEST_STREQUAL(url, "inproc://url1");
-	TEST_NNG_FAIL(
-	    nng_listener_set(l, NNG_OPT_URL, url, sz), NNG_EREADONLY);
+	NUTS_PASS(nng_listener_get(l, NNG_OPT_URL, url, &sz));
+	NUTS_MATCH(url, "inproc://url1");
+	NUTS_FAIL(nng_listener_set(l, NNG_OPT_URL, url, sz), NNG_EREADONLY);
 	sz = sizeof(url);
 
 	// Dialer
-	TEST_NNG_PASS(nng_dialer_create(&d, s1, "inproc://url2"));
-	TEST_NNG_PASS(nng_dialer_get(d, NNG_OPT_URL, url, &sz));
-	TEST_STREQUAL(url, "inproc://url2");
-	TEST_NNG_FAIL(nng_dialer_set(d, NNG_OPT_URL, url, sz), NNG_EREADONLY);
+	NUTS_PASS(nng_dialer_create(&d, s1, "inproc://url2"));
+	NUTS_PASS(nng_dialer_get(d, NNG_OPT_URL, url, &sz));
+	NUTS_MATCH(url, "inproc://url2");
+	NUTS_FAIL(nng_dialer_set(d, NNG_OPT_URL, url, sz), NNG_EREADONLY);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -411,56 +398,53 @@ test_listener_options(void)
 	nng_listener l;
 	size_t       sz;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
+	NUTS_OPEN(s1);
 
 #ifndef NNG_ELIDE_DEPRECATED
 	// Create a listener with the specified options
-	TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 543));
-	TEST_NNG_PASS(nng_listener_create(&l, s1, "inproc://listener_opts"));
-	TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 543);
+	NUTS_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 543));
+	NUTS_PASS(nng_listener_create(&l, s1, "inproc://listener_opts"));
+	NUTS_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 543);
 
 	// Verify endpoint overrides
-	TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 678));
-	TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 678);
-	TEST_NNG_PASS(nng_socket_get_size(s1, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 543);
+	NUTS_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 678));
+	NUTS_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 678);
+	NUTS_PASS(nng_socket_get_size(s1, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 543);
 
 	// And socket overrides again
-	TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 911));
-	TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 911);
+	NUTS_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 911));
+	NUTS_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 911);
 #else
-	TEST_NNG_PASS(nng_listener_create(&l, s1, "inproc://listener_opts"));
-	TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 678));
-	TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 678);
+	NUTS_PASS(nng_listener_create(&l, s1, "inproc://listener_opts"));
+	NUTS_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 678));
+	NUTS_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 678);
 #endif
 
 	// Cannot set invalid options
-	TEST_NNG_FAIL(nng_listener_set_size(l, "BAD_OPT", 1), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
+	NUTS_FAIL(nng_listener_set_size(l, "BAD_OPT", 1), NNG_ENOTSUP);
+	NUTS_FAIL(
 	    nng_listener_set_bool(l, NNG_OPT_RECVMAXSZ, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(
-	    nng_listener_set(l, NNG_OPT_RECVMAXSZ, &sz, 1), NNG_EINVAL);
+	NUTS_FAIL(nng_listener_set(l, NNG_OPT_RECVMAXSZ, &sz, 1), NNG_EINVAL);
 
 	// Cannot set inappropriate options
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_listener_set_string(l, NNG_OPT_SOCKNAME, "1"), NNG_ENOTSUP);
 
-	TEST_NNG_FAIL(
-	    nng_listener_set_bool(l, NNG_OPT_RAW, true), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
-	    nng_listener_set_ms(l, NNG_OPT_RECONNMINT, 1), NNG_ENOTSUP);
-	TEST_NNG_FAIL(nng_listener_set_string(l, NNG_OPT_SOCKNAME, "bogus"),
+	NUTS_FAIL(nng_listener_set_bool(l, NNG_OPT_RAW, true), NNG_ENOTSUP);
+	NUTS_FAIL(nng_listener_set_ms(l, NNG_OPT_RECONNMINT, 1), NNG_ENOTSUP);
+	NUTS_FAIL(nng_listener_set_string(l, NNG_OPT_SOCKNAME, "bogus"),
 	    NNG_ENOTSUP);
 
 	// Read only options
-	TEST_NNG_FAIL(nng_listener_set_string(l, NNG_OPT_URL, "inproc://junk"),
+	NUTS_FAIL(nng_listener_set_string(l, NNG_OPT_URL, "inproc://junk"),
 	    NNG_EREADONLY);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -470,54 +454,53 @@ test_dialer_options(void)
 	nng_dialer d;
 	size_t     sz;
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
+	NUTS_OPEN(s1);
 
 #ifndef NNG_ELIDE_DEPRECATED
 	// NOTE: This test will fail if eliding deprecated behavior.
 	// Create a dialer with the specified options
-	TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 543));
-	TEST_NNG_PASS(nng_dialer_create(&d, s1, "inproc://dialer_opts"));
-	TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 543);
+	NUTS_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 543));
+	NUTS_PASS(nng_dialer_create(&d, s1, "inproc://dialer_opts"));
+	NUTS_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 543);
 
 	// Verify endpoint overrides
-	TEST_NNG_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 678));
-	TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 678);
-	TEST_NNG_PASS(nng_socket_get_size(s1, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 543);
+	NUTS_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 678));
+	NUTS_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 678);
+	NUTS_PASS(nng_socket_get_size(s1, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 543);
 
 	// And socket overrides again
-	TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 911));
-	TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 911);
+	NUTS_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 911));
+	NUTS_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 911);
 #else
-	TEST_NNG_PASS(nng_dialer_create(&d, s1, "inproc://dialer_opts"));
-	TEST_NNG_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 678));
-	TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
-	TEST_CHECK(sz == 678);
+	NUTS_PASS(nng_dialer_create(&d, s1, "inproc://dialer_opts"));
+	NUTS_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 678));
+	NUTS_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz));
+	NUTS_TRUE(sz == 678);
 #endif
 
 	// Cannot set invalid options
-	TEST_NNG_FAIL(nng_dialer_set_size(d, "BAD_OPT", 1), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
+	NUTS_FAIL(nng_dialer_set_size(d, "BAD_OPT", 1), NNG_ENOTSUP);
+	NUTS_FAIL(
 	    nng_dialer_set_bool(d, NNG_OPT_RECVMAXSZ, true), NNG_EBADTYPE);
-	TEST_NNG_FAIL(
-	    nng_dialer_set(d, NNG_OPT_RECVMAXSZ, &sz, 1), NNG_EINVAL);
+	NUTS_FAIL(nng_dialer_set(d, NNG_OPT_RECVMAXSZ, &sz, 1), NNG_EINVAL);
 
 	// Cannot set inappropriate options
-	TEST_NNG_FAIL(
+	NUTS_FAIL(
 	    nng_dialer_set_string(d, NNG_OPT_SOCKNAME, "1"), NNG_ENOTSUP);
-	TEST_NNG_FAIL(nng_dialer_set_bool(d, NNG_OPT_RAW, true), NNG_ENOTSUP);
-	TEST_NNG_FAIL(nng_dialer_set_ms(d, NNG_OPT_SENDTIMEO, 1), NNG_ENOTSUP);
-	TEST_NNG_FAIL(
+	NUTS_FAIL(nng_dialer_set_bool(d, NNG_OPT_RAW, true), NNG_ENOTSUP);
+	NUTS_FAIL(nng_dialer_set_ms(d, NNG_OPT_SENDTIMEO, 1), NNG_ENOTSUP);
+	NUTS_FAIL(
 	    nng_dialer_set_string(d, NNG_OPT_SOCKNAME, "bogus"), NNG_ENOTSUP);
 
 	// Read only options
-	TEST_NNG_FAIL(nng_dialer_set_string(d, NNG_OPT_URL, "inproc://junk"),
+	NUTS_FAIL(nng_dialer_set_string(d, NNG_OPT_URL, "inproc://junk"),
 	    NNG_EREADONLY);
 
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -532,25 +515,20 @@ test_endpoint_absent_options(void)
 	d.id = 1999;
 	l.id = 1999;
 
-	TEST_NNG_FAIL(
-	    nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 10), NNG_ENOENT);
-	TEST_NNG_FAIL(
-	    nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 10), NNG_ENOENT);
+	NUTS_FAIL(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 10), NNG_ENOENT);
+	NUTS_FAIL(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 10), NNG_ENOENT);
 
-	TEST_NNG_FAIL(nng_dialer_get_bool(d, NNG_OPT_RAW, &b), NNG_ENOENT);
-	TEST_NNG_FAIL(nng_listener_get_bool(l, NNG_OPT_RAW, &b), NNG_ENOENT);
+	NUTS_FAIL(nng_dialer_get_bool(d, NNG_OPT_RAW, &b), NNG_ENOENT);
+	NUTS_FAIL(nng_listener_get_bool(l, NNG_OPT_RAW, &b), NNG_ENOENT);
 
-	TEST_NNG_FAIL(
-	    nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &s), NNG_ENOENT);
-	TEST_NNG_FAIL(
-	    nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &s), NNG_ENOENT);
+	NUTS_FAIL(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &s), NNG_ENOENT);
+	NUTS_FAIL(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &s), NNG_ENOENT);
 
-	TEST_NNG_FAIL(nng_dialer_get_int(d, NNG_OPT_RAW, &i), NNG_ENOENT);
-	TEST_NNG_FAIL(nng_listener_get_int(l, NNG_OPT_RAW, &i), NNG_ENOENT);
+	NUTS_FAIL(nng_dialer_get_int(d, NNG_OPT_RAW, &i), NNG_ENOENT);
+	NUTS_FAIL(nng_listener_get_int(l, NNG_OPT_RAW, &i), NNG_ENOENT);
 
-	TEST_NNG_FAIL(nng_dialer_get_ms(d, NNG_OPT_RECVTIMEO, &t), NNG_ENOENT);
-	TEST_NNG_FAIL(
-	    nng_listener_get_ms(l, NNG_OPT_SENDTIMEO, &t), NNG_ENOENT);
+	NUTS_FAIL(nng_dialer_get_ms(d, NNG_OPT_RECVTIMEO, &t), NNG_ENOENT);
+	NUTS_FAIL(nng_listener_get_ms(l, NNG_OPT_SENDTIMEO, &t), NNG_ENOENT);
 }
 
 void
@@ -568,44 +546,40 @@ test_timeout_options(void)
 		NULL,
 	};
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
+	NUTS_OPEN(s1);
 	for (int i = 0; cases[i] != NULL; i++) {
 		bool b;
 		TEST_CASE(cases[i]);
 
 		// Can't receive a duration into zero bytes.
 		sz = 0;
-		TEST_NNG_FAIL(
-		    nng_socket_get(s1, cases[i], &to, &sz), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_get(s1, cases[i], &to, &sz), NNG_EINVAL);
 
 		// Type mismatches
-		TEST_NNG_FAIL(
-		    nng_socket_get_bool(s1, cases[i], &b), NNG_EBADTYPE);
+		NUTS_FAIL(nng_socket_get_bool(s1, cases[i], &b), NNG_EBADTYPE);
 		sz = 1;
-		TEST_NNG_FAIL(
-		    nng_socket_get(s1, cases[i], &b, &sz), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_get(s1, cases[i], &b, &sz), NNG_EINVAL);
 
 		// Can set a valid duration
-		TEST_NNG_PASS(nng_socket_set_ms(s1, cases[i], 1234));
-		TEST_NNG_PASS(nng_socket_get_ms(s1, cases[i], &to));
-		TEST_CHECK(to == 1234);
+		NUTS_PASS(nng_socket_set_ms(s1, cases[i], 1234));
+		NUTS_PASS(nng_socket_get_ms(s1, cases[i], &to));
+		NUTS_TRUE(to == 1234);
 
 		to = 0;
 		sz = sizeof(to);
-		TEST_NNG_PASS(nng_socket_get(s1, cases[i], &to, &sz));
-		TEST_CHECK(to == 1234);
-		TEST_CHECK(sz == sizeof(to));
+		NUTS_PASS(nng_socket_get(s1, cases[i], &to, &sz));
+		NUTS_TRUE(to == 1234);
+		NUTS_TRUE(sz == sizeof(to));
 
 		// Can't set a negative duration
-		TEST_NNG_FAIL(nng_socket_set_ms(s1, cases[i], -5), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_set_ms(s1, cases[i], -5), NNG_EINVAL);
 
 		// Can't pass a buf too small for duration
 		sz = sizeof(to) - 1;
 		to = 1;
-		TEST_NNG_FAIL(
-		    nng_socket_set(s1, cases[i], &to, sz), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_set(s1, cases[i], &to, sz), NNG_EINVAL);
 	}
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
 void
@@ -621,44 +595,44 @@ test_size_options(void)
 		NULL,
 	};
 
-	TEST_NNG_PASS(nng_pair1_open(&s1));
+	NUTS_OPEN(s1);
 	for (int i = 0; (opt = cases[i]) != NULL; i++) {
 		TEST_CASE(opt);
 
 		// Can't receive a size into zero bytes.
 		sz = 0;
-		TEST_NNG_FAIL(nng_socket_get(s1, opt, &val, &sz), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_get(s1, opt, &val, &sz), NNG_EINVAL);
 
 		// Can set a valid duration
-		TEST_NNG_PASS(nng_socket_set_size(s1, opt, 1234));
-		TEST_NNG_PASS(nng_socket_get_size(s1, opt, &val));
-		TEST_CHECK(val == 1234);
+		NUTS_PASS(nng_socket_set_size(s1, opt, 1234));
+		NUTS_PASS(nng_socket_get_size(s1, opt, &val));
+		NUTS_TRUE(val == 1234);
 
 		val = 0;
 		sz  = sizeof(val);
-		TEST_NNG_PASS(nng_socket_get(s1, opt, &val, &sz));
-		TEST_CHECK(val == 1234);
-		TEST_CHECK(sz == sizeof(val));
+		NUTS_PASS(nng_socket_get(s1, opt, &val, &sz));
+		NUTS_TRUE(val == 1234);
+		NUTS_TRUE(sz == sizeof(val));
 
 		// Can't pass a buf too small for size
 		sz  = sizeof(val) - 1;
 		val = 1;
-		TEST_NNG_FAIL(nng_socket_set(s1, opt, &val, sz), NNG_EINVAL);
+		NUTS_FAIL(nng_socket_set(s1, opt, &val, sz), NNG_EINVAL);
 
 		// We limit the limit to 4GB. Clear it if you want to
 		// ship more than 4GB at a time.
 #if defined(_WIN64) || defined(_LP64)
 		val = 0x10000u;
 		val <<= 30u;
-		TEST_NNG_FAIL(nng_socket_set_size(s1, opt, val), NNG_EINVAL);
-		TEST_NNG_PASS(nng_socket_get_size(s1, opt, &val));
-		TEST_CHECK(val == 1234);
+		NUTS_FAIL(nng_socket_set_size(s1, opt, val), NNG_EINVAL);
+		NUTS_PASS(nng_socket_get_size(s1, opt, &val));
+		NUTS_TRUE(val == 1234);
 #endif
 	}
-	TEST_NNG_PASS(nng_close(s1));
+	NUTS_CLOSE(s1);
 }
 
-TEST_LIST = {
+NUTS_TESTS = {
 	{ "recv timeout", test_recv_timeout },
 	{ "recv non-block", test_recv_nonblock },
 	{ "send timeout", test_send_timeout },